feat: add model management endpoints and admin interface for cache status

Co-authored-by: Copilot <copilot@github.com>

backend/app/routers/admin.py

@@ -1,10 +1,12 @@
 """Admin router: operational endpoints for application management."""
 from datetime import datetime, timezone
+from typing import Any
 
 from fastapi import APIRouter, Depends
 
 from ..db import get_conn, get_write_lock
 from ..dependencies import require_admin
+from ..services import models as models_service
 
 router = APIRouter(prefix="/admin", tags=["admin"])
 
@@ -13,16 +15,15 @@ router = APIRouter(prefix="/admin", tags=["admin"])
 async def get_stats(_: dict = Depends(require_admin)) -> dict:
     """Return aggregate statistics: user counts and token counts."""
     conn = get_conn()
-    total_users = conn.execute("SELECT COUNT(*) FROM users").fetchone()[0]
-    users_by_role = conn.execute(
-        "SELECT role, COUNT(*) FROM users GROUP BY role ORDER BY role"
-    ).fetchall()
-    total_tokens = conn.execute(
-        "SELECT COUNT(*) FROM refresh_tokens").fetchone()[0]
-    active_tokens = conn.execute(
-        "SELECT COUNT(*) FROM refresh_tokens WHERE revoked = false AND expires_at > ?",
-        [datetime.now(timezone.utc)],
-    ).fetchone()[0]
+    sql_user_count = "SELECT COUNT(*) FROM users"
+    sql_user_counts = "SELECT role, COUNT(*) FROM users GROUP BY role ORDER BY role"
+    sql_token_count = "SELECT COUNT(*) FROM refresh_tokens"
+    sql_tokens_active = "SELECT COUNT(*) FROM refresh_tokens WHERE revoked = false AND expires_at > ?"
+    now = datetime.now(timezone.utc)
+    total_users = conn.execute(sql_user_count).fetchone()[0]
+    users_by_role = conn.execute(sql_user_counts).fetchall()
+    total_tokens = conn.execute(sql_token_count).fetchone()[0]
+    active_tokens = conn.execute(sql_tokens_active, [now]).fetchone()[0]
     return {
         "users": {
             "total": total_users,
@@ -50,13 +51,42 @@ async def purge_tokens(_: dict = Depends(require_admin)) -> dict:
     conn = get_conn()
     lock = get_write_lock()
     now = datetime.now(timezone.utc)
+    sql_count = "SELECT COUNT(*) FROM refresh_tokens"
+    sql_delete = "DELETE FROM refresh_tokens WHERE revoked = true OR expires_at <= ?"
     async with lock:
-        before = conn.execute(
-            "SELECT COUNT(*) FROM refresh_tokens").fetchone()[0]
-        conn.execute(
-            "DELETE FROM refresh_tokens WHERE revoked = true OR expires_at <= ?", [
-                now]
-        )
-        after = conn.execute(
-            "SELECT COUNT(*) FROM refresh_tokens").fetchone()[0]
-    return {"deleted": before - after, "remaining": after}
+        before = conn.execute(sql_count).fetchone()[0]
+        conn.execute(sql_delete, [now])
+        after = conn.execute(sql_count).fetchone()[0]
+        return {"deleted": before - after, "remaining": after}
+
+
+@router.get("/models/status")
+async def get_model_status(_: dict = Depends(require_admin)) -> dict[str, Any]:
+    """Return model cache status: last update time and model count."""
+    conn = get_conn()
+    return models_service.get_cache_status(conn)
+
+
+@router.get("/models")
+async def get_all_models(_: dict = Depends(require_admin)) -> list[dict[str, Any]]:
+    """Return all cached models."""
+    conn = get_conn()
+    return models_service.get_cached_models(conn)
+
+
+@router.post("/models/refresh", status_code=200)
+async def refresh_models(
+    _: dict = Depends(require_admin),
+) -> dict[str, str | int | None]:
+    """Force a refresh of the model cache from OpenRouter."""
+    conn = get_conn()
+    lock = get_write_lock()
+    async with lock:
+        count = await models_service.refresh_models_cache(conn)
+    status = models_service.get_cache_status(conn)
+    return {
+        "status": "ok",
+        "refreshed": count,
+        "total_models": status.get("model_count"),
+        "last_updated": status.get("last_updated"),
+    }

backend/app/services/models.py

@@ -198,3 +198,12 @@ def get_model_output_modalities(
         return json.loads(row[0])
     except (json.JSONDecodeError, TypeError):
         return []
+
+
+def get_cache_status(conn: duckdb.DuckDBPyConnection) -> dict[str, Any]:
+    """Return cache last update time and model count."""
+    row = conn.execute(
+        "SELECT MAX(fetched_at), COUNT(*) FROM models_cache"
+    ).fetchone()
+    last_updated, model_count = (row[0], row[1]) if row else (None, 0)
+    return {"last_updated": last_updated, "model_count": model_count}