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>
1138 lines
39 KiB
Python
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}")
|