added dynamic model list

app/config.py

@@ -19,4 +19,7 @@ VERTEX_EXPRESS_API_KEY_VAL = os.environ.get("VERTEX_EXPRESS_API_KEY")
 FAKE_STREAMING_ENABLED = os.environ.get("FAKE_STREAMING", "false").lower() == "true"
 FAKE_STREAMING_INTERVAL_SECONDS = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1.0"))
 
+# URL for the remote JSON file containing model lists
+MODELS_CONFIG_URL = os.environ.get("MODELS_CONFIG_URL", "https://gist.githubusercontent.com/gzzhongqi/e0b684f319437a859bcf5bd6203fd1f6/raw")
+
 # Validation logic moved to app/auth.py

app/main.py

@@ -35,8 +35,8 @@ app.include_router(chat_api.router)
 
 @app.on_event("startup")
 async def startup_event():
-    if init_vertex_ai(credential_manager):
-        print("INFO: Fallback Vertex AI client initialization check completed successfully.")
+    if await init_vertex_ai(credential_manager): # Added await
+        print("INFO: Vertex AI credential and model config initialization check completed successfully.")
     else:
         print("ERROR: Failed to initialize a fallback Vertex AI client. API will likely fail.")
 

app/requirements.txt

@@ -3,4 +3,5 @@ uvicorn==0.27.1
 google-auth==2.38.0
 google-cloud-aiplatform==1.86.0
 pydantic==2.6.1
-google-genai==1.13.0
+google-genai==1.13.0
+httpx>=0.25.0

app/routes/chat_api.py

@@ -1,6 +1,6 @@
 import asyncio
 import json # Needed for error streaming
-from fastapi import APIRouter, Depends, Request # Added Request
+from fastapi import APIRouter, Depends, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 from typing import List, Dict, Any
 
@@ -8,12 +8,12 @@ from typing import List, Dict, Any
 from google.genai import types
 from google import genai
 
-# Local module imports (now absolute from app/ perspective)
+# Local module imports
 from models import OpenAIRequest, OpenAIMessage
 from auth import get_api_key
-# from main import credential_manager # Removed, will use request.app.state
+# from main import credential_manager # Removed to prevent circular import; accessed via request.app.state
 import config as app_config
-from vertex_ai_init import VERTEX_EXPRESS_MODELS
+from model_loader import get_vertex_models, get_vertex_express_models # Import from model_loader
 from message_processing import (
     create_gemini_prompt,
     create_encrypted_gemini_prompt,
@@ -27,12 +27,40 @@ from api_helpers import (
 
 router = APIRouter()
 
-
 @router.post("/v1/chat/completions")
 async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api_key: str = Depends(get_api_key)):
     try:
-        # Access credential_manager from app state
         credential_manager_instance = fastapi_request.app.state.credential_manager
+        
+        # Dynamically fetch allowed models for validation
+        vertex_model_ids = await get_vertex_models()
+        # Suffixes that can be appended to base models.
+        # The remote model config should ideally be the source of truth for all valid permutations.
+        standard_suffixes = ["-search", "-encrypt", "-encrypt-full", "-auto"]
+        # No longer using special_suffix_map, will use prefix check instead
+
+        all_allowed_model_ids = set(vertex_model_ids) # Start with base models from config
+        for base_id in vertex_model_ids: # Iterate over base models to add suffixed versions
+            # Apply standard suffixes only if not gemini-2.0
+            if not base_id.startswith("gemini-2.0"):
+                for suffix in standard_suffixes:
+                    all_allowed_model_ids.add(f"{base_id}{suffix}")
+            
+            # Apply special suffixes for models starting with "gemini-2.5-flash"
+            if base_id.startswith("gemini-2.5-flash"):
+                special_flash_suffixes = ["-nothinking", "-max"]
+                for special_suffix in special_flash_suffixes:
+                    all_allowed_model_ids.add(f"{base_id}{special_suffix}")
+        
+        # Add express models to the allowed list as well.
+        # These should be full names from the remote config.
+        vertex_express_model_ids = await get_vertex_express_models()
+        all_allowed_model_ids.update(vertex_express_model_ids)
+
+
+        if not request.model or request.model not in all_allowed_model_ids:
+            return JSONResponse(status_code=400, content=create_openai_error_response(400, f"Model '{request.model}' not found or not supported by this adapter. Valid models are: {sorted(list(all_allowed_model_ids))}", "invalid_request_error"))
+
         is_auto_model = request.model.endswith("-auto")
         is_grounded_search = request.model.endswith("-search")
         is_encrypted_model = request.model.endswith("-encrypt")
@@ -41,18 +69,28 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
         is_max_thinking_model = request.model.endswith("-max")
         base_model_name = request.model
 
-        if is_auto_model: base_model_name = request.model.replace("-auto", "")
-        elif is_grounded_search: base_model_name = request.model.replace("-search", "")
-        elif is_encrypted_model: base_model_name = request.model.replace("-encrypt", "")
-        elif is_encrypted_full_model: base_model_name = request.model.replace("-encrypt-full", "")
-        elif is_nothinking_model: base_model_name = request.model.replace("-nothinking","")
-        elif is_max_thinking_model: base_model_name = request.model.replace("-max","")
+        # Determine base_model_name by stripping known suffixes
+        # This order matters if a model could have multiple (e.g. -encrypt-auto, though not currently a pattern)
+        if is_auto_model: base_model_name = request.model[:-len("-auto")]
+        elif is_grounded_search: base_model_name = request.model[:-len("-search")]
+        elif is_encrypted_full_model: base_model_name = request.model[:-len("-encrypt-full")] # Must be before -encrypt
+        elif is_encrypted_model: base_model_name = request.model[:-len("-encrypt")]
+        elif is_nothinking_model: base_model_name = request.model[:-len("-nothinking")]
+        elif is_max_thinking_model: base_model_name = request.model[:-len("-max")]
+        
+        # Specific model variant checks (if any remain exclusive and not covered dynamically)
+        if is_nothinking_model and base_model_name != "gemini-2.5-flash-preview-04-17":
+            return JSONResponse(status_code=400, content=create_openai_error_response(400, f"Model '{request.model}' (-nothinking) is only supported for 'gemini-2.5-flash-preview-04-17'.", "invalid_request_error"))
+        if is_max_thinking_model and base_model_name != "gemini-2.5-flash-preview-04-17":
+            return JSONResponse(status_code=400, content=create_openai_error_response(400, f"Model '{request.model}' (-max) is only supported for 'gemini-2.5-flash-preview-04-17'.", "invalid_request_error"))
+
         generation_config = create_generation_config(request)
 
         client_to_use = None
         express_api_key_val = app_config.VERTEX_EXPRESS_API_KEY_VAL
-
-        if express_api_key_val and base_model_name in VERTEX_EXPRESS_MODELS:
+        
+        # Use dynamically fetched express models list for this check
+        if express_api_key_val and base_model_name in vertex_express_model_ids: # Check against base_model_name
             try:
                 client_to_use = genai.Client(vertexai=True, api_key=express_api_key_val)
                 print(f"INFO: Using Vertex Express Mode for model {base_model_name}.")
@@ -74,28 +112,28 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
             print("ERROR: No Vertex AI client could be initialized via Express Mode or Rotated Credentials.")
             return JSONResponse(status_code=500, content=create_openai_error_response(500, "Vertex AI client not available. Ensure credentials are set up correctly (env var or files).", "server_error"))
 
-        encryption_instructions = ["// Protocol Instructions Placeholder //"]
+        encryption_instructions_placeholder = ["// Protocol Instructions Placeholder //"] # Actual instructions are in message_processing
 
         if is_auto_model:
             print(f"Processing auto model: {request.model}")
             attempts = [
                 {"name": "base", "model": base_model_name, "prompt_func": create_gemini_prompt, "config_modifier": lambda c: c},
-                {"name": "encrypt", "model": base_model_name, "prompt_func": create_encrypted_gemini_prompt, "config_modifier": lambda c: {**c, "system_instruction": encryption_instructions}},
+                {"name": "encrypt", "model": base_model_name, "prompt_func": create_encrypted_gemini_prompt, "config_modifier": lambda c: {**c, "system_instruction": encryption_instructions_placeholder}},
                 {"name": "old_format", "model": base_model_name, "prompt_func": create_encrypted_full_gemini_prompt, "config_modifier": lambda c: c}                  
             ]
             last_err = None
             for attempt in attempts:
-                print(f"Auto-mode attempting: '{attempt['name']}'")
+                print(f"Auto-mode attempting: '{attempt['name']}' for model {attempt['model']}")
                 current_gen_config = attempt["config_modifier"](generation_config.copy())
                 try:
                     return await execute_gemini_call(client_to_use, attempt["model"], attempt["prompt_func"], current_gen_config, request)
                 except Exception as e_auto:
                     last_err = e_auto
-                    print(f"Auto-attempt '{attempt['name']}' failed: {e_auto}")
+                    print(f"Auto-attempt '{attempt['name']}' for model {attempt['model']} failed: {e_auto}")
                     await asyncio.sleep(1)
             
             print(f"All auto attempts failed. Last error: {last_err}")
-            err_msg = f"All auto-mode attempts failed for {request.model}. Last error: {str(last_err)}"
+            err_msg = f"All auto-mode attempts failed for model {request.model}. Last error: {str(last_err)}"
             if not request.stream and last_err:
                  return JSONResponse(status_code=500, content=create_openai_error_response(500, err_msg, "server_error"))
             elif request.stream: 
@@ -106,23 +144,33 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
                 return StreamingResponse(final_error_stream(), media_type="text/event-stream")
             return JSONResponse(status_code=500, content=create_openai_error_response(500, "All auto-mode attempts failed without specific error.", "server_error"))
 
-        else: 
+        else: # Not an auto model
             current_prompt_func = create_gemini_prompt
+            # Determine the actual model string to call the API with (e.g., "gemini-1.5-pro-search")
+            api_model_string = request.model 
+
             if is_grounded_search:
                 search_tool = types.Tool(google_search=types.GoogleSearch())
                 generation_config["tools"] = [search_tool]
             elif is_encrypted_model:
-                generation_config["system_instruction"] = encryption_instructions
+                generation_config["system_instruction"] = encryption_instructions_placeholder
                 current_prompt_func = create_encrypted_gemini_prompt
             elif is_encrypted_full_model:
-                generation_config["system_instruction"] = encryption_instructions
+                generation_config["system_instruction"] = encryption_instructions_placeholder
                 current_prompt_func = create_encrypted_full_gemini_prompt
             elif is_nothinking_model:
                 generation_config["thinking_config"] = {"thinking_budget": 0}
             elif is_max_thinking_model:
                 generation_config["thinking_config"] = {"thinking_budget": 24576}
             
-            return await execute_gemini_call(client_to_use, base_model_name, current_prompt_func, generation_config, request)
+            # For non-auto models, the 'base_model_name' might have suffix stripped.
+            # We should use the original 'request.model' for API call if it's a suffixed one,
+            # or 'base_model_name' if it's truly a base model without suffixes.
+            # The current logic uses 'base_model_name' for the API call in the 'else' block.
+            # This means if `request.model` was "gemini-1.5-pro-search", `base_model_name` becomes "gemini-1.5-pro"
+            # but the API call might need the full "gemini-1.5-pro-search".
+            # Let's use `request.model` for the API call here, and `base_model_name` for checks like Express eligibility.
+            return await execute_gemini_call(client_to_use, api_model_string, current_prompt_func, generation_config, request)
 
     except Exception as e:
         error_msg = f"Unexpected error in chat_completions endpoint: {str(e)}"

app/routes/models_api.py

@@ -1,49 +1,86 @@
 import time
-from fastapi import APIRouter, Depends
-# from typing import List, Dict, Any # Removed as unused
-
-from auth import get_api_key # Changed from relative
+from fastapi import APIRouter, Depends, Request # Added Request
+from typing import List, Dict, Any
+from auth import get_api_key
+from model_loader import get_vertex_models, get_vertex_express_models, refresh_models_config_cache
+import config as app_config # Import config
+from credentials_manager import CredentialManager # To check its type
 
 router = APIRouter()
 
 @router.get("/v1/models")
-async def list_models(api_key: str = Depends(get_api_key)):
-    # This model list should ideally be dynamic or configurable
-    models_data = [
-        {"id": "gemini-2.5-pro-exp-03-25", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-exp-03-25-search", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-exp-03-25-encrypt", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-exp-03-25-encrypt-full", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-exp-03-25-auto", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-03-25", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-03-25-search", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-03-25-encrypt", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-03-25-encrypt-full", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-03-25-auto", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-05-06", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-05-06-search", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-05-06-encrypt", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-05-06-encrypt-full", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-pro-preview-05-06-auto", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.0-flash", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.0-flash-search", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.0-flash-lite", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.0-flash-lite-search", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.0-pro-exp-02-05", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-1.5-flash", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-flash-preview-04-17", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-flash-preview-04-17-encrypt", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-flash-preview-04-17-nothinking", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-2.5-flash-preview-04-17-max", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-1.5-flash-8b", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-1.5-pro", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-1.0-pro-002", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-1.0-pro-vision-001", "object": "model", "created": int(time.time()), "owned_by": "google"},
-        {"id": "gemini-embedding-exp", "object": "model", "created": int(time.time()), "owned_by": "google"}
-    ]
-    # Add root and parent for consistency with OpenAI-like response
-    for model_info in models_data:
-        model_info.setdefault("permission", [])
-        model_info.setdefault("root", model_info["id"]) # Typically the model ID itself
-        model_info.setdefault("parent", None) # Typically None for base models
-    return {"object": "list", "data": models_data}
+async def list_models(fastapi_request: Request, api_key: str = Depends(get_api_key)):
+    await refresh_models_config_cache()
+    
+    # Access credential_manager from app state
+    credential_manager_instance: CredentialManager = fastapi_request.app.state.credential_manager
+
+    has_sa_creds = credential_manager_instance.get_total_credentials() > 0
+    has_express_key = bool(app_config.VERTEX_EXPRESS_API_KEY_VAL)
+
+    raw_vertex_models = await get_vertex_models()
+    raw_express_models = await get_vertex_express_models()
+    
+    candidate_model_ids = set()
+
+    if has_express_key:
+        candidate_model_ids.update(raw_express_models)
+        # If *only* express key is available, only express models (and their variants) should be listed.
+        # The current `vertex_model_ids` from remote config might contain non-express models.
+        # The `get_vertex_express_models()` should be the source of truth for express-eligible base models.
+        if not has_sa_creds:
+            # Only list models that are explicitly in the express list.
+            # Suffix generation will apply only to these if they are not gemini-2.0
+            all_model_ids = set(raw_express_models)
+        else:
+            # Both SA and Express are available, combine all known models
+            all_model_ids = set(raw_vertex_models + raw_express_models)
+    elif has_sa_creds:
+        # Only SA creds available, use all vertex_models (which might include express-eligible ones)
+        all_model_ids = set(raw_vertex_models)
+    else:
+        # No credentials available
+        all_model_ids = set()
+    
+    # Create extended model list with variations (search, encrypt, auto etc.)
+    # This logic might need to be more sophisticated based on actual supported features per base model.
+    # For now, let's assume for each base model, we might have these variations.
+    # A better approach would be if the remote config specified these variations.
+    
+    dynamic_models_data: List[Dict[str, Any]] = []
+    current_time = int(time.time())
+
+    # Add base models and their variations
+    for model_id in sorted(list(all_model_ids)):
+        dynamic_models_data.append({
+            "id": model_id, "object": "model", "created": current_time, "owned_by": "google",
+            "permission": [], "root": model_id, "parent": None
+        })
+        
+        # Conditionally add common variations (standard suffixes)
+        if not model_id.startswith("gemini-2.0"):
+            standard_suffixes = ["-search", "-encrypt", "-encrypt-full", "-auto"]
+            for suffix in standard_suffixes:
+                suffixed_id = f"{model_id}{suffix}"
+                # Check if this suffixed ID is already in all_model_ids (fetched from remote) or already added to dynamic_models_data
+                if suffixed_id not in all_model_ids and not any(m['id'] == suffixed_id for m in dynamic_models_data):
+                    dynamic_models_data.append({
+                        "id": suffixed_id, "object": "model", "created": current_time, "owned_by": "google",
+                        "permission": [], "root": model_id, "parent": None
+                    })
+        
+        # Apply special suffixes for models starting with "gemini-2.5-flash"
+        if model_id.startswith("gemini-2.5-flash"):
+            special_flash_suffixes = ["-nothinking", "-max"]
+            for special_suffix in special_flash_suffixes:
+                suffixed_id = f"{model_id}{special_suffix}"
+                if suffixed_id not in all_model_ids and not any(m['id'] == suffixed_id for m in dynamic_models_data):
+                    dynamic_models_data.append({
+                        "id": suffixed_id, "object": "model", "created": current_time, "owned_by": "google",
+                        "permission": [], "root": model_id, "parent": None
+                    })
+
+    # Ensure uniqueness again after adding suffixes
+    final_models_data_map = {m["id"]: m for m in dynamic_models_data}
+    
+    return {"object": "list", "data": list(final_models_data_map.values())}

app/vertex_ai_init.py

@@ -1,20 +1,17 @@
 import json
+import asyncio # Added for await
 from google import genai
-from credentials_manager import CredentialManager, parse_multiple_json_credentials # Changed from relative
-import config as app_config # Changed from relative
+from credentials_manager import CredentialManager, parse_multiple_json_credentials
+import config as app_config
+from model_loader import refresh_models_config_cache # Import new model loader function
 
-# VERTEX_EXPRESS_API_KEY constant is removed, direct string "VERTEX_EXPRESS_API_KEY" will be used in chat_api.py
-VERTEX_EXPRESS_MODELS = [
-    "gemini-2.0-flash-001",
-    "gemini-2.0-flash-lite-001",
-    "gemini-2.5-pro-preview-03-25",
-    "gemini-2.5-flash-preview-04-17",
-    "gemini-2.5-pro-preview-05-06",
-]
+# VERTEX_EXPRESS_MODELS list is now dynamically loaded via model_loader
+# The constant VERTEX_EXPRESS_MODELS previously defined here is removed.
+# Consumers should use get_vertex_express_models() from model_loader.
 
 # Global 'client' and 'get_vertex_client()' are removed.
 
-def init_vertex_ai(credential_manager_instance: CredentialManager) -> bool:
+async def init_vertex_ai(credential_manager_instance: CredentialManager) -> bool: # Made async
     """
     Initializes the credential manager with credentials from GOOGLE_CREDENTIALS_JSON (if provided)
     and verifies if any credentials (environment or file-based through the manager) are available.
@@ -65,6 +62,16 @@ def init_vertex_ai(credential_manager_instance: CredentialManager) -> bool:
         else:
             print("INFO: GOOGLE_CREDENTIALS_JSON environment variable not found.")
 
+        # Attempt to pre-warm the model configuration cache
+        print("INFO: Attempting to pre-warm model configuration cache during startup...")
+        models_loaded_successfully = await refresh_models_config_cache()
+        if models_loaded_successfully:
+            print("INFO: Model configuration cache pre-warmed successfully.")
+        else:
+            print("WARNING: Failed to pre-warm model configuration cache during startup. It will be loaded lazily on first request.")
+            # We don't necessarily fail the entire init_vertex_ai if model list fetching fails,
+            # as credential validation might still be important, and model list can be fetched later.
+
         # CredentialManager's __init__ calls load_credentials_list() for files.
         # refresh_credentials_list() re-scans files and combines with in-memory (already includes env creds if loaded above).
         # The return value of refresh_credentials_list indicates if total > 0