feat: add provider and model routing tables, admin UI, and audit category for gateway

Implement the multi-provider routing system for the OpenAI gateway, including two new database tables (`gateway_providers`, `gateway_models`) ensured at init, a new admin page at `/admin/gateway` with full CRUD for providers and model routes, and a `"gateway"` audit category mapped to `"ai"`. The routing layer sits transparently on top of the existing single-provider default path: unmatched model names fall through unchanged, while matched routes forward to the configured provider with their own pricing economy, vision model, and context window. Cross-worker cache invalidation uses a shared `_ROUTING_CACHE` bumped via `"gateway_routing"` cache version.

devplacepy/routers/admin/gateway_configs.py

@@ -0,0 +1,182 @@
+# retoor <retoor@molodetz.nl>
+
+import logging
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import ValidationError
+
+from devplacepy.seo import base_seo_context, site_url, website_schema
+from devplacepy.services.audit import record as audit
+from devplacepy.services.manager import service_manager
+from devplacepy.services.openai_gateway import routing
+from devplacepy.templating import templates
+from devplacepy.utils import require_admin
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+def _default_provider_summary() -> dict:
+    svc = service_manager.get_service("openai")
+    cfg = svc.get_config() if svc is not None else {}
+    return {
+        "base_url": cfg.get("gateway_upstream_url", ""),
+        "model": cfg.get("gateway_model", ""),
+        "embed_url": cfg.get("gateway_embed_url", ""),
+        "embed_model": cfg.get("gateway_embed_model", ""),
+        "vision_url": cfg.get("gateway_vision_url", ""),
+        "vision_model": cfg.get("gateway_vision_model", ""),
+    }
+
+
+def _validation_error(exc: ValidationError) -> JSONResponse:
+    first = exc.errors()[0]
+    message = first.get("msg", "Invalid input")
+    return JSONResponse({"ok": False, "error": message}, status_code=400)
+
+
+async def _payload(request: Request) -> dict:
+    content_type = request.headers.get("content-type", "")
+    if "application/json" in content_type:
+        try:
+            data = await request.json()
+        except Exception:
+            return {}
+        return data if isinstance(data, dict) else {}
+    form = await request.form()
+    return {key: value for key, value in form.items()}
+
+
+@router.get("/gateway", response_class=HTMLResponse)
+async def gateway_config_page(request: Request):
+    admin = require_admin(request)
+    base = site_url(request)
+    seo_ctx = base_seo_context(
+        request,
+        title="Gateway routing - Admin",
+        description="Manage OpenAI gateway providers and per-model routing.",
+        robots="noindex,nofollow",
+        breadcrumbs=[
+            {"name": "Home", "url": "/feed"},
+            {"name": "Admin", "url": "/admin"},
+            {"name": "Gateway", "url": "/admin/gateway"},
+        ],
+        schemas=[website_schema(base)],
+    )
+    return templates.TemplateResponse(
+        request,
+        "admin_gateway.html",
+        {
+            **seo_ctx,
+            "request": request,
+            "user": admin,
+            "admin_section": "gateway",
+            "default_provider": _default_provider_summary(),
+        },
+    )
+
+
+@router.get("/gateway/providers")
+async def list_providers(request: Request):
+    require_admin(request)
+    return JSONResponse(
+        {
+            "providers": routing.provider_store.list(),
+            "default": _default_provider_summary(),
+            "count": routing.provider_store.count(),
+        }
+    )
+
+
+@router.post("/gateway/providers")
+async def save_provider(request: Request):
+    admin = require_admin(request)
+    body = await _payload(request)
+    try:
+        payload = routing.ProviderIn(**body)
+    except ValidationError as exc:
+        return _validation_error(exc)
+    saved = routing.provider_store.set(payload)
+    audit.record(
+        request,
+        "gateway.provider.update",
+        user=admin,
+        target_type="gateway_provider",
+        target_uid=payload.name,
+        target_label=payload.name,
+        summary=f"admin {admin['username']} saved gateway provider {payload.name}",
+    )
+    return JSONResponse({"ok": True, "provider": saved})
+
+
+@router.delete("/gateway/providers/{name}")
+async def delete_provider(request: Request, name: str):
+    admin = require_admin(request)
+    existed = routing.provider_store.remove(name)
+    if not existed:
+        return JSONResponse({"ok": False, "error": "Provider not found"}, status_code=404)
+    audit.record(
+        request,
+        "gateway.provider.delete",
+        user=admin,
+        target_type="gateway_provider",
+        target_uid=name,
+        target_label=name,
+        summary=f"admin {admin['username']} deleted gateway provider {name}",
+    )
+    return JSONResponse({"ok": True})
+
+
+@router.get("/gateway/models")
+async def list_models(request: Request):
+    require_admin(request)
+    return JSONResponse(
+        {
+            "models": routing.model_store.list(),
+            "providers": routing.provider_store.names(),
+            "count": routing.model_store.count(),
+        }
+    )
+
+
+@router.post("/gateway/models")
+async def save_model(request: Request):
+    admin = require_admin(request)
+    body = await _payload(request)
+    try:
+        payload = routing.ModelRouteIn(**body)
+    except ValidationError as exc:
+        return _validation_error(exc)
+    saved = routing.model_store.set(payload)
+    audit.record(
+        request,
+        "gateway.model.update",
+        user=admin,
+        target_type="gateway_model",
+        target_uid=payload.source_model,
+        target_label=f"{payload.source_model} -> {payload.target_model}",
+        summary=(
+            f"admin {admin['username']} saved gateway model route "
+            f"{payload.source_model} -> {payload.target_model}"
+        ),
+    )
+    return JSONResponse({"ok": True, "model": saved})
+
+
+@router.delete("/gateway/models/{source_model}")
+async def delete_model(request: Request, source_model: str):
+    admin = require_admin(request)
+    existed = routing.model_store.remove(source_model)
+    if not existed:
+        return JSONResponse({"ok": False, "error": "Model route not found"}, status_code=404)
+    audit.record(
+        request,
+        "gateway.model.delete",
+        user=admin,
+        target_type="gateway_model",
+        target_uid=source_model,
+        target_label=source_model,
+        summary=f"admin {admin['username']} deleted gateway model route {source_model}",
+    )
+    return JSONResponse({"ok": True})