Files
devplacepy/devplacepy/services/openai_gateway/routing.py
T
2026-11-05 17:59:21 +01:00

1013 lines
38 KiB
Python

# retoor <retoor@molodetz.nl>
from __future__ import annotations
import logging
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import Optional
from pydantic import BaseModel, Field, field_validator, model_validator
from devplacepy.database import (
bump_cache_version,
db,
get_table,
sync_local_cache,
)
from devplacepy.services.openai_gateway import muse_code, opencode_zen
from devplacepy.services.openai_gateway.tool_emulation import (
TOOLS_MODE_NATIVE,
TOOLS_MODES,
)
logger = logging.getLogger(__name__)
PROVIDERS_TABLE = "gateway_providers"
MODELS_TABLE = "gateway_models"
CACHE_NAME = "gateway_routing"
KINDS = ("chat", "embed", "image")
# Admin-selectable on a gateway_providers row's `client_profile` field. A
# generic provider (the default, empty profile) sends no extra headers -
# this exists only for upstreams that reject requests unless they see a
# specific client's headers, e.g. OpenCode Zen's free tier only serves the
# real opencode CLI (spoofed via opencode_zen.opencode_impersonation_headers)
# and returns 429/400 to anything else, and api.meta.ai only serves
# subscription-billed keys to the real muse CLI (spoofed via
# muse_code.muse_impersonation_headers) since the 2026-10-29 rollout,
# returning 403 client_attestation_denied to anything else. Adding a new
# profile is one entry here plus one option in the provider form - no other
# special-casing.
CLIENT_PROFILES: dict = {
"": None,
"opencode": opencode_zen.opencode_impersonation_headers,
"muse": muse_code.muse_impersonation_headers,
}
# Upstream wire protocol a provider speaks. `chat_completions` is the
# classic OpenAI shape (base_url ends in /chat/completions, forwarded
# verbatim). `responses` is the Responses API shape (base_url ends in
# /responses); the gateway transpiles inbound Chat requests to it and
# converts Response objects / SSE events back to the normal OpenAI surface.
PROVIDER_PROTOCOLS = ("chat_completions", "responses")
PROTOCOL_DEFAULT = "chat_completions"
_ROUTING_CACHE: dict = {}
def _now() -> str:
return datetime.now(timezone.utc).isoformat()
def _as_bool(value) -> bool:
if isinstance(value, bool):
return value
if isinstance(value, (int, float)):
return value != 0
return str(value).strip() in ("1", "true", "True", "yes", "on")
def _embed_url_from_base(base_url: str) -> str:
base_url = (base_url or "").strip()
if not base_url:
return ""
if base_url.endswith("/chat/completions"):
return base_url[: -len("/chat/completions")] + "/embeddings"
return base_url
def _image_url_from_base(base_url: str) -> str:
base_url = (base_url or "").strip()
if not base_url:
return ""
if base_url.endswith("/chat/completions"):
return base_url[: -len("/chat/completions")] + "/images"
return base_url
def _models_url_from_base(base_url: str) -> str:
base_url = (base_url or "").strip()
if not base_url:
return ""
if base_url.endswith("/chat/completions"):
return base_url[: -len("/chat/completions")] + "/models"
return base_url.rstrip("/") + "/models"
def _responses_models_urls(base_url: str) -> list:
# A Responses-protocol provider's model listing is vendor-specific:
# OpenAI serves /models next to /responses, Meta serves
# /muse-code/models. Probe both, first success wins.
base_url = (base_url or "").strip()
if not base_url:
return []
if base_url.endswith("/responses"):
root = base_url[: -len("/responses")].rstrip("/")
else:
root = base_url.rstrip("/")
return [root + "/models", root + "/muse-code/models"]
PROVIDER_MODELS_PROBE_TIMEOUT = 8.0
def _default_provider_credentials() -> tuple[str, str]:
from devplacepy.services.manager import service_manager
svc = service_manager.get_service("openai")
cfg = svc.get_config() if svc is not None else {}
return cfg.get("gateway_upstream_url", ""), cfg.get("gateway_api_key", "")
def _default_provider_protocol() -> str:
from devplacepy.services.manager import service_manager
svc = service_manager.get_service("openai")
cfg = svc.get_config() if svc is not None else {}
return cfg.get("gateway_upstream_protocol", PROTOCOL_DEFAULT) or PROTOCOL_DEFAULT
async def fetch_provider_models(
provider_name: str, timeout: float = PROVIDER_MODELS_PROBE_TIMEOUT
) -> Optional[list[str]]:
provider_name = (provider_name or "").strip()
if provider_name:
provider = provider_store.get(provider_name)
if provider is None:
return None
base_url = provider.get("base_url", "")
api_key = provider.get("api_key", "")
protocol = provider.get("protocol", PROTOCOL_DEFAULT) or PROTOCOL_DEFAULT
else:
base_url, api_key = _default_provider_credentials()
protocol = _default_provider_protocol()
if protocol == "responses":
models_urls = _responses_models_urls(base_url)
else:
single = _models_url_from_base(base_url)
models_urls = [single] if single else []
if not models_urls:
return None
from devplacepy import stealth
headers: dict = {}
if provider_name:
header_hook = _header_hook_for(provider_name)
if header_hook is not None:
headers.update(header_hook())
if api_key:
headers["authorization"] = f"Bearer {api_key}"
for models_url in models_urls:
try:
async with stealth.stealth_async_client(
timeout=timeout, headers=headers
) as client:
response = await client.get(models_url)
except Exception as exc:
logger.info(
"gateway provider model listing failed for %s: %s",
models_url,
exc,
)
continue
if response.status_code != 200:
continue
try:
payload = response.json()
except Exception:
continue
rows = payload.get("data") if isinstance(payload, dict) else None
if not isinstance(rows, list):
continue
ids = [
str(row["id"])
for row in rows
if isinstance(row, dict) and row.get("id")
]
if ids:
return ids
return None
MODEL_TIER2_COLUMNS = (
"context_tier_threshold_tokens",
"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_minute",
"off_peak_end_minute",
"off_peak_discount_pct",
)
MODEL_HEALTH_COLUMNS = (
"health_status",
"health_code",
"health_message",
"health_checked_at",
)
MODEL_TOOLS_COLUMN = "tools_mode"
HEALTH_OK = "ok"
HEALTH_BAD = "bad"
def ensure_tables() -> None:
db.query(
"CREATE TABLE IF NOT EXISTS "
+ PROVIDERS_TABLE
+ " (id INTEGER PRIMARY KEY, name TEXT, base_url TEXT, api_key TEXT, "
"is_active INTEGER DEFAULT 1, client_profile TEXT DEFAULT '', "
"protocol TEXT DEFAULT 'chat_completions', "
"created_at TEXT, updated_at TEXT)"
)
providers_table = get_table(PROVIDERS_TABLE)
if not providers_table.has_column("client_profile"):
providers_table.create_column_by_example("client_profile", "")
if not providers_table.has_column("protocol"):
providers_table.create_column_by_example(
"protocol", PROTOCOL_DEFAULT
)
db.query(
"CREATE TABLE IF NOT EXISTS "
+ MODELS_TABLE
+ " (id INTEGER PRIMARY KEY, source_model TEXT, provider TEXT, "
"target_model TEXT, kind TEXT DEFAULT 'chat', vision_provider TEXT, "
"vision_model TEXT, context_window INTEGER DEFAULT 0, "
"price_cache_hit_per_m REAL DEFAULT 0, price_cache_miss_per_m REAL DEFAULT 0, "
"price_output_per_m REAL DEFAULT 0, price_input_per_m REAL DEFAULT 0, "
"context_tier_threshold_tokens INTEGER DEFAULT 0, "
"price_cache_hit_per_m_tier2 REAL, price_cache_miss_per_m_tier2 REAL, "
"price_output_per_m_tier2 REAL, price_input_per_m_tier2 REAL, "
"off_peak_start_minute INTEGER, off_peak_end_minute INTEGER, "
"off_peak_discount_pct REAL DEFAULT 0, fallback_model TEXT DEFAULT '', "
"is_active INTEGER DEFAULT 1, health_status TEXT DEFAULT '', "
"health_code TEXT DEFAULT '', health_message TEXT DEFAULT '', "
"health_checked_at TEXT DEFAULT '', "
"tools_mode TEXT DEFAULT 'native', "
"created_at TEXT, updated_at TEXT)"
)
models_table = get_table(MODELS_TABLE)
for column in MODEL_TIER2_COLUMNS:
if not models_table.has_column(column):
models_table.create_column_by_example(column, 0.0)
if not models_table.has_column("fallback_model"):
models_table.create_column_by_example("fallback_model", "")
for column in MODEL_HEALTH_COLUMNS:
if not models_table.has_column(column):
models_table.create_column_by_example(column, "")
if not models_table.has_column(MODEL_TOOLS_COLUMN):
models_table.create_column_by_example(MODEL_TOOLS_COLUMN, TOOLS_MODE_NATIVE)
try:
db.query(
"CREATE UNIQUE INDEX IF NOT EXISTS idx_gateway_providers_name ON "
+ PROVIDERS_TABLE
+ " (name)"
)
db.query(
"CREATE UNIQUE INDEX IF NOT EXISTS idx_gateway_models_source ON "
+ MODELS_TABLE
+ " (source_model)"
)
db.query(
"CREATE INDEX IF NOT EXISTS idx_gateway_models_kind ON "
+ MODELS_TABLE
+ " (kind)"
)
except Exception as exc:
logger.warning("gateway routing index creation failed: %s", exc)
class ProviderIn(BaseModel):
name: str = Field(min_length=1, max_length=64)
base_url: str = Field(default="", max_length=500)
api_key: str = Field(default="", max_length=400)
is_active: bool = True
client_profile: str = Field(default="", max_length=32)
protocol: str = Field(default=PROTOCOL_DEFAULT, max_length=32)
@field_validator("name")
@classmethod
def _clean_name(cls, value: str) -> str:
value = value.strip().lower()
if not value:
raise ValueError("Provider name is required")
if not all(c.isalnum() or c in "-_" for c in value):
raise ValueError("Provider name allows letters, numbers, hyphen, underscore")
return value
@field_validator("base_url")
@classmethod
def _clean_url(cls, value: str) -> str:
value = (value or "").strip()
if value and not (value.startswith("http://") or value.startswith("https://")):
raise ValueError("Base URL must be a http(s) URL")
return value
@field_validator("client_profile")
@classmethod
def _clean_client_profile(cls, value: str) -> str:
value = (value or "").strip().lower()
if value not in CLIENT_PROFILES:
raise ValueError(
f"client_profile must be one of: {', '.join(sorted(CLIENT_PROFILES)) or '(none)'}"
)
return value
@field_validator("protocol")
@classmethod
def _clean_protocol(cls, value: str) -> str:
value = (value or PROTOCOL_DEFAULT).strip().lower()
if value not in PROVIDER_PROTOCOLS:
raise ValueError(
f"protocol must be one of: {', '.join(PROVIDER_PROTOCOLS)}"
)
return value
class ModelRouteIn(BaseModel):
source_model: str = Field(min_length=1, max_length=128)
provider: str = Field(default="", max_length=64)
target_model: str = Field(min_length=1, max_length=128)
kind: str = "chat"
vision_provider: str = Field(default="", max_length=64)
vision_model: str = Field(default="", max_length=128)
context_window: int = Field(default=0, ge=0, le=100_000_000)
price_cache_hit_per_m: float = Field(default=0.0, ge=0)
price_cache_miss_per_m: float = Field(default=0.0, ge=0)
price_output_per_m: float = Field(default=0.0, ge=0)
price_input_per_m: float = Field(default=0.0, ge=0)
context_tier_threshold_tokens: int = Field(default=0, ge=0, le=100_000_000)
price_cache_hit_per_m_tier2: Optional[float] = Field(default=None, ge=0)
price_cache_miss_per_m_tier2: Optional[float] = Field(default=None, ge=0)
price_output_per_m_tier2: Optional[float] = Field(default=None, ge=0)
price_input_per_m_tier2: Optional[float] = Field(default=None, ge=0)
off_peak_start_minute: Optional[int] = Field(default=None, ge=0, le=1439)
off_peak_end_minute: Optional[int] = Field(default=None, ge=0, le=1439)
off_peak_discount_pct: float = Field(default=0.0, ge=0, le=100)
fallback_model: str = Field(default="", max_length=128)
tools_mode: str = Field(default=TOOLS_MODE_NATIVE, max_length=16)
is_active: bool = True
@field_validator("tools_mode")
@classmethod
def _clean_tools_mode(cls, value: str) -> str:
value = (value or TOOLS_MODE_NATIVE).strip().lower()
if value not in TOOLS_MODES:
raise ValueError(f"tools_mode must be one of: {', '.join(TOOLS_MODES)}")
return value
@field_validator("source_model", "target_model")
@classmethod
def _clean_model(cls, value: str) -> str:
value = (value or "").strip()
if not value:
raise ValueError("Model name is required")
return value
@field_validator("provider", "vision_provider", "vision_model", "fallback_model")
@classmethod
def _strip(cls, value: str) -> str:
return (value or "").strip()
@field_validator("kind")
@classmethod
def _clean_kind(cls, value: str) -> str:
value = (value or "chat").strip().lower()
if value not in KINDS:
raise ValueError("Kind must be 'chat', 'embed', or 'image'")
return value
@model_validator(mode="after")
def _check_off_peak_window(self) -> "ModelRouteIn":
has_start = self.off_peak_start_minute is not None
has_end = self.off_peak_end_minute is not None
if has_start != has_end:
raise ValueError(
"Off-peak start and end minute must both be set, or both left blank"
)
return self
@model_validator(mode="after")
def _check_fallback_is_not_self(self) -> "ModelRouteIn":
if self.fallback_model and self.fallback_model == self.source_model:
raise ValueError("A model cannot fall back to itself")
return self
@dataclass(frozen=True)
class ModelRoute:
source_model: str
provider: str
target_model: str
kind: str
vision_provider: str
vision_model: str
context_window: int
price_cache_hit_per_m: float
price_cache_miss_per_m: float
price_output_per_m: float
price_input_per_m: float
context_tier_threshold_tokens: int
price_cache_hit_per_m_tier2: Optional[float]
price_cache_miss_per_m_tier2: Optional[float]
price_output_per_m_tier2: Optional[float]
price_input_per_m_tier2: Optional[float]
off_peak_start_minute: Optional[int]
off_peak_end_minute: Optional[int]
off_peak_discount_pct: float
fallback_model: str
is_active: bool
health_status: str
health_code: str
health_message: str
health_checked_at: str
tools_mode: str
def _opt_float(row: dict, key: str) -> Optional[float]:
value = row.get(key)
return float(value) if value is not None else None
def _opt_int(row: dict, key: str) -> Optional[int]:
value = row.get(key)
return int(value) if value is not None else None
def _route_from_row(row: dict) -> ModelRoute:
return ModelRoute(
source_model=str(row.get("source_model") or ""),
provider=str(row.get("provider") or ""),
target_model=str(row.get("target_model") or ""),
kind=str(row.get("kind") or "chat"),
vision_provider=str(row.get("vision_provider") or ""),
vision_model=str(row.get("vision_model") or ""),
context_window=int(row.get("context_window") or 0),
price_cache_hit_per_m=float(row.get("price_cache_hit_per_m") or 0.0),
price_cache_miss_per_m=float(row.get("price_cache_miss_per_m") or 0.0),
price_output_per_m=float(row.get("price_output_per_m") or 0.0),
price_input_per_m=float(row.get("price_input_per_m") or 0.0),
context_tier_threshold_tokens=int(
row.get("context_tier_threshold_tokens") or 0
),
price_cache_hit_per_m_tier2=_opt_float(row, "price_cache_hit_per_m_tier2"),
price_cache_miss_per_m_tier2=_opt_float(row, "price_cache_miss_per_m_tier2"),
price_output_per_m_tier2=_opt_float(row, "price_output_per_m_tier2"),
price_input_per_m_tier2=_opt_float(row, "price_input_per_m_tier2"),
off_peak_start_minute=_opt_int(row, "off_peak_start_minute"),
off_peak_end_minute=_opt_int(row, "off_peak_end_minute"),
off_peak_discount_pct=float(row.get("off_peak_discount_pct") or 0.0),
fallback_model=str(row.get("fallback_model") or ""),
is_active=_as_bool(row.get("is_active", 1)),
health_status=str(row.get("health_status") or ""),
health_code=str(row.get("health_code") or ""),
health_message=str(row.get("health_message") or ""),
health_checked_at=str(row.get("health_checked_at") or ""),
tools_mode=str(row.get("tools_mode") or TOOLS_MODE_NATIVE),
)
def _load() -> dict:
sync_local_cache(CACHE_NAME, _ROUTING_CACHE)
if "providers" not in _ROUTING_CACHE:
providers: dict = {}
models: dict = {}
try:
if PROVIDERS_TABLE in db.tables:
for row in get_table(PROVIDERS_TABLE).all():
name = str(row.get("name") or "").strip().lower()
if name:
providers[name] = {
"name": name,
"base_url": str(row.get("base_url") or ""),
"api_key": str(row.get("api_key") or ""),
"is_active": _as_bool(row.get("is_active", 1)),
"client_profile": str(row.get("client_profile") or ""),
"protocol": str(
row.get("protocol") or PROTOCOL_DEFAULT
),
}
if MODELS_TABLE in db.tables:
for row in get_table(MODELS_TABLE).all():
source = str(row.get("source_model") or "").strip()
if source:
models[source] = _route_from_row(row)
except Exception as exc:
logger.warning("gateway routing load failed: %s", exc)
_ROUTING_CACHE["providers"] = providers
_ROUTING_CACHE["models"] = models
return _ROUTING_CACHE
class ProviderStore:
def list(self) -> list[dict]:
return sorted(_load()["providers"].values(), key=lambda p: p["name"])
def get(self, name: str) -> Optional[dict]:
if not name:
return None
return _load()["providers"].get(name.strip().lower())
def names(self) -> list[str]:
return sorted(_load()["providers"].keys())
def count(self) -> int:
return len(_load()["providers"])
def set(self, payload: ProviderIn) -> dict:
ensure_tables()
table = get_table(PROVIDERS_TABLE)
existing = table.find_one(name=payload.name)
record = {
"name": payload.name,
"base_url": payload.base_url,
"api_key": payload.api_key,
"is_active": 1 if payload.is_active else 0,
"client_profile": payload.client_profile,
"protocol": payload.protocol,
"updated_at": _now(),
}
if existing:
table.update({**record, "id": existing["id"]}, ["id"])
else:
record["created_at"] = _now()
table.insert(record)
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()
return self.get(payload.name) or record
def remove(self, name: str) -> bool:
name = (name or "").strip().lower()
if not name or PROVIDERS_TABLE not in db.tables:
return False
removed = int(get_table(PROVIDERS_TABLE).delete(name=name))
if removed:
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()
return bool(removed)
class ModelStore:
def list(self) -> list[dict]:
rows = []
for route in _load()["models"].values():
rows.append(route.__dict__.copy())
return sorted(rows, key=lambda r: r["source_model"])
def get(self, source_model: str) -> Optional[ModelRoute]:
if not source_model:
return None
return _load()["models"].get(source_model.strip())
def resolve(self, source_model: Optional[str], kind: str) -> Optional[ModelRoute]:
if not source_model:
return None
route = _load()["models"].get(source_model.strip())
if route is None or not route.is_active or route.kind != kind:
return None
return route
def count(self) -> int:
return len(_load()["models"])
def set(self, payload: ModelRouteIn) -> dict:
ensure_tables()
table = get_table(MODELS_TABLE)
existing = table.find_one(source_model=payload.source_model)
record = {
"source_model": payload.source_model,
"provider": payload.provider,
"target_model": payload.target_model,
"kind": payload.kind,
"vision_provider": payload.vision_provider,
"vision_model": payload.vision_model,
"context_window": payload.context_window,
"price_cache_hit_per_m": payload.price_cache_hit_per_m,
"price_cache_miss_per_m": payload.price_cache_miss_per_m,
"price_output_per_m": payload.price_output_per_m,
"price_input_per_m": payload.price_input_per_m,
"context_tier_threshold_tokens": payload.context_tier_threshold_tokens,
"price_cache_hit_per_m_tier2": payload.price_cache_hit_per_m_tier2,
"price_cache_miss_per_m_tier2": payload.price_cache_miss_per_m_tier2,
"price_output_per_m_tier2": payload.price_output_per_m_tier2,
"price_input_per_m_tier2": payload.price_input_per_m_tier2,
"off_peak_start_minute": payload.off_peak_start_minute,
"off_peak_end_minute": payload.off_peak_end_minute,
"off_peak_discount_pct": payload.off_peak_discount_pct,
"fallback_model": payload.fallback_model,
"tools_mode": payload.tools_mode,
"is_active": 1 if payload.is_active else 0,
"updated_at": _now(),
}
if existing:
table.update({**record, "id": existing["id"]}, ["id"])
else:
record["created_at"] = _now()
table.insert(record)
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()
route = self.get(payload.source_model)
return route.__dict__.copy() if route else record
def remove(self, source_model: str) -> bool:
source_model = (source_model or "").strip()
if not source_model or MODELS_TABLE not in db.tables:
return False
removed = int(get_table(MODELS_TABLE).delete(source_model=source_model))
if removed:
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()
return bool(removed)
provider_store = ProviderStore()
model_store = ModelStore()
def resolve_fallback(source_model: Optional[str], kind: str) -> Optional[ModelRoute]:
route = model_store.resolve(source_model, kind)
if route is None or not route.fallback_model:
return None
if route.fallback_model == route.source_model:
return None
fallback = model_store.resolve(route.fallback_model, kind)
if fallback is None or fallback.source_model == route.source_model:
return None
return fallback
MAX_FALLBACK_HOPS = 5
def is_route_healthy(route: Optional[ModelRoute]) -> bool:
return route is not None and (route.health_status or "") != HEALTH_BAD
def resolve_fallback_chain(
source_model: Optional[str], kind: str, max_hops: int = MAX_FALLBACK_HOPS
) -> list:
"""Attempt line after `source_model`: usable routes only, in order.
Inactive and unhealthy links are skipped transparently (their own
fallback is followed instead), so a bad link never breaks the line.
The visited set makes cycles impossible; max_hops caps the attempts.
"""
line = []
seen = set()
source = (source_model or "").strip()
current = source
while current and current not in seen and len(line) < max_hops:
seen.add(current)
route = model_store.get(current)
if route is None or route.kind != kind:
break
nxt = (route.fallback_model or "").strip()
if not nxt or nxt == current:
break
current = nxt
target = model_store.get(current)
if target is None or target.kind != kind:
break
if (
current != source
and target.is_active
and is_route_healthy(target)
):
line.append(target)
return line
def resolve_entry_route(
source_model: Optional[str], kind: str
) -> Optional[ModelRoute]:
"""Route a direct request starts on: healthy-next when bad, else itself.
An unhealthy route with a usable fallback line starts on the line's
first member (bad models are skipped without attempting); when the
line is empty the original route is still tried - health is advisory,
and the model may have recovered since its last test.
"""
route = model_store.resolve(source_model, kind)
if route is None or is_route_healthy(route):
return route
chain = resolve_fallback_chain(route.source_model, kind)
if chain:
return chain[0]
return route
DEEPSEEK_DEFAULT_ROUTES = (
{
"source_model": "deepseek-v4-flash",
"target_model": "deepseek-v4-flash",
"context_window": 1_048_576,
"price_cache_hit_per_m": 0.0028,
"price_cache_miss_per_m": 0.14,
"price_output_per_m": 0.28,
},
{
"source_model": "deepseek-v4-pro",
"target_model": "deepseek-v4-pro",
"context_window": 1_048_576,
"price_cache_hit_per_m": 0.003625,
"price_cache_miss_per_m": 0.435,
"price_output_per_m": 0.87,
},
{
"source_model": "molodetz",
"target_model": "deepseek-v4-flash",
"context_window": 1_048_576,
"price_cache_hit_per_m": 0.0028,
"price_cache_miss_per_m": 0.14,
"price_output_per_m": 0.28,
},
{
"source_model": "molodetz-pro",
"target_model": "deepseek-v4-pro",
"context_window": 1_048_576,
"price_cache_hit_per_m": 0.003625,
"price_cache_miss_per_m": 0.435,
"price_output_per_m": 0.87,
},
)
def seed_default_deepseek_routes() -> None:
ensure_tables()
table = get_table(MODELS_TABLE)
seeded = False
for defaults in DEEPSEEK_DEFAULT_ROUTES:
if table.find_one(source_model=defaults["source_model"]):
continue
record = {
"source_model": defaults["source_model"],
"provider": "",
"target_model": defaults["target_model"],
"kind": "chat",
"vision_provider": "",
"vision_model": "",
"context_window": defaults["context_window"],
"price_cache_hit_per_m": defaults["price_cache_hit_per_m"],
"price_cache_miss_per_m": defaults["price_cache_miss_per_m"],
"price_output_per_m": defaults["price_output_per_m"],
"price_input_per_m": 0.0,
"context_tier_threshold_tokens": 0,
"price_cache_hit_per_m_tier2": None,
"price_cache_miss_per_m_tier2": None,
"price_output_per_m_tier2": None,
"price_input_per_m_tier2": None,
"off_peak_start_minute": None,
"off_peak_end_minute": None,
"off_peak_discount_pct": 0.0,
"is_active": 1,
"created_at": _now(),
"updated_at": _now(),
}
table.insert(record)
seeded = True
if seeded:
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()
def _header_hook_for(provider_name: str):
if not provider_name:
return None
provider = provider_store.get(provider_name)
if provider is None:
return None
return CLIENT_PROFILES.get(provider.get("client_profile") or "")
def _provider_overlay(name: str, base_key: str, url_key: str, overlay: dict) -> None:
provider = provider_store.get(name)
if provider is None:
return
if provider.get("base_url"):
overlay[url_key] = provider["base_url"]
if provider.get("api_key"):
overlay[base_key] = provider["api_key"]
def chat_overlay(requested_model: Optional[str], base_cfg: dict) -> Optional[dict]:
route = model_store.resolve(requested_model, "chat")
if route is None:
return None
overlay: dict = {
"gateway_force_model": True,
"gateway_model": route.target_model,
"gateway_price_cache_hit_per_m": route.price_cache_hit_per_m,
"gateway_price_cache_miss_per_m": route.price_cache_miss_per_m,
"gateway_price_output_per_m": route.price_output_per_m,
"gateway_price_cache_hit_per_m_tier2": route.price_cache_hit_per_m_tier2,
"gateway_price_cache_miss_per_m_tier2": route.price_cache_miss_per_m_tier2,
"gateway_price_output_per_m_tier2": route.price_output_per_m_tier2,
"gateway_context_tier_threshold_tokens": route.context_tier_threshold_tokens,
"gateway_off_peak_start_minute": route.off_peak_start_minute,
"gateway_off_peak_end_minute": route.off_peak_end_minute,
"gateway_off_peak_discount_pct": route.off_peak_discount_pct,
"gateway_provider_name": route.provider or "default",
"gateway_tools_mode": route.tools_mode,
}
if route.provider:
_provider_overlay(
route.provider, "gateway_api_key", "gateway_upstream_url", overlay
)
header_hook = _header_hook_for(route.provider)
if header_hook is not None:
overlay["gateway_extra_request_headers"] = header_hook()
provider = provider_store.get(route.provider)
if provider is not None:
overlay["gateway_upstream_protocol"] = (
provider.get("protocol") or PROTOCOL_DEFAULT
)
if provider.get("client_profile"):
overlay["gateway_client_profile"] = provider["client_profile"]
if route.context_window:
from devplacepy.services.openai_gateway.usage import parse_context_map
context_map = parse_context_map(base_cfg.get("gateway_model_context_map"))
context_map[route.target_model] = route.context_window
overlay["gateway_model_context_map"] = context_map
if route.vision_model:
overlay["gateway_vision_enabled"] = True
overlay["gateway_vision_model"] = route.vision_model
overlay["gateway_vision_price_input_per_m"] = route.price_input_per_m
overlay["gateway_vision_price_output_per_m"] = route.price_output_per_m
overlay["gateway_vision_price_input_per_m_tier2"] = (
route.price_input_per_m_tier2
)
overlay["gateway_vision_price_output_per_m_tier2"] = (
route.price_output_per_m_tier2
)
vision_provider = route.vision_provider or route.provider
if vision_provider:
_provider_overlay(
vision_provider, "gateway_vision_key", "gateway_vision_url", overlay
)
return overlay
def embed_overlay(requested_model: Optional[str], base_cfg: dict) -> Optional[dict]:
route = model_store.resolve(requested_model, "embed")
if route is None:
return None
overlay: dict = {
"gateway_force_model": True,
"gateway_embed_model": route.target_model,
"gateway_embed_price_input_per_m": route.price_input_per_m,
"gateway_embed_price_input_per_m_tier2": route.price_input_per_m_tier2,
"gateway_context_tier_threshold_tokens": route.context_tier_threshold_tokens,
"gateway_off_peak_start_minute": route.off_peak_start_minute,
"gateway_off_peak_end_minute": route.off_peak_end_minute,
"gateway_off_peak_discount_pct": route.off_peak_discount_pct,
"gateway_provider_name": route.provider or "default",
}
provider = provider_store.get(route.provider) if route.provider else None
if provider:
if provider.get("base_url"):
overlay["gateway_embed_url"] = _embed_url_from_base(provider["base_url"])
if provider.get("api_key"):
overlay["gateway_embed_key"] = provider["api_key"]
header_hook = _header_hook_for(route.provider)
if header_hook is not None:
overlay["gateway_extra_request_headers"] = header_hook()
if provider.get("client_profile"):
overlay["gateway_client_profile"] = provider["client_profile"]
return overlay
def image_overlay(requested_model: Optional[str], base_cfg: dict) -> Optional[dict]:
route = model_store.resolve(requested_model, "image")
if route is None:
return None
overlay: dict = {
"gateway_force_model": True,
"gateway_image_model": route.target_model,
"gateway_image_price_per_call": route.price_input_per_m,
"gateway_off_peak_start_minute": route.off_peak_start_minute,
"gateway_off_peak_end_minute": route.off_peak_end_minute,
"gateway_off_peak_discount_pct": route.off_peak_discount_pct,
"gateway_provider_name": route.provider or "default",
}
provider = provider_store.get(route.provider) if route.provider else None
if provider:
if provider.get("base_url"):
overlay["gateway_image_url"] = _image_url_from_base(provider["base_url"])
if provider.get("api_key"):
overlay["gateway_image_key"] = provider["api_key"]
header_hook = _header_hook_for(route.provider)
if header_hook is not None:
overlay["gateway_extra_request_headers"] = header_hook()
if provider.get("client_profile"):
overlay["gateway_client_profile"] = provider["client_profile"]
return overlay
OPENROUTER_PROVIDER_NAME = "openrouter"
FLUX_TARGET_MODEL = "black-forest-labs/flux.2-pro"
IMAGE_SOURCE_MODEL = "molodetz-img-small"
RETIRED_IMAGE_MODELS = {
"black-forest-labs/flux-1.1-pro": FLUX_TARGET_MODEL,
"black-forest-labs/flux-schnell": "black-forest-labs/flux.2-klein-4b",
}
LEGACY_IMAGE_URL = "https://openrouter.ai/api/v1/images/generations"
def seed_default_image_routes() -> None:
import os
from devplacepy.services.openai_gateway import config as gw_config
ensure_tables()
openrouter_key = os.environ.get("OPENROUTER_API_KEY", "")
if openrouter_key:
existing_provider = provider_store.get(OPENROUTER_PROVIDER_NAME)
if existing_provider is None:
provider_store.set(
ProviderIn(
name=OPENROUTER_PROVIDER_NAME,
base_url="https://openrouter.ai/api/v1/chat/completions",
api_key=openrouter_key,
is_active=True,
)
)
models_table = get_table(MODELS_TABLE)
if models_table.find_one(source_model=IMAGE_SOURCE_MODEL):
return
record = {
"source_model": IMAGE_SOURCE_MODEL,
"provider": OPENROUTER_PROVIDER_NAME if openrouter_key else "",
"target_model": FLUX_TARGET_MODEL,
"kind": "image",
"vision_provider": "",
"vision_model": "",
"context_window": 0,
"price_cache_hit_per_m": 0.0,
"price_cache_miss_per_m": 0.0,
"price_output_per_m": 0.0,
"price_input_per_m": gw_config.IMAGE_PRICE_PER_CALL_DEFAULT,
"context_tier_threshold_tokens": 0,
"price_cache_hit_per_m_tier2": None,
"price_cache_miss_per_m_tier2": None,
"price_output_per_m_tier2": None,
"price_input_per_m_tier2": None,
"off_peak_start_minute": None,
"off_peak_end_minute": None,
"off_peak_discount_pct": 0.0,
"is_active": 1,
"created_at": _now(),
"updated_at": _now(),
}
models_table.insert(record)
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()
def migrate_retired_image_gateway() -> None:
from devplacepy.database import get_setting, set_setting
from devplacepy.services.openai_gateway import config as gw_config
ensure_tables()
models_table = get_table(MODELS_TABLE)
now = _now()
changed = False
for row in models_table.find(kind="image"):
target = str(row.get("target_model") or "")
replacement = RETIRED_IMAGE_MODELS.get(target)
if not replacement:
continue
models_table.update(
{
"source_model": row["source_model"],
"target_model": replacement,
"updated_at": now,
},
["source_model"],
)
changed = True
image_url = get_setting("gateway_image_url", "")
if image_url in (LEGACY_IMAGE_URL, ""):
set_setting("gateway_image_url", gw_config.IMAGE_URL_DEFAULT)
changed = True
elif image_url.endswith("/images/generations"):
set_setting(
"gateway_image_url",
image_url[: -len("/generations")],
)
changed = True
image_model = get_setting("gateway_image_model", "")
replacement = RETIRED_IMAGE_MODELS.get(image_model)
if replacement:
set_setting("gateway_image_model", replacement)
changed = True
elif not image_model:
set_setting("gateway_image_model", gw_config.IMAGE_MODEL_DEFAULT)
changed = True
if changed:
bump_cache_version(CACHE_NAME)
_ROUTING_CACHE.clear()