feat: dynamic model discovery from OpenRouter + React Doctor 100/100

Backend: Models are now dynamically fetched from OpenRouter API (filtered by
programming-relevant providers), cached in Redis (1h TTL) + in-memory (30min),
with periodic background refresh. Auto-detects latest Anthropic Sonnet as
default. Falls back to hardcoded list if API is unavailable.

Frontend: Model selector fetches models from /api/models/available endpoint.
Refactored hero-section and message-input to useReducer (React Doctor).
Replaced client-side router.replace() redirect with render-time redirect().

Author: iamjr15

README.md

@@ -29,7 +29,7 @@
 from utils.encryption import decrypt_data
 from utils.file_utils import is_image_file
 from utils.logger import logger, structlog
-from utils.models import get_available_models, get_default_model, resolve_model_id
+from utils.models import get_default_model_id, resolve_model_id
 from utils.rate_limit import limiter
 
 from .utils import check_for_active_project_agent_run
@@ -89,7 +89,7 @@ def chunk_responses(responses: list, chunk_size: int = SSE_BATCH_SIZE) -> list:
 
 
 class AgentStartRequest(BaseModel):
-    model_name: str | None = None  # Will be set from config.MODEL_TO_USE in the endpoint
+    model_name: str | None = None  # Defaults to latest Anthropic Sonnet if not specified
     enable_thinking: bool | None = False
     reasoning_effort: str | None = "low"
     stream: bool | None = True
@@ -123,11 +123,15 @@ def initialize(_db: DBConnection, _instance_id: str | None = None):
 async def get_models_available():
     """Get list of available AI models for user selection.
 
-    Returns models with their display names, providers, and descriptions.
+    Models are dynamically fetched from OpenRouter and cached (1h TTL).
+    Falls back to hardcoded list if the API is unavailable.
     """
-    models = get_available_models()
-    default_model = get_default_model()
-    return {"models": models, "default_model_id": default_model["id"] if default_model else "claude-sonnet-4.5"}
+    from services.openrouter_models import get_available_models_cached
+
+    models = await get_available_models_cached()
+    default_model = next((m for m in models if m.get("default")), None)
+    default_id = default_model["id"] if default_model else (models[0]["id"] if models else get_default_model_id())
+    return {"models": models, "default_model_id": default_id}
 
 
 async def cleanup():
@@ -402,7 +406,7 @@ async def start_agent(
 
         # Model selection: request > project (single source of truth) > config default
         stored_model = project_data.get("model_name")
-        model_name = body.model_name or stored_model or config.MODEL_TO_USE
+        model_name = body.model_name or stored_model or get_default_model_id()
 
         # Resolve to full OpenRouter ID for API calls
         model_name = resolve_model_id(model_name)
@@ -1138,8 +1142,8 @@ async def generate_and_update_project_name(project_id: str, prompt: str):
         db_conn = DBConnection()
         client = await db_conn.client
 
-        # Use the configured model and resolve to full OpenRouter ID
-        model_name = resolve_model_id(config.MODEL_TO_USE)
+        # Use the default model and resolve to full OpenRouter ID
+        model_name = resolve_model_id(get_default_model_id())
         system_prompt = "You are a helpful assistant that generates extremely concise titles (2-4 words maximum) for chat threads based on the user's message."
         user_message = f'Generate an extremely brief title (2-4 words only) for a chat thread that starts with this message: "{prompt}"'
         messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_message}]
@@ -1179,7 +1183,7 @@ async def generate_and_update_project_name(project_id: str, prompt: str):
 async def initiate_agent_with_files(
     request: Request,
     prompt: str = Form(...),
-    model_name: str | None = Form(None),  # Default to None to use config.MODEL_TO_USE
+    model_name: str | None = Form(None),  # Defaults to latest Anthropic Sonnet if not specified
     enable_thinking: bool | None = Form(False),
     reasoning_effort: str | None = Form("low"),
     stream: bool | None = Form(True),
@@ -1205,9 +1209,9 @@ async def initiate_agent_with_files(
     # Use model from config if not specified in the request
     logger.info(f"Original model_name from request: {model_name}")
 
-    if model_name is None:
-        model_name = config.MODEL_TO_USE
-        logger.info(f"Using model from config: {model_name}")
+    if not model_name:
+        model_name = get_default_model_id()
+        logger.info(f"Using default model: {model_name}")
 
     # Keep the original short model ID for UI persistence
     ui_model_name = model_name

backend/agent/api.py

@@ -112,6 +112,7 @@ async def process_agent_run(ctx: inngest.Context) -> dict:
     from services.supabase import DBConnection
     from utils.config import config
     from utils.encryption import decrypt_data
+    from utils.models import get_default_model_id
     from utils.retry import retry
 
     # Self-initialize: ensure Redis and DB are ready
@@ -127,7 +128,7 @@ async def process_agent_run(ctx: inngest.Context) -> dict:
         raise RuntimeError(f"Agent run {agent_run_id} not found in database")
 
     metadata = run_result.data[0].get("metadata", {})
-    model_name = metadata.get("model_name", config.MODEL_TO_USE)
+    model_name = metadata.get("model_name") or get_default_model_id()
     enable_thinking = metadata.get("enable_thinking")
     reasoning_effort = metadata.get("reasoning_effort")
     enable_context_manager = metadata.get("enable_context_manager", False)

backend/inngest_functions/agent_run.py

@@ -61,17 +61,32 @@ async def lifespan(_app: FastAPI):
         composio_api.initialize(db)
         composio_secure_mcp_api.initialize(db)
 
+        # Load dynamic models from OpenRouter (cached in Redis)
+        from services.openrouter_models import refresh_models, start_periodic_refresh
+
+        try:
+            await refresh_models()
+            logger.info("Dynamic model list loaded from OpenRouter")
+        except Exception as e:
+            logger.warning(f"Failed to load dynamic models (using fallback): {e}")
+
         # Start background health monitoring
         from utils.health_check import start_health_monitoring
 
         health_task = asyncio.create_task(start_health_monitoring(instance_id, interval=600))
 
+        # Start periodic model refresh (every hour)
+        model_refresh_task = asyncio.create_task(start_periodic_refresh())
+
         yield
 
-        # Shutdown: cancel health monitoring
+        # Shutdown: cancel background tasks
         health_task.cancel()
+        model_refresh_task.cancel()
         with contextlib.suppress(asyncio.CancelledError):
             await health_task
+        with contextlib.suppress(asyncio.CancelledError):
+            await model_refresh_task
 
         # Clean up agent resources
         logger.info("Cleaning up agent resources")

backend/main.py

@@ -128,6 +128,16 @@ def get_llm_router() -> Router | None:
     return _llm_router
 
 
+def refresh_router() -> None:
+    """Rebuild the Router with the current model store.
+
+    Called by services.openrouter_models after dynamic model refresh.
+    """
+    global _llm_router
+    _llm_router = create_llm_router()
+    logger.info("LiteLLM Router rebuilt with refreshed model list")
+
+
 def get_router_model_name(model_name: str) -> str | None:
     """Map an OpenRouter model ID to the router group name (short ID).