Files
devplacepy/devplacepy/routers/admin/gateway_configs.py
T
retoorandClaude Sonnet 5.5 1a9201cb91 Admin pages: one shared specification, builders, fragments, caps and live refresh
Adds admin_sections registry, shared admin partials, WorkspaceList, admin CLAUDE.md spec,
capped node/flag listings, and api/unit tests enforcing the spec.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-15 01:50:50 +01:00

1184 lines
40 KiB
Python

# retoor <retoor@molodetz.nl>
import logging
from datetime import datetime, timezone
from typing import Optional
from urllib.parse import quote
from fastapi import APIRouter, Query, Request
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
from pydantic import ValidationError
from devplacepy.responses import json_error, respond, wants_json
from devplacepy.schemas import (
AdminGatewayModelFormOut,
AdminGatewayOut,
AdminGatewayProviderFormOut,
AdminGatewayQuotaFormOut,
)
from devplacepy.seo import base_seo_context, site_url, website_schema
from devplacepy.routers.admin._shared import ADMIN_LIST_CAP
from devplacepy.services.audit import record as audit
from devplacepy.services.manager import service_manager
from devplacepy.services.openai_gateway import (
health,
model_stats_query,
quota,
routing,
)
from devplacepy.services.openai_gateway.learned import (
DEFAULT_PROVIDER,
LearnedResetIn,
learned_store,
)
from devplacepy.services.openai_gateway.shape import shape_stats
from devplacepy.templating import templates
from devplacepy.utils import not_found, require_admin
logger = logging.getLogger(__name__)
router = APIRouter()
INDEX_URL = "/admin/gateway"
TABS = ("models", "providers", "quota", "stats")
DEFAULT_STATS_RANGE = "24h"
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", ""),
"image_url": cfg.get("gateway_image_url", ""),
"image_model": cfg.get("gateway_image_model", ""),
"vision_url": cfg.get("gateway_vision_url", ""),
"vision_model": cfg.get("gateway_vision_model", ""),
}
def _quota_defaults_summary() -> dict:
svc = service_manager.get_service("openai")
cfg = svc.get_config() if svc is not None else {}
return {
"user": cfg.get(quota.FIELD_DEFAULT_USER, 0.0),
"admin": cfg.get(quota.FIELD_DEFAULT_ADMIN, 0.0),
"guest": cfg.get(quota.FIELD_DEFAULT_GUEST, 0.0),
"internal": cfg.get(quota.FIELD_DEFAULT_INTERNAL, 0.0),
"key": cfg.get(quota.FIELD_DEFAULT_KEY, 0.0),
}
def _rule_label(rule: dict) -> str:
return quota.scope_label(rule, fallback=rule.get("uid", ""))
def _breadcrumbs(*extra: dict) -> list[dict]:
trail = [
{"name": "Home", "url": "/feed"},
{"name": "Admin", "url": "/admin"},
{"name": "Gateway", "url": INDEX_URL},
]
return trail + list(extra)
def _seo(request: Request, title: str, breadcrumbs: list[dict]) -> dict:
base = site_url(request)
return base_seo_context(
request,
title=title,
description="Manage OpenAI gateway providers, per-model routing, and quota rules.",
robots="noindex,nofollow",
breadcrumbs=breadcrumbs,
schemas=[website_schema(base)],
)
def _first_error(exc: ValidationError) -> str:
return exc.errors()[0].get("msg", "Invalid input")
def _validation_error(exc: ValidationError) -> JSONResponse:
return JSONResponse({"ok": False, "error": _first_error(exc)}, status_code=400)
def _bool_str(value) -> str:
if isinstance(value, bool):
return "1" if value else "0"
return "1" if str(value).strip().lower() in ("1", "true", "on", "yes") else "0"
def _blank_to_none(value):
value = "" if value is None else str(value).strip()
return value or None
def _time_to_minutes(value: str) -> Optional[int]:
value = (value or "").strip()
if not value or ":" not in value:
return None
hours_str, _, minutes_str = value.partition(":")
try:
return int(hours_str) * 60 + int(minutes_str)
except ValueError:
return None
def _minutes_to_time(value) -> str:
if value is None or value == "":
return ""
try:
total = int(value)
except (TypeError, ValueError):
return ""
return f"{(total // 60) % 24:02d}:{total % 60:02d}"
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()}
def _error_response(
request: Request, template: str, context: dict, message: str, status_code: int = 400
):
if wants_json(request):
return json_error(status_code, message)
return respond(
request,
template,
{**context, "request": request, "error": message},
model=AdminGatewayOut,
status_code=status_code,
)
def _models_with_learned(limit: int = ADMIN_LIST_CAP) -> list[dict]:
models = routing.model_store.list()[:limit]
for model in models:
method = learned_store.get(
model["provider"] or DEFAULT_PROVIDER, model["target_model"]
)
model["learned_shape"] = method.label if method is not None else ""
model["learned_provider"] = model["provider"] or DEFAULT_PROVIDER
return models
def _reset_learned(request: Request, admin: dict, payload: LearnedResetIn) -> bool:
provider = payload.provider or DEFAULT_PROVIDER
existed = learned_store.forget(provider, payload.target_model)
if existed:
audit.record(
request,
"gateway.learned.reset",
user=admin,
target_type="gateway_learned_method",
target_uid=f"{provider}/{payload.target_model}",
target_label=f"{provider}/{payload.target_model}",
summary=(
f"admin {admin['username']} reset the learned request shape "
f"for {provider}/{payload.target_model}"
),
)
return existed
# --- Index page (tabs: models / providers / quota) --------------------------
@router.get("/gateway", response_class=HTMLResponse)
async def gateway_config_page(
request: Request,
tab: str = "models",
tested: str = "",
test_image: str = "",
stats_range: str = Query(DEFAULT_STATS_RANGE, alias="range"),
):
admin = require_admin(request)
if tab not in TABS:
tab = "models"
if not test_image.startswith("http"):
test_image = ""
all_quota_rules = quota.quota_rule_store.list()
quota_rules = all_quota_rules[:ADMIN_LIST_CAP]
for rule in quota_rules:
rule["spent_24h_usd"] = round(
quota.spent_24h(rule["owner_kind"], rule["owner_id"], rule["app_reference"]), 6
)
all_providers = routing.provider_store.list()
stats_context = _stats_context(stats_range) if tab == "stats" else {}
return respond(
request,
"admin_gateway.html",
{
**_seo(request, "Gateway routing - Admin", _breadcrumbs()),
"user": admin,
"admin_section": "gateway",
"tab": tab,
"providers": all_providers[:ADMIN_LIST_CAP],
"providers_total": len(all_providers),
"models": _models_with_learned(),
"models_total": routing.model_store.count(),
"quota_rules": quota_rules,
"quota_rules_total": len(all_quota_rules),
**stats_context,
"default_provider": _default_provider_summary(),
"quota_defaults": _quota_defaults_summary(),
"stats_ranges": list(model_stats_query.RANGE_SECONDS.keys()),
"tested": tested,
"test_image": test_image,
},
model=AdminGatewayOut,
)
# --- Providers: JSON API (Devii + programmatic clients) ---------------------
@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_json(request: Request):
admin = require_admin(request)
body = await _payload(request)
try:
payload = routing.ProviderIn(**body)
except ValidationError as exc:
return _validation_error(exc)
saved = _save_provider(request, admin, payload)
return JSONResponse({"ok": True, "provider": saved})
@router.delete("/gateway/providers/{name}")
async def delete_provider(request: Request, name: str):
admin = require_admin(request)
if not _remove_provider(request, admin, name):
return JSONResponse({"ok": False, "error": "Provider not found"}, status_code=404)
return JSONResponse({"ok": True})
# --- Providers: backend-rendered pages ---------------------------------------
def _provider_form_values(data: Optional[dict] = None) -> dict:
data = data or {}
return {
"name": str(data.get("name", "")),
"base_url": str(data.get("base_url", "")),
"api_key": str(data.get("api_key", "")),
"is_active": _bool_str(data.get("is_active", True)),
"client_profile": str(data.get("client_profile", "")),
"protocol": str(data.get("protocol", "chat_completions")),
}
def _save_provider(request: Request, admin: dict, payload: "routing.ProviderIn") -> dict:
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 saved
def _remove_provider(request: Request, admin: dict, name: str) -> bool:
existed = routing.provider_store.remove(name)
if existed:
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 existed
@router.get("/gateway/providers/new", response_class=HTMLResponse)
async def new_provider_page(request: Request):
admin = require_admin(request)
return respond(
request,
"admin_gateway_provider_form.html",
{
**_seo(request, "Add provider - Gateway - Admin", _breadcrumbs({"name": "Add provider", "url": "/admin/gateway/providers/new"})),
"user": admin,
"admin_section": "gateway",
"is_edit": False,
"form": _provider_form_values(),
"error": None,
},
model=AdminGatewayProviderFormOut,
)
@router.post("/gateway/providers/new")
async def create_provider_page(request: Request):
admin = require_admin(request)
data = dict(await request.form())
try:
payload = routing.ProviderIn(**data)
except ValidationError as exc:
return _error_response(
request,
"admin_gateway_provider_form.html",
{
**_seo(request, "Add provider - Gateway - Admin", _breadcrumbs({"name": "Add provider", "url": "/admin/gateway/providers/new"})),
"user": admin,
"admin_section": "gateway",
"is_edit": False,
"form": _provider_form_values(data),
},
_first_error(exc),
)
_save_provider(request, admin, payload)
return RedirectResponse(url=f"{INDEX_URL}?tab=providers", status_code=302)
@router.get("/gateway/providers/{name}/edit", response_class=HTMLResponse)
async def edit_provider_page(request: Request, name: str):
admin = require_admin(request)
provider = routing.provider_store.get(name)
if provider is None:
raise not_found("Provider not found")
return respond(
request,
"admin_gateway_provider_form.html",
{
**_seo(
request,
f"Edit {provider['name']} - Gateway - Admin",
_breadcrumbs({"name": f"Edit {provider['name']}", "url": f"/admin/gateway/providers/{provider['name']}/edit"}),
),
"user": admin,
"admin_section": "gateway",
"is_edit": True,
"form": _provider_form_values(provider),
"error": None,
},
model=AdminGatewayProviderFormOut,
)
@router.post("/gateway/providers/{name}/edit")
async def edit_provider_save(request: Request, name: str):
admin = require_admin(request)
existing = routing.provider_store.get(name)
if existing is None:
raise not_found("Provider not found")
data = dict(await request.form())
data["name"] = existing["name"]
try:
payload = routing.ProviderIn(**data)
except ValidationError as exc:
return _error_response(
request,
"admin_gateway_provider_form.html",
{
**_seo(
request,
f"Edit {existing['name']} - Gateway - Admin",
_breadcrumbs({"name": f"Edit {existing['name']}", "url": f"/admin/gateway/providers/{existing['name']}/edit"}),
),
"user": admin,
"admin_section": "gateway",
"is_edit": True,
"form": _provider_form_values({**data, "name": existing["name"]}),
},
_first_error(exc),
)
_save_provider(request, admin, payload)
return RedirectResponse(url=f"{INDEX_URL}?tab=providers", status_code=302)
@router.post("/gateway/providers/{name}/delete")
async def delete_provider_page(request: Request, name: str):
admin = require_admin(request)
if not _remove_provider(request, admin, name):
raise not_found("Provider not found")
return RedirectResponse(url=f"{INDEX_URL}?tab=providers", status_code=302)
# --- Model routes: JSON API (Devii + programmatic clients) ------------------
@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.get("/gateway/learned")
async def list_learned(request: Request):
require_admin(request)
rows = learned_store.list()
return JSONResponse(
{"learned": rows, "count": len(rows), "stats": shape_stats.snapshot()}
)
@router.post("/gateway/learned/reset")
async def reset_learned_json(request: Request):
admin = require_admin(request)
body = await _payload(request)
try:
payload = LearnedResetIn(**body)
except ValidationError as exc:
return _validation_error(exc)
if not _reset_learned(request, admin, payload):
return JSONResponse(
{"ok": False, "error": "No learned method for that route"},
status_code=404,
)
return JSONResponse({"ok": True})
@router.post("/gateway/learned/reset-page")
async def reset_learned_page(request: Request):
admin = require_admin(request)
body = await _payload(request)
try:
payload = LearnedResetIn(**body)
except ValidationError as exc:
return _validation_error(exc)
if not _reset_learned(request, admin, payload):
raise not_found("No learned method for that route")
return RedirectResponse(url=f"{INDEX_URL}?tab=models", status_code=302)
@router.get("/gateway/provider-models")
async def provider_models(request: Request, provider: str = ""):
require_admin(request)
models = await routing.fetch_provider_models(provider)
if models is None:
return json_error(404, "No model list available for this provider")
return JSONResponse({"provider": provider, "models": models})
def _check_fallback(payload: "routing.ModelRouteIn") -> Optional[str]:
if not payload.fallback_model:
return None
fallback_route = routing.model_store.get(payload.fallback_model)
if fallback_route is None or fallback_route.kind != payload.kind:
return "Fallback model must be an existing model route of the same kind"
return None
def _save_model(request: Request, admin: dict, payload: "routing.ModelRouteIn") -> dict:
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 saved
def _remove_model(request: Request, admin: dict, source_model: str) -> bool:
existed = routing.model_store.remove(source_model)
if existed:
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 existed
@router.post("/gateway/models")
async def save_model_json(request: Request):
admin = require_admin(request)
body = await _payload(request)
try:
payload = routing.ModelRouteIn(**body)
except ValidationError as exc:
return _validation_error(exc)
fallback_error = _check_fallback(payload)
if fallback_error:
return JSONResponse({"ok": False, "error": fallback_error}, status_code=400)
saved = _save_model(request, admin, payload)
return JSONResponse({"ok": True, "model": saved})
@router.delete("/gateway/models/{source_model:path}")
async def delete_model(request: Request, source_model: str):
admin = require_admin(request)
if not _remove_model(request, admin, source_model):
return JSONResponse({"ok": False, "error": "Model route not found"}, status_code=404)
return JSONResponse({"ok": True})
# --- Model routes: backend-rendered pages ------------------------------------
MODEL_FORM_DEFAULTS = {
"source_model": "",
"provider": "",
"target_model": "",
"kind": "chat",
"vision_provider": "",
"vision_model": "",
"context_window": "0",
"price_cache_hit_per_m": "0",
"price_cache_miss_per_m": "0",
"price_output_per_m": "0",
"price_input_per_m": "0",
"context_tier_threshold_tokens": "0",
"price_cache_hit_per_m_tier2": "",
"price_cache_miss_per_m_tier2": "",
"price_output_per_m_tier2": "",
"price_input_per_m_tier2": "",
"off_peak_start": "",
"off_peak_end": "",
"off_peak_discount_pct": "0",
"fallback_model": "",
"tools_mode": "native",
"is_active": "1",
}
def _model_form_values_from_route(route: dict) -> dict:
def _num(key):
return str(route.get(key, 0))
def _opt_num(key):
value = route.get(key)
return "" if value is None else str(value)
return {
"source_model": route.get("source_model", ""),
"provider": route.get("provider", ""),
"target_model": route.get("target_model", ""),
"kind": route.get("kind", "chat"),
"vision_provider": route.get("vision_provider", ""),
"vision_model": route.get("vision_model", ""),
"context_window": _num("context_window"),
"price_cache_hit_per_m": _num("price_cache_hit_per_m"),
"price_cache_miss_per_m": _num("price_cache_miss_per_m"),
"price_output_per_m": _num("price_output_per_m"),
"price_input_per_m": _num("price_input_per_m"),
"context_tier_threshold_tokens": _num("context_tier_threshold_tokens"),
"price_cache_hit_per_m_tier2": _opt_num("price_cache_hit_per_m_tier2"),
"price_cache_miss_per_m_tier2": _opt_num("price_cache_miss_per_m_tier2"),
"price_output_per_m_tier2": _opt_num("price_output_per_m_tier2"),
"price_input_per_m_tier2": _opt_num("price_input_per_m_tier2"),
"off_peak_start": _minutes_to_time(route.get("off_peak_start_minute")),
"off_peak_end": _minutes_to_time(route.get("off_peak_end_minute")),
"off_peak_discount_pct": _num("off_peak_discount_pct"),
"fallback_model": route.get("fallback_model", ""),
"tools_mode": route.get("tools_mode", "native"),
"is_active": _bool_str(route.get("is_active", True)),
}
def _model_form_values_from_submission(data: dict) -> dict:
values = dict(MODEL_FORM_DEFAULTS)
for key in values:
if key in data:
values[key] = str(data[key])
values["is_active"] = _bool_str(data.get("is_active", "1"))
return values
def _model_payload_kwargs(data: dict) -> dict:
def _num(key, default="0"):
value = data.get(key, default)
return value if str(value).strip() != "" else default
def _opt_num(key):
value = str(data.get(key, "")).strip()
return value or None
return {
"source_model": data.get("source_model", ""),
"provider": data.get("provider", ""),
"target_model": data.get("target_model", ""),
"kind": data.get("kind", "chat"),
"vision_provider": data.get("vision_provider", ""),
"vision_model": data.get("vision_model", ""),
"context_window": _num("context_window"),
"price_cache_hit_per_m": _num("price_cache_hit_per_m"),
"price_cache_miss_per_m": _num("price_cache_miss_per_m"),
"price_output_per_m": _num("price_output_per_m"),
"price_input_per_m": _num("price_input_per_m"),
"context_tier_threshold_tokens": _num("context_tier_threshold_tokens"),
"price_cache_hit_per_m_tier2": _opt_num("price_cache_hit_per_m_tier2"),
"price_cache_miss_per_m_tier2": _opt_num("price_cache_miss_per_m_tier2"),
"price_output_per_m_tier2": _opt_num("price_output_per_m_tier2"),
"price_input_per_m_tier2": _opt_num("price_input_per_m_tier2"),
"off_peak_start_minute": _time_to_minutes(data.get("off_peak_start", "")),
"off_peak_end_minute": _time_to_minutes(data.get("off_peak_end", "")),
"off_peak_discount_pct": _num("off_peak_discount_pct"),
"fallback_model": data.get("fallback_model", ""),
"tools_mode": data.get("tools_mode", "native"),
"is_active": data.get("is_active", "1"),
}
def _fallback_groups(exclude_source: str = "") -> list[dict]:
by_kind: dict[str, list[str]] = {}
for route in routing.model_store.list():
if route["source_model"] == exclude_source:
continue
by_kind.setdefault(route["kind"], []).append(route["source_model"])
return [{"kind": kind, "options": names} for kind, names in sorted(by_kind.items())]
def _model_form_context(
request: Request,
admin: dict,
*,
is_edit: bool,
form: dict,
exclude_source: str = "",
title: str,
crumb_url: str,
) -> dict:
return {
**_seo(request, title, _breadcrumbs({"name": title.split(" - ")[0], "url": crumb_url})),
"user": admin,
"admin_section": "gateway",
"is_edit": is_edit,
"form": form,
"providers": routing.provider_store.list(),
"fallback_groups": _fallback_groups(exclude_source),
}
@router.get("/gateway/models/new", response_class=HTMLResponse)
async def new_model_page(request: Request):
admin = require_admin(request)
context = _model_form_context(
request,
admin,
is_edit=False,
form=_model_form_values_from_submission({}),
title="Add model route - Gateway - Admin",
crumb_url="/admin/gateway/models/new",
)
return respond(request, "admin_gateway_model_form.html", {**context, "error": None}, model=AdminGatewayModelFormOut)
@router.post("/gateway/models/new")
async def create_model_page(request: Request):
admin = require_admin(request)
data = dict(await request.form())
context = _model_form_context(
request,
admin,
is_edit=False,
form=_model_form_values_from_submission(data),
exclude_source=str(data.get("source_model", "")),
title="Add model route - Gateway - Admin",
crumb_url="/admin/gateway/models/new",
)
try:
payload = routing.ModelRouteIn(**_model_payload_kwargs(data))
except ValidationError as exc:
return _error_response(request, "admin_gateway_model_form.html", context, _first_error(exc))
fallback_error = _check_fallback(payload)
if fallback_error:
return _error_response(request, "admin_gateway_model_form.html", context, fallback_error)
_save_model(request, admin, payload)
return RedirectResponse(url=f"{INDEX_URL}?tab=models", status_code=302)
@router.get("/gateway/models/{source_model:path}/edit", response_class=HTMLResponse)
async def edit_model_page(request: Request, source_model: str):
admin = require_admin(request)
route = routing.model_store.get(source_model)
if route is None:
raise not_found("Model route not found")
route_dict = route.__dict__.copy()
context = _model_form_context(
request,
admin,
is_edit=True,
form=_model_form_values_from_route(route_dict),
exclude_source=source_model,
title=f"Edit {source_model} - Gateway - Admin",
crumb_url=f"/admin/gateway/models/{source_model}/edit",
)
return respond(request, "admin_gateway_model_form.html", {**context, "error": None}, model=AdminGatewayModelFormOut)
@router.post("/gateway/models/{source_model:path}/edit")
async def edit_model_save(request: Request, source_model: str):
admin = require_admin(request)
existing = routing.model_store.get(source_model)
if existing is None:
raise not_found("Model route not found")
data = dict(await request.form())
data["source_model"] = source_model
context = _model_form_context(
request,
admin,
is_edit=True,
form=_model_form_values_from_submission(data),
exclude_source=source_model,
title=f"Edit {source_model} - Gateway - Admin",
crumb_url=f"/admin/gateway/models/{source_model}/edit",
)
try:
payload = routing.ModelRouteIn(**_model_payload_kwargs(data))
except ValidationError as exc:
return _error_response(request, "admin_gateway_model_form.html", context, _first_error(exc))
fallback_error = _check_fallback(payload)
if fallback_error:
return _error_response(request, "admin_gateway_model_form.html", context, fallback_error)
_save_model(request, admin, payload)
return RedirectResponse(url=f"{INDEX_URL}?tab=models", status_code=302)
@router.post("/gateway/models/{source_model:path}/delete")
async def delete_model_page(request: Request, source_model: str):
admin = require_admin(request)
if not _remove_model(request, admin, source_model):
raise not_found("Model route not found")
return RedirectResponse(url=f"{INDEX_URL}?tab=models", status_code=302)
@router.post("/gateway/models/test-all")
async def test_all_models_page(request: Request):
admin = require_admin(request)
tested, failed = await health.test_all()
audit.record(
request,
"gateway.models.test_all",
user=admin,
target_type="gateway_models",
target_uid="all",
target_label=f"{tested} routes",
summary=(
f"admin {admin['username']} tested all gateway model routes: "
f"{tested - failed} ok, {failed} failed"
),
)
return RedirectResponse(
url=f"{INDEX_URL}?tab=models&tested=all", status_code=302
)
@router.post("/gateway/models/{source_model:path}/test")
async def test_model_page(request: Request, source_model: str):
admin = require_admin(request)
route = routing.model_store.get(source_model)
if route is None:
raise not_found("Model route not found")
result = await health.probe_route(source_model)
health.record_health(source_model, result)
audit.record(
request,
"gateway.model.test",
user=admin,
target_type="gateway_model",
target_uid=source_model,
target_label=source_model,
summary=(
f"admin {admin['username']} tested gateway model route "
f"{source_model}: {'ok' if result.ok else result.code}"
),
)
url = f"{INDEX_URL}?tab=models&tested={quote(source_model, safe='')}"
if (
result.ok
and route.kind == "image"
and result.image_url.startswith("http")
and len(result.image_url) <= 2000
):
url += f"&test_image={quote(result.image_url, safe='')}"
return RedirectResponse(url=url, status_code=302)
# --- Quota rules: JSON API (Devii + programmatic clients) -------------------
@router.get("/gateway/quota-rules")
async def list_quota_rules(request: Request):
require_admin(request)
rules = quota.quota_rule_store.list()
for rule in rules:
rule["spent_24h_usd"] = round(
quota.spent_24h(rule["owner_kind"], rule["owner_id"], rule["app_reference"]), 6
)
return JSONResponse(
{
"rules": rules,
"count": len(rules),
"defaults": _quota_defaults_summary(),
}
)
def _save_quota_rule(
request: Request, admin: dict, payload: "quota.QuotaRuleIn", uid: Optional[str] = None
) -> dict:
saved = quota.quota_rule_store.set(payload, uid=uid, created_by=admin["uid"])
audit.record(
request,
"gateway.quota_rule.update",
user=admin,
target_type="gateway_quota_rule",
target_uid=saved["uid"],
target_label=_rule_label(saved),
summary=f"admin {admin['username']} saved gateway quota rule ({_rule_label(saved)}) at ${saved['limit_usd']}/24h",
metadata={
"owner_kind": saved["owner_kind"],
"owner_id": saved["owner_id"],
"app_reference": saved["app_reference"],
"limit_usd": saved["limit_usd"],
"is_active": saved["is_active"],
},
)
return saved
@router.post("/gateway/quota-rules")
async def save_quota_rule_json(request: Request):
admin = require_admin(request)
body = await _payload(request)
uid = str(body.pop("uid", "") or "").strip() or None
try:
payload = quota.QuotaRuleIn(**body)
except ValidationError as exc:
return _validation_error(exc)
saved = _save_quota_rule(request, admin, payload, uid=uid)
return JSONResponse({"ok": True, "rule": saved})
@router.post("/gateway/quota-resets")
async def reset_quota_spend(request: Request):
admin = require_admin(request)
body = await _payload(request)
try:
payload = quota.QuotaResetIn(**body)
except ValidationError as exc:
return _validation_error(exc)
scope = quota.reset(payload, created_by=admin["uid"])
label = quota.scope_label(scope, fallback="every caller")
audit.record(
request,
"gateway.quota.reset",
user=admin,
target_type="gateway_quota",
target_uid=scope["uid"],
target_label=label,
summary=f"admin {admin['username']} reset the gateway 24h spend for {label}",
metadata={
"owner_kind": scope["owner_kind"],
"owner_id": scope["owner_id"],
"app_reference": scope["app_reference"],
"reset_at": scope["reset_at"],
},
)
return JSONResponse({"ok": True, "reset": scope})
@router.delete("/gateway/quota-rules/{uid}")
async def delete_quota_rule(request: Request, uid: str):
admin = require_admin(request)
existing = quota.quota_rule_store.get(uid)
label = _rule_label(existing.as_dict()) if existing else uid
existed = quota.quota_rule_store.remove(uid)
if not existed:
return JSONResponse({"ok": False, "error": "Quota rule not found"}, status_code=404)
audit.record(
request,
"gateway.quota_rule.delete",
user=admin,
target_type="gateway_quota_rule",
target_uid=uid,
target_label=label,
summary=f"admin {admin['username']} deleted gateway quota rule ({label})",
)
return JSONResponse({"ok": True})
# --- Quota rules: backend-rendered pages -------------------------------------
QUOTA_FORM_DEFAULTS = {
"owner_kind": "",
"owner_id": "",
"app_reference": "",
"limit_usd": "0",
"is_active": "1",
"label": "",
}
def _quota_form_values(data: Optional[dict] = None) -> dict:
if not data:
return dict(QUOTA_FORM_DEFAULTS)
values = dict(QUOTA_FORM_DEFAULTS)
for key in values:
if key in data and data[key] is not None:
values[key] = str(data[key])
values["is_active"] = _bool_str(data.get("is_active", "1"))
return values
@router.get("/gateway/quota-rules/new", response_class=HTMLResponse)
async def new_quota_rule_page(request: Request):
admin = require_admin(request)
return respond(
request,
"admin_gateway_quota_form.html",
{
**_seo(request, "Add quota rule - Gateway - Admin", _breadcrumbs({"name": "Add quota rule", "url": "/admin/gateway/quota-rules/new"})),
"user": admin,
"admin_section": "gateway",
"is_edit": False,
"form": _quota_form_values(),
"error": None,
},
model=AdminGatewayQuotaFormOut,
)
@router.post("/gateway/quota-rules/new")
async def create_quota_rule_page(request: Request):
admin = require_admin(request)
data = dict(await request.form())
try:
payload = quota.QuotaRuleIn(
owner_kind=_blank_to_none(data.get("owner_kind")),
owner_id=_blank_to_none(data.get("owner_id")),
app_reference=_blank_to_none(data.get("app_reference")),
limit_usd=data.get("limit_usd", "0") or "0",
is_active=data.get("is_active", "1"),
label=data.get("label", ""),
)
except ValidationError as exc:
return _error_response(
request,
"admin_gateway_quota_form.html",
{
**_seo(request, "Add quota rule - Gateway - Admin", _breadcrumbs({"name": "Add quota rule", "url": "/admin/gateway/quota-rules/new"})),
"user": admin,
"admin_section": "gateway",
"is_edit": False,
"form": _quota_form_values(data),
},
_first_error(exc),
)
_save_quota_rule(request, admin, payload)
return RedirectResponse(url=f"{INDEX_URL}?tab=quota", status_code=302)
@router.get("/gateway/quota-rules/{uid}/edit", response_class=HTMLResponse)
async def edit_quota_rule_page(request: Request, uid: str):
admin = require_admin(request)
rule = quota.quota_rule_store.get(uid)
if rule is None:
raise not_found("Quota rule not found")
rule_dict = rule.as_dict()
return respond(
request,
"admin_gateway_quota_form.html",
{
**_seo(
request,
"Edit quota rule - Gateway - Admin",
_breadcrumbs({"name": "Edit quota rule", "url": f"/admin/gateway/quota-rules/{uid}/edit"}),
),
"user": admin,
"admin_section": "gateway",
"is_edit": True,
"uid": uid,
"form": _quota_form_values(rule_dict),
"error": None,
},
model=AdminGatewayQuotaFormOut,
)
@router.post("/gateway/quota-rules/{uid}/edit")
async def edit_quota_rule_save(request: Request, uid: str):
admin = require_admin(request)
existing = quota.quota_rule_store.get(uid)
if existing is None:
raise not_found("Quota rule not found")
data = dict(await request.form())
try:
payload = quota.QuotaRuleIn(
owner_kind=_blank_to_none(data.get("owner_kind")),
owner_id=_blank_to_none(data.get("owner_id")),
app_reference=_blank_to_none(data.get("app_reference")),
limit_usd=data.get("limit_usd", "0") or "0",
is_active=data.get("is_active", "1"),
label=data.get("label", ""),
)
except ValidationError as exc:
return _error_response(
request,
"admin_gateway_quota_form.html",
{
**_seo(
request,
"Edit quota rule - Gateway - Admin",
_breadcrumbs({"name": "Edit quota rule", "url": f"/admin/gateway/quota-rules/{uid}/edit"}),
),
"user": admin,
"admin_section": "gateway",
"is_edit": True,
"uid": uid,
"form": _quota_form_values(data),
},
_first_error(exc),
)
_save_quota_rule(request, admin, payload, uid=uid)
return RedirectResponse(url=f"{INDEX_URL}?tab=quota", status_code=302)
@router.post("/gateway/quota-rules/{uid}/delete")
async def delete_quota_rule_page(request: Request, uid: str):
admin = require_admin(request)
existing = quota.quota_rule_store.get(uid)
label = _rule_label(existing.as_dict()) if existing else uid
if not quota.quota_rule_store.remove(uid):
raise not_found("Quota rule not found")
audit.record(
request,
"gateway.quota_rule.delete",
user=admin,
target_type="gateway_quota_rule",
target_uid=uid,
target_label=label,
summary=f"admin {admin['username']} deleted gateway quota rule ({label})",
)
return RedirectResponse(url=f"{INDEX_URL}?tab=quota", status_code=302)
@router.post("/gateway/quota-rules/{uid}/reset")
async def reset_quota_rule_page(request: Request, uid: str):
admin = require_admin(request)
existing = quota.quota_rule_store.get(uid)
if existing is None:
raise not_found("Quota rule not found")
scope = quota.reset(
quota.QuotaResetIn(
owner_kind=existing.owner_kind,
owner_id=existing.owner_id,
app_reference=existing.app_reference,
),
created_by=admin["uid"],
)
label = quota.scope_label(scope, fallback="every caller")
audit.record(
request,
"gateway.quota.reset",
user=admin,
target_type="gateway_quota",
target_uid=scope["uid"],
target_label=label,
summary=f"admin {admin['username']} reset the gateway 24h spend for {label}",
metadata={
"owner_kind": scope["owner_kind"],
"owner_id": scope["owner_id"],
"app_reference": scope["app_reference"],
"reset_at": scope["reset_at"],
},
)
return RedirectResponse(url=f"{INDEX_URL}?tab=quota", status_code=302)
# --- Stats: JSON API for the Stats tab's charts ------------------------------
def _stats_context(range_key: str) -> dict:
if range_key not in model_stats_query.RANGE_SECONDS:
range_key = DEFAULT_STATS_RANGE
summary = model_stats_query.compute_summary(range_key)
return _stats_view(summary, range_key)
def _stats_view(summary: dict, range_key: str) -> dict:
per_model = summary["per_model"]
generated = datetime.fromtimestamp(summary["generated_at"], tz=timezone.utc)
return {
"stats": summary,
"stats_range": range_key,
"stats_generated_iso": generated.isoformat(),
"stats_models": model_stats_query.list_known_models()[:ADMIN_LIST_CAP],
"stats_table_models": per_model[:ADMIN_LIST_CAP],
"stats_table_models_total": len(per_model),
}
@router.get("/gateway/stats/data")
async def gateway_stats_data(request: Request, range: str = DEFAULT_STATS_RANGE):
require_admin(request)
try:
return JSONResponse(model_stats_query.compute_summary(range))
except ValueError:
return json_error(400, f"Unknown range: {range!r}")
@router.get("/gateway/stats/fragment", response_class=HTMLResponse)
async def gateway_stats_fragment(request: Request, range: str = DEFAULT_STATS_RANGE):
require_admin(request)
if range not in model_stats_query.RANGE_SECONDS:
return json_error(400, f"Unknown range: {range!r}")
context = _stats_context(range)
return HTMLResponse(
templates.get_template("_gateway_stats_fragment.html").render(**context)
)
@router.get("/gateway/stats/models")
async def gateway_stats_models(request: Request):
require_admin(request)
return JSONResponse({"models": model_stats_query.list_known_models()})
@router.get("/gateway/stats/model/{provider}/{model:path}")
async def gateway_stats_model_detail(
request: Request, provider: str, model: str, range: str = "24h"
):
require_admin(request)
try:
return JSONResponse(model_stats_query.compute_model_detail(provider, model, range))
except ValueError:
return json_error(400, f"Unknown range: {range!r}")