Files
devplacepy/devplacepy/routers/admin/gateway_configs.py
T
retoorandClaude Sonnet 5.5 151476125f Gateway: auto-resolve request shape per provider and model
An upstream that rejects a key the gateway adds (e.g. thinking) now gets
retried with other shapes on a parsable 400/422; the working method is
stored per (provider, target model) and applied first-try from then on.
Fallback attempts are re-shaped per attempt. Admin list/reset, Devii
tools, audit event and ledger resolved_method included.

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

1138 lines
39 KiB
Python

# retoor <retoor@molodetz.nl>
import logging
from typing import Optional
from urllib.parse import quote
from fastapi import APIRouter, 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.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")
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 templates.TemplateResponse(
request,
template,
{**context, "request": request, "error": message},
status_code=status_code,
)
def _models_with_learned() -> list[dict]:
models = routing.model_store.list()
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 = ""
):
admin = require_admin(request)
if tab not in TABS:
tab = "models"
if not test_image.startswith("http"):
test_image = ""
quota_rules = quota.quota_rule_store.list()
for rule in quota_rules:
rule["spent_24h_usd"] = round(
quota.spent_24h(rule["owner_kind"], rule["owner_id"], rule["app_reference"]), 6
)
return respond(
request,
"admin_gateway.html",
{
**_seo(request, "Gateway routing - Admin", _breadcrumbs()),
"user": admin,
"admin_section": "gateway",
"tab": tab,
"providers": routing.provider_store.list(),
"models": _models_with_learned(),
"quota_rules": quota_rules,
"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 ------------------------------
@router.get("/gateway/stats/data")
async def gateway_stats_data(request: Request, range: str = "24h"):
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/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}")