added project files

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY app/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app/ .
+
+# Create a directory for the credentials
+RUN mkdir -p /app/credentials
+
+# Expose the port
+EXPOSE 8050
+
+# Command to run the application
+# Use the default Hugging Face port 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,24 @@
+import os
+
+# Default password if not set in environment
+DEFAULT_PASSWORD = "123456"
+
+# Get password from environment variable or use default
+API_KEY = os.environ.get("API_KEY", DEFAULT_PASSWORD)
+
+# Function to validate API key
+def validate_api_key(api_key: str) -> bool:
+    """
+    Validate the provided API key against the configured key
+    
+    Args:
+        api_key: The API key to validate
+        
+    Returns:
+        bool: True if the key is valid, False otherwise
+    """
+    if not API_KEY:
+        # If no API key is configured, authentication is disabled
+        return True
+    
+    return api_key == API_KEY

app/main.py

@@ -0,0 +1,780 @@
+from fastapi import FastAPI, HTTPException, Depends, Header, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel, ConfigDict, Field
+from typing import List, Dict, Any, Optional, Union, Literal
+import base64
+import re
+import json
+import time
+import os
+import glob
+import random
+from google.oauth2 import service_account
+import config
+
+from google.genai import types
+
+from google import genai
+
+client = None
+
+app = FastAPI(title="OpenAI to Gemini Adapter")
+
+# API Key security scheme
+api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
+
+# Dependency for API key validation
+async def get_api_key(authorization: Optional[str] = Header(None)):
+    if authorization is None:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing API key. Please include 'Authorization: Bearer YOUR_API_KEY' header."
+        )
+    
+    # Check if the header starts with "Bearer "
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key format. Use 'Authorization: Bearer YOUR_API_KEY'"
+        )
+    
+    # Extract the API key
+    api_key = authorization.replace("Bearer ", "")
+    
+    # Validate the API key
+    if not config.validate_api_key(api_key):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key"
+        )
+    
+    return api_key
+
+# Credential Manager for handling multiple service accounts
+class CredentialManager:
+    def __init__(self, default_credentials_dir="/app/credentials"):
+        # Use environment variable if set, otherwise use default
+        self.credentials_dir = os.environ.get("CREDENTIALS_DIR", default_credentials_dir)
+        self.credentials_files = []
+        self.current_index = 0
+        self.credentials = None
+        self.project_id = None
+        self.load_credentials_list()
+    
+    def load_credentials_list(self):
+        """Load the list of available credential files"""
+        # Look for all .json files in the credentials directory
+        pattern = os.path.join(self.credentials_dir, "*.json")
+        self.credentials_files = glob.glob(pattern)
+        
+        if not self.credentials_files:
+            print(f"No credential files found in {self.credentials_dir}")
+            return False
+        
+        print(f"Found {len(self.credentials_files)} credential files: {[os.path.basename(f) for f in self.credentials_files]}")
+        return True
+    
+    def refresh_credentials_list(self):
+        """Refresh the list of credential files (useful if files are added/removed)"""
+        old_count = len(self.credentials_files)
+        self.load_credentials_list()
+        new_count = len(self.credentials_files)
+        
+        if old_count != new_count:
+            print(f"Credential files updated: {old_count} -> {new_count}")
+        
+        return len(self.credentials_files) > 0
+    
+    def get_next_credentials(self):
+        """Rotate to the next credential file and load it"""
+        if not self.credentials_files:
+            return None, None
+        
+        # Get the next credential file in rotation
+        file_path = self.credentials_files[self.current_index]
+        self.current_index = (self.current_index + 1) % len(self.credentials_files)
+        
+        try:
+            credentials = service_account.Credentials.from_service_account_file(file_path,scopes=['https://www.googleapis.com/auth/cloud-platform'])
+            project_id = credentials.project_id
+            print(f"Loaded credentials from {file_path} for project: {project_id}")
+            self.credentials = credentials
+            self.project_id = project_id
+            return credentials, project_id
+        except Exception as e:
+            print(f"Error loading credentials from {file_path}: {e}")
+            # Try the next file if this one fails
+            if len(self.credentials_files) > 1:
+                print("Trying next credential file...")
+                return self.get_next_credentials()
+            return None, None
+    
+    def get_random_credentials(self):
+        """Get a random credential file and load it"""
+        if not self.credentials_files:
+            return None, None
+        
+        # Choose a random credential file
+        file_path = random.choice(self.credentials_files)
+        
+        try:
+            credentials = service_account.Credentials.from_service_account_file(file_path,scopes=['https://www.googleapis.com/auth/cloud-platform'])
+            project_id = credentials.project_id
+            print(f"Loaded credentials from {file_path} for project: {project_id}")
+            self.credentials = credentials
+            self.project_id = project_id
+            return credentials, project_id
+        except Exception as e:
+            print(f"Error loading credentials from {file_path}: {e}")
+            # Try another random file if this one fails
+            if len(self.credentials_files) > 1:
+                print("Trying another credential file...")
+                return self.get_random_credentials()
+            return None, None
+
+# Initialize the credential manager
+credential_manager = CredentialManager()
+
+# Define data models
+class ImageUrl(BaseModel):
+    url: str
+
+class ContentPartImage(BaseModel):
+    type: Literal["image_url"]
+    image_url: ImageUrl
+
+class ContentPartText(BaseModel):
+    type: Literal["text"]
+    text: str
+
+class OpenAIMessage(BaseModel):
+    role: str
+    content: Union[str, List[Union[ContentPartText, ContentPartImage, Dict[str, Any]]]]
+
+class OpenAIRequest(BaseModel):
+    model: str
+    messages: List[OpenAIMessage]
+    temperature: Optional[float] = 1.0
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = 1.0
+    top_k: Optional[int] = None
+    stream: Optional[bool] = False
+    stop: Optional[List[str]] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    seed: Optional[int] = None
+    logprobs: Optional[int] = None
+    response_logprobs: Optional[bool] = None
+    n: Optional[int] = None  # Maps to candidate_count in Vertex AI
+
+    # Allow extra fields to pass through without causing validation errors
+    model_config = ConfigDict(extra='allow')
+
+# Configure authentication
+def init_vertex_ai():
+    global client # Ensure we modify the global client variable
+    try:
+        # Priority 1: Check for credentials JSON content in environment variable (Hugging Face)
+        credentials_json_str = os.environ.get("GOOGLE_CREDENTIALS_JSON")
+        if credentials_json_str:
+            try:
+                credentials_info = json.loads(credentials_json_str)
+                credentials = service_account.Credentials.from_service_account_info(credentials_info, scopes=['https://www.googleapis.com/auth/cloud-platform'])
+                project_id = credentials.project_id
+                client = genai.Client(vertexai=True, credentials=credentials, project=project_id, location="us-central1")
+                print(f"Initialized Vertex AI using GOOGLE_CREDENTIALS_JSON env var for project: {project_id}")
+                return True
+            except Exception as e:
+                print(f"Error loading credentials from GOOGLE_CREDENTIALS_JSON: {e}")
+                # Fall through to other methods if this fails
+
+        # Priority 2: Try to use the credential manager to get credentials from files
+        credentials, project_id = credential_manager.get_next_credentials()
+
+        if credentials and project_id:
+            client = genai.Client(vertexai=True, credentials=credentials, project=project_id, location="us-central1")
+            print(f"Initialized Vertex AI using Credential Manager for project: {project_id}")
+            return True
+        
+        # Priority 3: Fall back to GOOGLE_APPLICATION_CREDENTIALS environment variable (file path)
+        file_path = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS")
+        if file_path and os.path.exists(file_path):
+            try:
+                credentials = service_account.Credentials.from_service_account_file(file_path, scopes=['https://www.googleapis.com/auth/cloud-platform'])
+                project_id = credentials.project_id
+                client = genai.Client(vertexai=True, credentials=credentials, project=project_id, location="us-central1")
+                print(f"Initialized Vertex AI using GOOGLE_APPLICATION_CREDENTIALS file path for project: {project_id}")
+                return True
+            except Exception as e:
+                 print(f"Error loading credentials from GOOGLE_APPLICATION_CREDENTIALS path {file_path}: {e}")
+        
+        # If none of the methods worked
+        print(f"Error: No valid credentials found. Tried GOOGLE_CREDENTIALS_JSON, Credential Manager ({credential_manager.credentials_dir}), and GOOGLE_APPLICATION_CREDENTIALS.")
+        return False
+    except Exception as e:
+        print(f"Error initializing authentication: {e}")
+        return False
+
+# Initialize Vertex AI at startup
+@app.on_event("startup")
+async def startup_event():
+    if not init_vertex_ai():
+        print("WARNING: Failed to initialize Vertex AI authentication")
+
+# Conversion functions
+def create_gemini_prompt(messages: List[OpenAIMessage]) -> Union[str, List[Any]]:
+    """
+    Convert OpenAI messages to Gemini format.
+    Returns either a string prompt or a list of content parts if images are present.
+    """
+    # Check if any message contains image content
+    has_images = False
+    for message in messages:
+        if isinstance(message.content, list):
+            for part in message.content:
+                if isinstance(part, dict) and part.get('type') == 'image_url':
+                    has_images = True
+                    break
+                elif isinstance(part, ContentPartImage):
+                    has_images = True
+                    break
+        if has_images:
+            break
+    
+    # If no images, use the text-only format
+    if not has_images:
+        prompt = ""
+        
+        # Extract system message if present
+        system_message = None
+        for message in messages:
+            if message.role == "system":
+                # Handle both string and list[dict] content types
+                if isinstance(message.content, str):
+                    system_message = message.content
+                elif isinstance(message.content, list) and message.content and isinstance(message.content[0], dict) and 'text' in message.content[0]:
+                    system_message = message.content[0]['text']
+                else:
+                    # Handle unexpected format or raise error? For now, assume it's usable or skip.
+                    system_message = str(message.content) # Fallback, might need refinement
+                break
+        
+        # If system message exists, prepend it
+        if system_message:
+            prompt += f"System: {system_message}\n\n"
+        
+        # Add other messages
+        for message in messages:
+            if message.role == "system":
+                continue  # Already handled
+            
+            # Handle both string and list[dict] content types
+            content_text = ""
+            if isinstance(message.content, str):
+                content_text = message.content
+            elif isinstance(message.content, list) and message.content and isinstance(message.content[0], dict) and 'text' in message.content[0]:
+                content_text = message.content[0]['text']
+            else:
+                # Fallback for unexpected format
+                content_text = str(message.content)
+
+            if message.role == "user":
+                prompt += f"Human: {content_text}\n"
+            elif message.role == "assistant":
+                prompt += f"AI: {content_text}\n"
+        
+        # Add final AI prompt if last message was from user
+        if messages[-1].role == "user":
+            prompt += "AI: "
+        
+        return prompt
+    
+    # If images are present, create a list of content parts
+    gemini_contents = []
+    
+    # Extract system message if present and add it first
+    for message in messages:
+        if message.role == "system":
+            if isinstance(message.content, str):
+                gemini_contents.append(f"System: {message.content}")
+            elif isinstance(message.content, list):
+                # Extract text from system message
+                system_text = ""
+                for part in message.content:
+                    if isinstance(part, dict) and part.get('type') == 'text':
+                        system_text += part.get('text', '')
+                    elif isinstance(part, ContentPartText):
+                        system_text += part.text
+                if system_text:
+                    gemini_contents.append(f"System: {system_text}")
+            break
+    
+    # Process user and assistant messages
+    for message in messages:
+        if message.role == "system":
+            continue  # Already handled
+        
+        # For string content, add as text
+        if isinstance(message.content, str):
+            prefix = "Human: " if message.role == "user" else "AI: "
+            gemini_contents.append(f"{prefix}{message.content}")
+        
+        # For list content, process each part
+        elif isinstance(message.content, list):
+            # First collect all text parts
+            text_content = ""
+            
+            for part in message.content:
+                # Handle text parts
+                if isinstance(part, dict) and part.get('type') == 'text':
+                    text_content += part.get('text', '')
+                elif isinstance(part, ContentPartText):
+                    text_content += part.text
+            
+            # Add the combined text content if any
+            if text_content:
+                prefix = "Human: " if message.role == "user" else "AI: "
+                gemini_contents.append(f"{prefix}{text_content}")
+            
+            # Then process image parts
+            for part in message.content:
+                # Handle image parts
+                if isinstance(part, dict) and part.get('type') == 'image_url':
+                    image_url = part.get('image_url', {}).get('url', '')
+                    if image_url.startswith('data:'):
+                        # Extract mime type and base64 data
+                        mime_match = re.match(r'data:([^;]+);base64,(.+)', image_url)
+                        if mime_match:
+                            mime_type, b64_data = mime_match.groups()
+                            image_bytes = base64.b64decode(b64_data)
+                            gemini_contents.append(types.Part.from_bytes(data=image_bytes, mime_type=mime_type))
+                elif isinstance(part, ContentPartImage):
+                    image_url = part.image_url.url
+                    if image_url.startswith('data:'):
+                        # Extract mime type and base64 data
+                        mime_match = re.match(r'data:([^;]+);base64,(.+)', image_url)
+                        if mime_match:
+                            mime_type, b64_data = mime_match.groups()
+                            image_bytes = base64.b64decode(b64_data)
+                            gemini_contents.append(types.Part.from_bytes(data=image_bytes, mime_type=mime_type))
+    
+    return gemini_contents
+
+def create_generation_config(request: OpenAIRequest) -> Dict[str, Any]:
+    config = {}
+    
+    # Basic parameters that were already supported
+    if request.temperature is not None:
+        config["temperature"] = request.temperature
+    
+    if request.max_tokens is not None:
+        config["max_output_tokens"] = request.max_tokens
+    
+    if request.top_p is not None:
+        config["top_p"] = request.top_p
+    
+    if request.top_k is not None:
+        config["top_k"] = request.top_k
+    
+    if request.stop is not None:
+        config["stop_sequences"] = request.stop
+    
+    # Additional parameters with direct mappings
+    if request.presence_penalty is not None:
+        config["presence_penalty"] = request.presence_penalty
+    
+    if request.frequency_penalty is not None:
+        config["frequency_penalty"] = request.frequency_penalty
+    
+    if request.seed is not None:
+        config["seed"] = request.seed
+    
+    if request.logprobs is not None:
+        config["logprobs"] = request.logprobs
+    
+    if request.response_logprobs is not None:
+        config["response_logprobs"] = request.response_logprobs
+    
+    # Map OpenAI's 'n' parameter to Vertex AI's 'candidate_count'
+    if request.n is not None:
+        config["candidate_count"] = request.n
+    
+    return config
+
+# Response format conversion
+def convert_to_openai_format(gemini_response, model: str) -> Dict[str, Any]:
+    # Handle multiple candidates if present
+    if hasattr(gemini_response, 'candidates') and len(gemini_response.candidates) > 1:
+        choices = []
+        for i, candidate in enumerate(gemini_response.candidates):
+            choices.append({
+                "index": i,
+                "message": {
+                    "role": "assistant",
+                    "content": candidate.text
+                },
+                "finish_reason": "stop"
+            })
+    else:
+        # Handle single response (backward compatibility)
+        choices = [
+            {
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": gemini_response.text
+                },
+                "finish_reason": "stop"
+            }
+        ]
+    
+    # Include logprobs if available
+    for i, choice in enumerate(choices):
+        if hasattr(gemini_response, 'candidates') and i < len(gemini_response.candidates):
+            candidate = gemini_response.candidates[i]
+            if hasattr(candidate, 'logprobs'):
+                choice["logprobs"] = candidate.logprobs
+    
+    return {
+        "id": f"chatcmpl-{int(time.time())}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+        "usage": {
+            "prompt_tokens": 0,  # Would need token counting logic
+            "completion_tokens": 0,
+            "total_tokens": 0
+        }
+    }
+
+def convert_chunk_to_openai(chunk, model: str, response_id: str, candidate_index: int = 0) -> str:
+    chunk_content = chunk.text if hasattr(chunk, 'text') else ""
+    
+    chunk_data = {
+        "id": response_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [
+            {
+                "index": candidate_index,
+                "delta": {
+                    "content": chunk_content
+                },
+                "finish_reason": None
+            }
+        ]
+    }
+    
+    # Add logprobs if available
+    if hasattr(chunk, 'logprobs'):
+        chunk_data["choices"][0]["logprobs"] = chunk.logprobs
+    
+    return f"data: {json.dumps(chunk_data)}\n\n"
+
+def create_final_chunk(model: str, response_id: str, candidate_count: int = 1) -> str:
+    choices = []
+    for i in range(candidate_count):
+        choices.append({
+            "index": i,
+            "delta": {},
+            "finish_reason": "stop"
+        })
+    
+    final_chunk = {
+        "id": response_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices
+    }
+    
+    return f"data: {json.dumps(final_chunk)}\n\n"
+
+# /v1/models endpoint
+@app.get("/v1/models")
+async def list_models(api_key: str = Depends(get_api_key)):
+    # Based on current information for Vertex AI models
+    models = [
+        {
+            "id": "gemini-2.5-pro-exp-03-25",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.5-pro-exp-03-25",
+            "parent": None,
+        },
+        {
+            "id": "gemini-2.5-pro-exp-03-25-search",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.5-pro-exp-03-25",
+            "parent": None,
+        },
+        {
+            "id": "gemini-2.0-flash",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.0-flash",
+            "parent": None,
+        },
+        {
+            "id": "gemini-2.0-flash-search",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.0-flash",
+            "parent": None,
+        },
+        {
+            "id": "gemini-2.0-flash-lite",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.0-flash-lite",
+            "parent": None,
+        },
+        {
+            "id": "gemini-2.0-flash-lite-search",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.0-flash-lite",
+            "parent": None,
+        },
+        {
+            "id": "gemini-2.0-pro-exp-02-05",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-2.0-pro-exp-02-05",
+            "parent": None,
+        },
+        {
+            "id": "gemini-1.5-flash",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-1.5-flash",
+            "parent": None,
+        },
+        {
+            "id": "gemini-1.5-flash-8b",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-1.5-flash-8b",
+            "parent": None,
+        },
+        {
+            "id": "gemini-1.5-pro",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-1.5-pro",
+            "parent": None,
+        },
+        {
+            "id": "gemini-1.0-pro-002",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-1.0-pro-002",
+            "parent": None,
+        },
+        {
+            "id": "gemini-1.0-pro-vision-001",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-1.0-pro-vision-001",
+            "parent": None,
+        },
+        {
+            "id": "gemini-embedding-exp",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-embedding-exp",
+            "parent": None,
+        }
+    ]
+    
+    return {"object": "list", "data": models}
+
+# Main chat completion endpoint
+# OpenAI-compatible error response
+def create_openai_error_response(status_code: int, message: str, error_type: str) -> Dict[str, Any]:
+    return {
+        "error": {
+            "message": message,
+            "type": error_type,
+            "code": status_code,
+            "param": None,
+        }
+    }
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: OpenAIRequest, api_key: str = Depends(get_api_key)):
+    try:
+        # Validate model availability
+        models_response = await list_models()
+        if not request.model or not any(model["id"] == request.model for model in models_response.get("data", [])):
+            error_response = create_openai_error_response(
+                400, f"Model '{request.model}' not found", "invalid_request_error"
+            )
+            return JSONResponse(status_code=400, content=error_response)
+        
+        # Check if this is a grounded search model
+        is_grounded_search = request.model.endswith("-search")
+        
+        # Extract the base model name (remove -search suffix if present)
+        gemini_model = request.model.replace("-search", "") if is_grounded_search else request.model
+        
+        # Create generation config
+        generation_config = create_generation_config(request)
+        
+        # Get fresh credentials for this request
+        credentials, project_id = credential_manager.get_next_credentials()
+        
+        if not credentials or not project_id:
+            error_response = create_openai_error_response(
+                500, "Failed to obtain valid credentials", "server_error"
+            )
+            return JSONResponse(status_code=500, content=error_response)
+        
+        # Initialize Vertex AI with the rotated credentials
+        try:
+            # Re-initialize client for this request - credentials might have rotated
+            client = genai.Client(vertexai=True, credentials=credentials, project=project_id, location="us-central1")
+            print(f"Using credentials for project: {project_id} for this request")
+        except Exception as auth_error:
+            error_response = create_openai_error_response(
+                500, f"Failed to initialize authentication: {str(auth_error)}", "server_error"
+            )
+            return JSONResponse(status_code=500, content=error_response)
+        
+        # Initialize Gemini model
+        search_tool = types.Tool(google_search=types.GoogleSearch())
+
+        safety_settings = [
+            types.SafetySetting(
+            category="HARM_CATEGORY_HATE_SPEECH",
+            threshold="OFF"
+            ),types.SafetySetting(
+            category="HARM_CATEGORY_DANGEROUS_CONTENT",
+            threshold="OFF"
+            ),types.SafetySetting(
+            category="HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            threshold="OFF"
+            ),types.SafetySetting(
+            category="HARM_CATEGORY_HARASSMENT",
+            threshold="OFF"
+        )]
+
+        generation_config["safety_settings"] = safety_settings
+        if is_grounded_search:
+            generation_config["tools"] = [search_tool]
+                
+        # Create prompt from messages
+        prompt = create_gemini_prompt(request.messages)
+
+        if request.stream:
+            # Handle streaming response
+            async def stream_generator():
+                response_id = f"chatcmpl-{int(time.time())}"
+                candidate_count = request.n or 1
+                
+                try:
+                    # For streaming, we can only handle one candidate at a time
+                    # If multiple candidates are requested, we'll generate them sequentially
+                    for candidate_index in range(candidate_count):
+                        # Generate content with streaming
+                        # Handle both string and list content formats (for images)
+                        responses = client.models.generate_content_stream(
+                            model=gemini_model,
+                            contents=prompt,  # This can be either a string or a list of content parts
+                            config=generation_config,
+                        )
+                        
+                        # Convert and yield each chunk
+                        for response in responses:
+                            yield convert_chunk_to_openai(response, request.model, response_id, candidate_index)
+                    
+                    # Send final chunk with all candidates
+                    yield create_final_chunk(request.model, response_id, candidate_count)
+                    yield "data: [DONE]\n\n"
+                
+                except Exception as stream_error:
+                    # Format streaming errors in SSE format
+                    error_msg = f"Error during streaming: {str(stream_error)}"
+                    print(error_msg)
+                    error_response = create_openai_error_response(500, error_msg, "server_error")
+                    yield f"data: {json.dumps(error_response)}\n\n"
+                    yield "data: [DONE]\n\n"
+            
+            return StreamingResponse(
+                stream_generator(),
+                media_type="text/event-stream"
+            )
+        else:
+            # Handle non-streaming response
+            try:
+                # If multiple candidates are requested, set candidate_count
+                if request.n and request.n > 1:
+                    # Make sure generation_config has candidate_count set
+                    if "candidate_count" not in generation_config:
+                        generation_config["candidate_count"] = request.n
+                # Handle both string and list content formats (for images)
+                response = client.models.generate_content(
+                    model=gemini_model,
+                    contents=prompt,  # This can be either a string or a list of content parts
+                    config=generation_config,
+                )
+                
+                
+                openai_response = convert_to_openai_format(response, request.model)
+                return JSONResponse(content=openai_response)
+            except Exception as generate_error:
+                error_msg = f"Error generating content: {str(generate_error)}"
+                print(error_msg)
+                error_response = create_openai_error_response(500, error_msg, "server_error")
+                return JSONResponse(status_code=500, content=error_response)
+    
+    except Exception as e:
+        error_msg = f"Error processing request: {str(e)}"
+        print(error_msg)
+        error_response = create_openai_error_response(500, error_msg, "server_error")
+        return JSONResponse(status_code=500, content=error_response)
+
+# Health check endpoint
+@app.get("/health")
+def health_check(api_key: str = Depends(get_api_key)):
+    # Refresh the credentials list to get the latest status
+    credential_manager.refresh_credentials_list()
+    
+    return {
+        "status": "ok",
+        "credentials": {
+            "available": len(credential_manager.credentials_files),
+            "files": [os.path.basename(f) for f in credential_manager.credentials_files],
+            "current_index": credential_manager.current_index
+        }
+    }

app/requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.110.0
+uvicorn==0.27.1
+google-auth==2.38.0
+google-cloud-aiplatform==1.86.0
+pydantic==2.6.1
+google-genai==1.8.0

docker-compose.yml

@@ -0,0 +1,20 @@
+version: '3.8'
+
+services:
+  openai-to-gemini:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      # Map host port 8050 to container port 7860 (for Hugging Face compatibility)
+      - "8050:7860"
+    volumes:
+      - ./credentials:/app/credentials
+    environment:
+      # This is kept for backward compatibility but our app now primarily uses the credential manager
+      - GOOGLE_APPLICATION_CREDENTIALS=/app/credentials/service-account.json
+      # Directory where credential files are stored (used by credential manager)
+      - CREDENTIALS_DIR=/app/credentials
+      # API key for authentication (default: 123456)
+      - API_KEY=123456
+    restart: unless-stopped