added image and file upload support for openai

run.py

@@ -0,0 +1,5 @@
+import uvicorn
+from src.main import app
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8888)

src/auth.py

@@ -0,0 +1,420 @@
+import os
+import json
+import base64
+import time
+from datetime import datetime
+from fastapi import Request, HTTPException, Depends
+from fastapi.security import HTTPBasic
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import urlparse, parse_qs
+
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import Flow
+from google.auth.transport.requests import Request as GoogleAuthRequest
+
+from .utils import get_user_agent, get_client_metadata
+
+# --- Configuration ---
+CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"
+CLIENT_SECRET = "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"
+SCOPES = [
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile",
+]
+SCRIPT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CREDENTIAL_FILE = os.path.join(SCRIPT_DIR, "oauth_creds.json")
+CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com"
+GEMINI_AUTH_PASSWORD = os.getenv("GEMINI_AUTH_PASSWORD", "123456")  # Default password
+
+# --- Global State ---
+credentials = None
+user_project_id = None
+onboarding_complete = False
+
+security = HTTPBasic()
+
+class _OAuthCallbackHandler(BaseHTTPRequestHandler):
+    auth_code = None
+    def do_GET(self):
+        query_components = parse_qs(urlparse(self.path).query)
+        code = query_components.get("code", [None])[0]
+        if code:
+            _OAuthCallbackHandler.auth_code = code
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"<h1>Authentication successful!</h1><p>You can close this window and restart the proxy.</p>")
+        else:
+            self.send_response(400)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"<h1>Authentication failed.</h1><p>Please try again.</p>")
+
+def authenticate_user(request: Request):
+    """Authenticate the user with multiple methods."""
+    # Check for API key in query parameters first (for Gemini client compatibility)
+    api_key = request.query_params.get("key")
+    if api_key and api_key == GEMINI_AUTH_PASSWORD:
+        return "api_key_user"
+    
+    # Check for API key in x-goog-api-key header (Google SDK format)
+    goog_api_key = request.headers.get("x-goog-api-key", "")
+    if goog_api_key and goog_api_key == GEMINI_AUTH_PASSWORD:
+        return "goog_api_key_user"
+    
+    # Check for API key in Authorization header (Bearer token format)
+    auth_header = request.headers.get("authorization", "")
+    if auth_header.startswith("Bearer "):
+        bearer_token = auth_header[7:]
+        if bearer_token == GEMINI_AUTH_PASSWORD:
+            return "bearer_user"
+    
+    # Check for HTTP Basic Authentication
+    if auth_header.startswith("Basic "):
+        try:
+            encoded_credentials = auth_header[6:]
+            decoded_credentials = base64.b64decode(encoded_credentials).decode('utf-8')
+            username, password = decoded_credentials.split(':', 1)
+            if password == GEMINI_AUTH_PASSWORD:
+                return username
+        except Exception:
+            pass
+    
+    # If none of the authentication methods work
+    raise HTTPException(
+        status_code=401,
+        detail="Invalid authentication credentials. Use HTTP Basic Auth, Bearer token, 'key' query parameter, or 'x-goog-api-key' header.",
+        headers={"WWW-Authenticate": "Basic"},
+    )
+
+def save_credentials(creds, project_id=None):
+    print(f"DEBUG: Saving credentials - Token: {creds.token[:20] if creds.token else 'None'}..., Expired: {creds.expired}, Expiry: {creds.expiry}")
+    
+    creds_data = {
+        "client_id": CLIENT_ID,
+        "client_secret": CLIENT_SECRET,
+        "token": creds.token,
+        "refresh_token": creds.refresh_token,
+        "scopes": creds.scopes if creds.scopes else SCOPES,
+        "token_uri": "https://oauth2.googleapis.com/token",
+    }
+    
+    if creds.expiry:
+        if creds.expiry.tzinfo is None:
+            from datetime import timezone
+            expiry_utc = creds.expiry.replace(tzinfo=timezone.utc)
+        else:
+            expiry_utc = creds.expiry
+        creds_data["expiry"] = expiry_utc.isoformat()
+        print(f"DEBUG: Saving expiry as: {creds_data['expiry']}")
+    else:
+        print("DEBUG: No expiry time available to save")
+    
+    if project_id:
+        creds_data["project_id"] = project_id
+    elif os.path.exists(CREDENTIAL_FILE):
+        try:
+            with open(CREDENTIAL_FILE, "r") as f:
+                existing_data = json.load(f)
+                if "project_id" in existing_data:
+                    creds_data["project_id"] = existing_data["project_id"]
+        except Exception:
+            pass
+    
+    print(f"DEBUG: Final credential data to save: {json.dumps(creds_data, indent=2)}")
+    
+    with open(CREDENTIAL_FILE, "w") as f:
+        json.dump(creds_data, f, indent=2)
+    
+    print("DEBUG: Credentials saved to file")
+
+def get_credentials():
+    """Loads credentials matching gemini-cli OAuth2 flow."""
+    global credentials
+    
+    if credentials and credentials.token:
+        print("Using valid credentials from memory cache.")
+        print(f"DEBUG: Memory credentials - Token: {credentials.token[:20] if credentials.token else 'None'}..., Expired: {credentials.expired}, Expiry: {credentials.expiry}")
+        return credentials
+    else:
+        print("No valid credentials in memory. Loading from disk.")
+    
+    env_creds = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
+    if env_creds and os.path.exists(env_creds):
+        try:
+            with open(env_creds, "r") as f:
+                creds_data = json.load(f)
+            credentials = Credentials.from_authorized_user_info(creds_data, SCOPES)
+            print("Loaded credentials from GOOGLE_APPLICATION_CREDENTIALS.")
+            print(f"DEBUG: Env credentials - Token: {credentials.token[:20] if credentials.token else 'None'}..., Expired: {credentials.expired}, Expiry: {credentials.expiry}")
+            
+            if credentials.refresh_token:
+                print("Refreshing environment credentials at startup for reliability...")
+                try:
+                    credentials.refresh(GoogleAuthRequest())
+                    print("Startup token refresh successful for environment credentials.")
+                except Exception as refresh_error:
+                    print(f"Startup token refresh failed for environment credentials: {refresh_error}. Credentials may be stale.")
+            else:
+                print("No refresh token available in environment credentials - using as-is.")
+            
+            return credentials
+        except Exception as e:
+            print(f"Could not load credentials from GOOGLE_APPLICATION_CREDENTIALS: {e}")
+
+    if os.path.exists(CREDENTIAL_FILE):
+        try:
+            with open(CREDENTIAL_FILE, "r") as f:
+                creds_data = json.load(f)
+            
+            print(f"DEBUG: Raw credential data from file: {json.dumps(creds_data, indent=2)}")
+            
+            if "access_token" in creds_data and "token" not in creds_data:
+                creds_data["token"] = creds_data["access_token"]
+                print("DEBUG: Converted access_token to token field")
+            
+            if "scope" in creds_data and "scopes" not in creds_data:
+                creds_data["scopes"] = creds_data["scope"].split()
+                print("DEBUG: Converted scope string to scopes list")
+            
+            credentials = Credentials.from_authorized_user_info(creds_data, SCOPES)
+            print("Loaded credentials from cache.")
+            print(f"DEBUG: Loaded credentials - Token: {credentials.token[:20] if credentials.token else 'None'}..., Expired: {credentials.expired}, Expiry: {credentials.expiry}")
+            
+            if credentials.refresh_token:
+                print("Refreshing tokens at startup for reliability...")
+                try:
+                    credentials.refresh(GoogleAuthRequest())
+                    save_credentials(credentials)
+                    print("Startup token refresh successful.")
+                except Exception as refresh_error:
+                    print(f"Startup token refresh failed: {refresh_error}. Credentials may be stale.")
+            else:
+                print("No refresh token available - using cached credentials as-is.")
+            
+            return credentials
+        except Exception as e:
+            print(f"Could not load cached credentials: {e}. Starting new login.")
+
+    client_config = {
+        "installed": {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+        }
+    }
+    
+    flow = Flow.from_client_config(
+        client_config,
+        scopes=SCOPES,
+        redirect_uri="http://localhost:8080"
+    )
+    
+    flow.oauth2session.scope = SCOPES
+    
+    auth_url, _ = flow.authorization_url(
+        access_type="offline",
+        prompt="consent",
+        include_granted_scopes='true'
+    )
+    print(f"\nPlease open this URL in your browser to log in:\n{auth_url}\n")
+    
+    server = HTTPServer(("", 8080), _OAuthCallbackHandler)
+    server.handle_request()
+    
+    auth_code = _OAuthCallbackHandler.auth_code
+    if not auth_code:
+        print("Failed to retrieve authorization code.")
+        return None
+
+    import oauthlib.oauth2.rfc6749.parameters
+    original_validate = oauthlib.oauth2.rfc6749.parameters.validate_token_parameters
+    
+    def patched_validate(params):
+        try:
+            return original_validate(params)
+        except Warning:
+            pass
+    
+    oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = patched_validate
+    
+    try:
+        flow.fetch_token(code=auth_code)
+        credentials = flow.credentials
+        save_credentials(credentials)
+        print("Authentication successful! Credentials saved.")
+        return credentials
+    except Exception as e:
+        print(f"Authentication failed: {e}")
+        return None
+    finally:
+        oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = original_validate
+
+def onboard_user(creds, project_id):
+    """Ensures the user is onboarded, matching gemini-cli setupUser behavior."""
+    global onboarding_complete
+    if onboarding_complete:
+        return
+
+    if creds.expired and creds.refresh_token:
+        print("Credentials expired. Refreshing before onboarding...")
+        try:
+            creds.refresh(GoogleAuthRequest())
+            save_credentials(creds)
+            print("Credentials refreshed successfully.")
+        except Exception as e:
+            print(f"Could not refresh credentials: {e}")
+            raise
+
+    print("Checking user onboarding status...")
+    headers = {
+        "Authorization": f"Bearer {creds.token}",
+        "Content-Type": "application/json",
+        "User-Agent": get_user_agent(),
+    }
+    
+    load_assist_payload = {
+        "cloudaicompanionProject": project_id,
+        "metadata": get_client_metadata(project_id),
+    }
+    
+    try:
+        import requests
+        resp = requests.post(
+            f"{CODE_ASSIST_ENDPOINT}/v1internal:loadCodeAssist",
+            data=json.dumps(load_assist_payload),
+            headers=headers,
+        )
+        resp.raise_for_status()
+        load_data = resp.json()
+        
+        tier = None
+        if load_data.get("currentTier"):
+            tier = load_data["currentTier"]
+            print("User is already onboarded.")
+        else:
+            for allowed_tier in load_data.get("allowedTiers", []):
+                if allowed_tier.get("isDefault"):
+                    tier = allowed_tier
+                    break
+            
+            if not tier:
+                tier = {
+                    "name": "",
+                    "description": "",
+                    "id": "legacy-tier",
+                    "userDefinedCloudaicompanionProject": True,
+                }
+
+        if tier.get("userDefinedCloudaicompanionProject") and not project_id:
+            raise ValueError("This account requires setting the GOOGLE_CLOUD_PROJECT env var.")
+
+        if load_data.get("currentTier"):
+            onboarding_complete = True
+            return
+
+        print(f"Onboarding user to tier: {tier.get('name', 'legacy-tier')}")
+        onboard_req_payload = {
+            "tierId": tier.get("id"),
+            "cloudaicompanionProject": project_id,
+            "metadata": get_client_metadata(project_id),
+        }
+
+        while True:
+            onboard_resp = requests.post(
+                f"{CODE_ASSIST_ENDPOINT}/v1internal:onboardUser",
+                data=json.dumps(onboard_req_payload),
+                headers=headers,
+            )
+            onboard_resp.raise_for_status()
+            lro_data = onboard_resp.json()
+
+            if lro_data.get("done"):
+                print("Onboarding successful.")
+                onboarding_complete = True
+                break
+            
+            print("Onboarding in progress, waiting 5 seconds...")
+            time.sleep(5)
+
+    except requests.exceptions.HTTPError as e:
+        print(f"Error during onboarding: {e.response.text}")
+        raise
+
+def get_user_project_id(creds):
+    """Gets the user's project ID matching gemini-cli setupUser logic."""
+    global user_project_id
+    if user_project_id:
+        return user_project_id
+
+    env_project_id = os.getenv("GOOGLE_CLOUD_PROJECT")
+    if env_project_id:
+        user_project_id = env_project_id
+        print(f"Using project ID from GOOGLE_CLOUD_PROJECT: {user_project_id}")
+        save_credentials(creds, user_project_id)
+        return user_project_id
+
+    gemini_env_project_id = os.getenv("GEMINI_PROJECT_ID")
+    if gemini_env_project_id:
+        user_project_id = gemini_env_project_id
+        print(f"Using project ID from GEMINI_PROJECT_ID: {user_project_id}")
+        save_credentials(creds, user_project_id)
+        return user_project_id
+
+    if os.path.exists(CREDENTIAL_FILE):
+        try:
+            with open(CREDENTIAL_FILE, "r") as f:
+                creds_data = json.load(f)
+                cached_project_id = creds_data.get("project_id")
+                if cached_project_id:
+                    user_project_id = cached_project_id
+                    print(f"Loaded project ID from cache: {user_project_id}")
+                    return user_project_id
+        except Exception as e:
+            print(f"Could not load project ID from cache: {e}")
+
+    print("Project ID not found in environment or cache. Probing for user project ID...")
+    
+    if creds.expired and creds.refresh_token:
+        print("Credentials expired. Refreshing before project ID probe...")
+        try:
+            creds.refresh(GoogleAuthRequest())
+            save_credentials(creds)
+            print("Credentials refreshed successfully.")
+        except Exception as e:
+            print(f"Could not refresh credentials: {e}")
+            raise
+    
+    headers = {
+        "Authorization": f"Bearer {creds.token}",
+        "Content-Type": "application/json",
+        "User-Agent": get_user_agent(),
+    }
+    
+    probe_payload = {
+        "metadata": get_client_metadata(),
+    }
+
+    try:
+        import requests
+        resp = requests.post(
+            f"{CODE_ASSIST_ENDPOINT}/v1internal:loadCodeAssist",
+            data=json.dumps(probe_payload),
+            headers=headers,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        user_project_id = data.get("cloudaicompanionProject")
+        if not user_project_id:
+            raise ValueError("Could not find 'cloudaicompanionProject' in loadCodeAssist response.")
+        print(f"Successfully fetched user project ID: {user_project_id}")
+        
+        save_credentials(creds, user_project_id)
+        print("Project ID saved to credential file for future use.")
+        
+        return user_project_id
+    except requests.exceptions.HTTPError as e:
+        print(f"Error fetching project ID: {e.response.text}")
+        raise

src/gemini.py

@@ -0,0 +1,228 @@
+import json
+import requests
+from fastapi import APIRouter, Request, Response, Depends
+
+from .auth import authenticate_user, get_credentials, get_user_project_id, onboard_user, save_credentials
+from .utils import get_user_agent
+from .gemini_request_builder import build_gemini_request
+from .gemini_response_handler import handle_gemini_response
+
+CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com"
+
+router = APIRouter()
+
+@router.get("/v1beta/models")
+async def list_models(request: Request, username: str = Depends(authenticate_user)):
+    """List available models - matching gemini-cli supported models exactly."""
+    print(f"[GET] {request.url.path} - User: {username}")
+    print(f"[MODELS] Serving models list (both /v1/models and /v1beta/models return the same data)")
+    
+    models_response = {
+        "models": [
+            {
+                "name": "models/gemini-1.5-pro",
+                "version": "001",
+                "displayName": "Gemini 1.5 Pro",
+                "description": "Mid-size multimodal model that supports up to 2 million tokens",
+                "inputTokenLimit": 2097152,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-1.5-flash",
+                "version": "001",
+                "displayName": "Gemini 1.5 Flash",
+                "description": "Fast and versatile multimodal model for scaling across diverse tasks",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.5-pro-preview-05-06",
+                "version": "001",
+                "displayName": "Gemini 2.5 Pro Preview 05-06",
+                "description": "Preview version of Gemini 2.5 Pro from May 6th",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.5-pro-preview-06-05",
+                "version": "001",
+                "displayName": "Gemini 2.5 Pro Preview 06-05",
+                "description": "Preview version of Gemini 2.5 Pro from June 5th",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.5-pro",
+                "version": "001",
+                "displayName": "Gemini 2.5 Pro",
+                "description": "Advanced multimodal model with enhanced capabilities",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.5-flash-preview-05-20",
+                "version": "001",
+                "displayName": "Gemini 2.5 Flash Preview 05-20",
+                "description": "Preview version of Gemini 2.5 Flash from May 20th",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.5-flash",
+                "version": "001",
+                "displayName": "Gemini 2.5 Flash",
+                "description": "Fast and efficient multimodal model with latest improvements",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.0-flash",
+                "version": "001",
+                "displayName": "Gemini 2.0 Flash",
+                "description": "Latest generation fast multimodal model",
+                "inputTokenLimit": 1048576,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-2.0-flash-preview-image-generation",
+                "version": "001",
+                "displayName": "Gemini 2.0 Flash Preview Image Generation",
+                "description": "Preview version with image generation capabilities",
+                "inputTokenLimit": 32000,
+                "outputTokenLimit": 8192,
+                "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+                "temperature": 1.0,
+                "maxTemperature": 2.0,
+                "topP": 0.95,
+                "topK": 64
+            },
+            {
+                "name": "models/gemini-embedding-001",
+                "version": "001",
+                "displayName": "Gemini Embedding 001",
+                "description": "Text embedding model for semantic similarity and search",
+                "inputTokenLimit": 2048,
+                "outputTokenLimit": 1,
+                "supportedGenerationMethods": ["embedContent"],
+                "temperature": 0.0,
+                "maxTemperature": 0.0,
+                "topP": 1.0,
+                "topK": 1
+            }
+        ]
+    }
+    
+    return Response(content=json.dumps(models_response), status_code=200, media_type="application/json; charset=utf-8")
+
+async def proxy_request(post_data: bytes, full_path: str, username: str, method: str, query_params: dict, is_openai: bool = False, is_streaming: bool = False):
+    print(f"[{method}] /{full_path} - User: {username}")
+    
+    creds = get_credentials()
+    if not creds:
+        print("❌ No credentials available")
+        return Response(content="Authentication failed. Please restart the proxy to log in.", status_code=500)
+    
+    print(f"Using credentials - Token: {creds.token[:20] if creds.token else 'None'}..., Expired: {creds.expired}")
+
+    if creds.expired and creds.refresh_token:
+        print("Credentials expired. Refreshing...")
+        try:
+            from google.auth.transport.requests import Request as GoogleAuthRequest
+            creds.refresh(GoogleAuthRequest())
+            save_credentials(creds)
+            print("Credentials refreshed successfully.")
+        except Exception as e:
+            print(f"Could not refresh token during request: {e}")
+            return Response(content="Token refresh failed. Please restart the proxy to re-authenticate.", status_code=500)
+    elif not creds.token:
+        print("No access token available.")
+        return Response(content="No access token. Please restart the proxy to re-authenticate.", status_code=500)
+
+    proj_id = get_user_project_id(creds)
+    if not proj_id:
+        return Response(content="Failed to get user project ID.", status_code=500)
+    
+    onboard_user(creds, proj_id)
+
+    if is_openai:
+        target_url, final_post_data, request_headers, _ = build_gemini_request(post_data, full_path, creds, is_streaming)
+    else:
+        action = "streamGenerateContent" if is_streaming else "generateContent"
+        target_url = f"{CODE_ASSIST_ENDPOINT}/v1internal:{action}" + "?alt=sse"
+        
+        try:
+            incoming_json = json.loads(post_data)
+        except (json.JSONDecodeError, AttributeError):
+            incoming_json = {}
+            
+        final_post_data = json.dumps({
+            "model": full_path.split('/')[2].split(':')[0],
+            "project": proj_id,
+            "request": incoming_json,
+        })
+        
+        request_headers = {
+            "Authorization": f"Bearer {creds.token}",
+            "Content-Type": "application/json",
+            "User-Agent": get_user_agent(),
+        }
+
+
+    if is_streaming:
+        print(f"STREAMING REQUEST to: {target_url}")
+        print(f"STREAMING REQUEST PAYLOAD: {final_post_data}")
+        resp = requests.post(target_url, data=final_post_data, headers=request_headers, stream=True)
+        print(f"STREAMING RESPONSE: {resp.status_code}")
+        return handle_gemini_response(resp, is_streaming=True)
+    else:
+        print(f"REQUEST to: {target_url}")
+        print(f"REQUEST PAYLOAD: {final_post_data}")
+        resp = requests.post(target_url, data=final_post_data, headers=request_headers)
+        print(f"RESPONSE: {resp.status_code}, {resp.text}")
+        return handle_gemini_response(resp, is_streaming=False)
+
+@router.api_route("/{full_path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+async def proxy(request: Request, full_path: str, username: str = Depends(authenticate_user)):
+    post_data = await request.body()
+    is_streaming = "stream" in full_path
+    return await proxy_request(post_data, full_path, username, request.method, dict(request.query_params), is_streaming=is_streaming)

src/gemini_request_builder.py

@@ -0,0 +1,68 @@
+import json
+import re
+
+from .auth import get_user_project_id
+from .utils import get_user_agent
+
+CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com"
+
+def build_gemini_request(post_data: bytes, full_path: str, creds, is_streaming: bool = False):
+    try:
+        incoming_json = json.loads(post_data)
+    except (json.JSONDecodeError, AttributeError):
+        incoming_json = {}
+
+    # Set the action based on streaming
+    action = "streamGenerateContent" if is_streaming else "generateContent"
+
+    # The target URL is always one of two values
+    target_url = f"{CODE_ASSIST_ENDPOINT}/v1internal:{action}"
+    
+    if is_streaming:
+        target_url += "?alt=sse"
+
+    # Extract model from the incoming JSON payload
+    final_model = incoming_json.get("model")
+
+    # Default safety settings if not provided
+    safety_settings = incoming_json.get("safetySettings")
+    if not safety_settings:
+        safety_settings = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "BLOCK_NONE"}
+        ]
+
+    # Build the final payload for the Google API
+    structured_payload = {
+        "model": final_model,
+        "project": get_user_project_id(creds),
+        "request": {
+            "contents": incoming_json.get("contents"),
+            "systemInstruction": incoming_json.get("systemInstruction"),
+            "cachedContent": incoming_json.get("cachedContent"),
+            "tools": incoming_json.get("tools"),
+            "toolConfig": incoming_json.get("toolConfig"),
+            "safetySettings": safety_settings,
+            "generationConfig": incoming_json.get("generationConfig", {}),
+        },
+    }
+    # Remove any keys with None values from the request
+    structured_payload["request"] = {
+        k: v
+        for k, v in structured_payload["request"].items()
+        if v is not None
+    }
+    
+    final_post_data = json.dumps(structured_payload)
+
+    # Build the request headers
+    request_headers = {
+        "Authorization": f"Bearer {creds.token}",
+        "Content-Type": "application/json",
+        "User-Agent": get_user_agent(),
+    }
+
+    return target_url, final_post_data, request_headers, is_streaming

src/gemini_response_handler.py

@@ -0,0 +1,73 @@
+import json
+import requests
+from fastapi import Response
+from fastapi.responses import StreamingResponse
+import asyncio
+
+def handle_gemini_response(resp, is_streaming):
+    if is_streaming:
+        async def stream_generator():
+            try:
+                with resp:
+                    resp.raise_for_status()
+                    
+                    print("[STREAM] Processing with Gemini SDK-compatible logic")
+                    
+                    for chunk in resp.iter_lines():
+                        if chunk:
+                            if not isinstance(chunk, str):
+                                chunk = chunk.decode('utf-8')
+                                
+                            print(chunk)
+                                                        
+                            if chunk.startswith('data: '):
+                                chunk = chunk[len('data: '):]
+                                
+                                try:
+                                    obj = json.loads(chunk)
+                                    
+                                    if "response" in obj:
+                                        response_chunk = obj["response"]
+                                        response_json = json.dumps(response_chunk, separators=(',', ':'))
+                                        response_line = f"data: {response_json}\n\n"
+                                        yield response_line
+                                        await asyncio.sleep(0)
+                                except json.JSONDecodeError:
+                                    continue
+                    
+            except requests.exceptions.RequestException as e:
+                print(f"Error during streaming request: {e}")
+                yield f'data: {{"error": {{"message": "Upstream request failed: {str(e)}"}}}}\n\n'.encode('utf-8')
+            except Exception as e:
+                print(f"An unexpected error occurred during streaming: {e}")
+                yield f'data: {{"error": {{"message": "An unexpected error occurred: {str(e)}"}}}}\n\n'.encode('utf-8')
+
+        response_headers = {
+            "Content-Type": "text/event-stream",
+            "Content-Disposition": "attachment",
+            "Vary": "Origin, X-Origin, Referer",
+            "X-XSS-Protection": "0",
+            "X-Frame-Options": "SAMEORIGIN",
+            "X-Content-Type-Options": "nosniff",
+            "Server": "ESF"
+        }
+        
+        return StreamingResponse(
+            stream_generator(),
+            media_type="text/event-stream",
+            headers=response_headers
+        )
+    else:
+        if resp.status_code == 200:
+            try:
+                google_api_response = resp.text
+                if google_api_response.startswith('data: '):
+                    google_api_response = google_api_response[len('data: '):]
+                google_api_response = json.loads(google_api_response)
+                standard_gemini_response = google_api_response.get("response")
+                return Response(content=json.dumps(standard_gemini_response), status_code=200, media_type="application/json; charset=utf-8")
+            except (json.JSONDecodeError, AttributeError) as e:
+                print(f"Error converting to standard Gemini format: {e}")
+                return Response(content=resp.content, status_code=resp.status_code, media_type=resp.headers.get("Content-Type"))
+        else:
+            return Response(content=resp.content, status_code=resp.status_code, media_type=resp.headers.get("Content-Type"))

src/main.py

@@ -0,0 +1,47 @@
+from fastapi import FastAPI, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from .gemini import router as gemini_router
+from .openai import router as openai_router
+from .auth import get_credentials, get_user_project_id, onboard_user
+
+app = FastAPI()
+
+# Add CORS middleware for preflight requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allow all methods
+    allow_headers=["*"],  # Allow all headers
+)
+
+@app.on_event("startup")
+async def startup_event():
+    print("Initializing credentials...")
+    creds = get_credentials()
+    if creds:
+        proj_id = get_user_project_id(creds)
+        if proj_id:
+            onboard_user(creds, proj_id)
+        print(f"\nStarting Gemini proxy server")
+        print("Send your Gemini API requests to this address.")
+        print(f"Authentication required - Password: see .env file")
+        print("Use HTTP Basic Authentication with any username and the password above.")
+    else:
+        print("\nCould not obtain credentials. Please authenticate and restart the server.")
+
+@app.options("/{full_path:path}")
+async def handle_preflight(request: Request, full_path: str):
+    """Handle CORS preflight requests without authentication."""
+    return Response(
+        status_code=200,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+            "Access-Control-Allow-Headers": "*",
+            "Access-Control-Allow-Credentials": "true",
+        }
+    )
+
+app.include_router(openai_router)
+app.include_router(gemini_router)

src/models.py

@@ -0,0 +1,61 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Union, Dict, Any
+
+# OpenAI Models
+class OpenAIChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]]]
+
+class OpenAIChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[OpenAIChatMessage]
+    stream: bool = False
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+class OpenAIChatCompletionChoice(BaseModel):
+    index: int
+    message: OpenAIChatMessage
+    finish_reason: Optional[str] = None
+
+class OpenAIChatCompletionResponse(BaseModel):
+    id: str
+    object: str
+    created: int
+    model: str
+    choices: List[OpenAIChatCompletionChoice]
+
+class OpenAIDelta(BaseModel):
+    content: Optional[str] = None
+
+class OpenAIChatCompletionStreamChoice(BaseModel):
+    index: int
+    delta: OpenAIDelta
+    finish_reason: Optional[str] = None
+
+class OpenAIChatCompletionStreamResponse(BaseModel):
+    id: str
+    object: str
+    created: int
+    model: str
+    choices: List[OpenAIChatCompletionStreamChoice]
+
+# Gemini Models
+class GeminiPart(BaseModel):
+    text: str
+
+class GeminiContent(BaseModel):
+    role: str
+    parts: List[GeminiPart]
+
+class GeminiRequest(BaseModel):
+    contents: List[GeminiContent]
+
+class GeminiCandidate(BaseModel):
+    content: GeminiContent
+    finish_reason: Optional[str] = None
+    index: int
+
+class GeminiResponse(BaseModel):
+    candidates: List[GeminiCandidate]

src/openai.py

@@ -0,0 +1,184 @@
+import json
+import time
+import uuid
+from fastapi import APIRouter, Request, Response, Depends
+from fastapi.responses import StreamingResponse
+
+from .auth import authenticate_user
+from .models import OpenAIChatCompletionRequest, OpenAIChatCompletionResponse, OpenAIChatCompletionStreamResponse, OpenAIChatMessage, OpenAIChatCompletionChoice, OpenAIChatCompletionStreamChoice, OpenAIDelta, GeminiRequest, GeminiContent, GeminiPart, GeminiResponse
+from .gemini import proxy_request
+
+import asyncio
+
+router = APIRouter()
+
+def openai_to_gemini(openai_request: OpenAIChatCompletionRequest) -> dict:
+    contents = []
+    for message in openai_request.messages:
+        role = message.role
+        if role == "assistant":
+            role = "model"
+        if role == "system":
+            role = "user"
+        if isinstance(message.content, list):
+            parts = []
+            for part in message.content:
+                if part.get("type") == "text":
+                    parts.append({"text": part.get("text", "")})
+                elif part.get("type") == "image_url":
+                    image_url = part.get("image_url", {}).get("url")
+                    if image_url:
+                        # Assuming the image_url is a base64 encoded string
+                        # "data:image/jpeg;base64,{base64_image}"
+                        mime_type, base64_data = image_url.split(";")
+                        _, mime_type = mime_type.split(":")
+                        _, base64_data = base64_data.split(",")
+                        parts.append({
+                            "inlineData": {
+                                "mimeType": mime_type,
+                                "data": base64_data
+                            }
+                        })
+            contents.append({"role": role, "parts": parts})
+        else:
+            contents.append({"role": role, "parts": [{"text": message.content}]})
+    
+    generation_config = {}
+    if openai_request.temperature is not None:
+        generation_config["temperature"] = openai_request.temperature
+    if openai_request.top_p is not None:
+        generation_config["topP"] = openai_request.top_p
+    if openai_request.max_tokens is not None:
+        generation_config["maxOutputTokens"] = openai_request.max_tokens
+
+    safety_settings = [
+        {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+        {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+        {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+        {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "BLOCK_NONE"}
+    ]
+
+    return {
+        "contents": contents,
+        "generationConfig": generation_config,
+        "safetySettings": safety_settings,
+        "model": openai_request.model
+    }
+
+def gemini_to_openai(gemini_response: dict, model: str) -> OpenAIChatCompletionResponse:
+    choices = []
+    for candidate in gemini_response.get("candidates", []):
+        role = candidate.get("content", {}).get("role", "assistant")
+        if role == "model":
+            role = "assistant"
+        choices.append(
+            {
+                "index": candidate.get("index"),
+                "message": {
+                    "role": role,
+                    "content": candidate.get("content", {}).get("parts", [{}])[0].get("text"),
+                },
+                "finish_reason": map_finish_reason(candidate.get("finishReason")),
+            }
+        )
+    return {
+        "id": str(uuid.uuid4()),
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+
+def gemini_to_openai_stream(gemini_response: dict, model: str, response_id: str) -> dict:
+    choices = []
+    for candidate in gemini_response.get("candidates", []):
+        role = candidate.get("content", {}).get("role", "assistant")
+        if role == "model":
+            role = "assistant"
+        choices.append(
+            {
+                "index": candidate.get("index"),
+                "delta": {
+                    "content": candidate.get("content", {}).get("parts", [{}])[0].get("text"),
+                },
+                "finish_reason": map_finish_reason(candidate.get("finishReason")),
+            }
+        )
+    return {
+        "id": response_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+
+def map_finish_reason(reason: str) -> str:
+    if reason == "STOP":
+        return "stop"
+    elif reason == "MAX_TOKENS":
+        return "length"
+    elif reason in ["SAFETY", "RECITATION"]:
+        return "content_filter"
+    else:
+        return None
+
+@router.post("/v1/chat/completions")
+async def chat_completions(request: OpenAIChatCompletionRequest, http_request: Request, username: str = Depends(authenticate_user)):
+    gemini_request = openai_to_gemini(request)
+    
+    if request.stream:
+        async def stream_generator():
+            response = await proxy_request(json.dumps(gemini_request).encode('utf-8'), http_request.url.path, username, "POST", dict(http_request.query_params), is_openai=True, is_streaming=True)
+            if isinstance(response, StreamingResponse):
+                response_id = "chatcmpl-realstream-" + str(uuid.uuid4())
+                async for chunk in response.body_iterator:
+                    if chunk.startswith('data: '):
+                        try:
+                            data = json.loads(chunk[6:])
+                            openai_response = gemini_to_openai_stream(data, request.model, response_id)
+                            yield f"data: {json.dumps(openai_response)}\n\n"
+                            await asyncio.sleep(0)
+                        except (json.JSONDecodeError, KeyError):
+                            continue
+                yield "data: [DONE]\n\n"
+            else:
+                yield f"data: {response.body.decode()}\n\n"
+                yield "data: [DONE]\n\n"
+
+        return StreamingResponse(stream_generator(), media_type="text/event-stream")
+    else:
+        response = await proxy_request(json.dumps(gemini_request).encode('utf-8'), http_request.url.path, username, "POST", dict(http_request.query_params), is_openai=True, is_streaming=False)
+        if isinstance(response, Response) and response.status_code != 200:
+            return response
+        gemini_response = json.loads(response.body)
+        openai_response = gemini_to_openai(gemini_response, request.model)
+        return openai_response
+    
+
+async def event_generator():
+    """
+    A generator function that yields a message in the Server-Sent Event (SSE)
+    format every second, five times.
+    """
+    count = 0
+    while count < 5:
+        # SSE format is "data: <content>\n\n"
+        # The two newlines are crucial as they mark the end of an event.
+        yield "data: 1\n\n"
+        
+        # Log to the server console to see it working on the backend
+        count += 1
+        print(f"Sent chunk {count}/5")
+
+        # Wait for 1 second
+        await asyncio.sleep(1)
+
+@router.post("/v1/test")
+async def stream_data(request: OpenAIChatCompletionRequest, http_request: Request, username: str = Depends(authenticate_user)):
+    """
+    This endpoint returns a streaming response.
+    It uses the event_generator to send data chunks.
+    The media_type is 'text/event-stream' which is standard for SSE.
+    """
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

src/utils.py

@@ -0,0 +1,39 @@
+import platform
+
+CLI_VERSION = "0.1.5"  # Match current gemini-cli version
+
+def get_user_agent():
+    """Generate User-Agent string matching gemini-cli format."""
+    version = CLI_VERSION
+    system = platform.system()
+    arch = platform.machine()
+    return f"GeminiCLI/{version} ({system}; {arch})"
+
+def get_platform_string():
+    """Generate platform string matching gemini-cli format."""
+    system = platform.system().upper()
+    arch = platform.machine().upper()
+    
+    # Map to gemini-cli platform format
+    if system == "DARWIN":
+        if arch in ["ARM64", "AARCH64"]:
+            return "DARWIN_ARM64"
+        else:
+            return "DARWIN_AMD64"
+    elif system == "LINUX":
+        if arch in ["ARM64", "AARCH64"]:
+            return "LINUX_ARM64"
+        else:
+            return "LINUX_AMD64"
+    elif system == "WINDOWS":
+        return "WINDOWS_AMD64"
+    else:
+        return "PLATFORM_UNSPECIFIED"
+
+def get_client_metadata(project_id=None):
+    return {
+        "ideType": "IDE_UNSPECIFIED",
+        "platform": get_platform_string(),
+        "pluginType": "GEMINI",
+        "duetProject": project_id,
+    }