"""Repository for persisted model providers and model routes.""" from __future__ import annotations import json from typing import Any from database.db_helper import Database class ModelProviderRepository: def __init__(self, database: Database): self.database = database @property def placeholder(self) -> str: return self.database._placeholder def upsert_provider(self, payload: dict[str, Any]) -> dict[str, Any]: provider_id = str(payload["provider_id"]).strip() existing = self.get_provider(provider_id) if existing: return self.update_provider(provider_id, payload) or existing placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO model_providers ( provider_id, display_name, provider_type, base_url, image_endpoint, api_key_env_var, api_key_secret_ref, enabled, timeout_seconds, capabilities_json, extra_headers_json, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( provider_id, str(payload.get("display_name") or provider_id), str(payload.get("provider_type") or "openai_compatible"), str(payload.get("base_url") or ""), str(payload.get("image_endpoint") or "/v1/images/generations"), _optional_text(payload.get("api_key_env_var")), _optional_text(payload.get("api_key_secret_ref")), _bool_int(payload.get("enabled", True)), _int_or_default(payload.get("timeout_seconds"), 180), _json_or_none(payload.get("capabilities") or {}), _json_or_none(payload.get("extra_headers") or {}), _json_or_none(payload.get("metadata") or {}), ), ) conn.commit() finally: conn.close() return self.get_provider(provider_id) or dict(payload) def update_provider(self, provider_id: str, payload: dict[str, Any]) -> dict[str, Any] | None: column_map = { "display_name": ("display_name", str), "provider_type": ("provider_type", str), "base_url": ("base_url", str), "image_endpoint": ("image_endpoint", str), "api_key_env_var": ("api_key_env_var", _optional_text), "api_key_secret_ref": ("api_key_secret_ref", _optional_text), "enabled": ("enabled", _bool_int), "timeout_seconds": ("timeout_seconds", lambda value: _int_or_default(value, 180)), "capabilities": ("capabilities_json", lambda value: _json_or_none(value or {})), "extra_headers": ("extra_headers_json", lambda value: _json_or_none(value or {})), "metadata": ("metadata_json", lambda value: _json_or_none(value or {})), } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key, (column, normalizer) in column_map.items(): if key not in payload: continue assignments.append(f"{column} = {placeholder}") params.append(normalizer(payload[key])) if not assignments: return self.get_provider(provider_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(provider_id) conn = self.database.connect() try: conn.execute( f""" UPDATE model_providers SET {", ".join(assignments)} WHERE provider_id = {placeholder} """, tuple(params), ) conn.commit() finally: conn.close() return self.get_provider(provider_id) def get_provider(self, provider_id: str) -> dict[str, Any] | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT * FROM model_providers WHERE provider_id = {placeholder}", (provider_id,), ).fetchone() finally: conn.close() return _row_to_provider(row) if row else None def list_providers(self, *, enabled: bool | None = None) -> list[dict[str, Any]]: params: list[Any] = [] where = "" if enabled is not None: where = f"WHERE enabled = {self.placeholder}" params.append(_bool_int(enabled)) conn = self.database.connect() try: rows = conn.execute( f""" SELECT * FROM model_providers {where} ORDER BY provider_id ASC """, tuple(params), ).fetchall() finally: conn.close() return [_row_to_provider(row) for row in rows] def upsert_route(self, payload: dict[str, Any]) -> dict[str, Any]: route_id = str(payload["route_id"]).strip() existing = self.get_route(route_id) if existing: return self.update_route(route_id, payload) or existing placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO model_routes ( route_id, route_name, provider_id, model_id, modality, priority, enabled, settings_json, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( route_id, str(payload["route_name"]).strip(), str(payload["provider_id"]).strip(), str(payload["model_id"]).strip(), str(payload.get("modality") or "image_generation"), _int_or_default(payload.get("priority"), 100), _bool_int(payload.get("enabled", True)), _json_or_none(payload.get("settings") or {}), _json_or_none(payload.get("metadata") or {}), ), ) conn.commit() finally: conn.close() return self.get_route(route_id) or dict(payload) def update_route(self, route_id: str, payload: dict[str, Any]) -> dict[str, Any] | None: column_map = { "route_name": ("route_name", str), "provider_id": ("provider_id", str), "model_id": ("model_id", str), "modality": ("modality", str), "priority": ("priority", lambda value: _int_or_default(value, 100)), "enabled": ("enabled", _bool_int), "settings": ("settings_json", lambda value: _json_or_none(value or {})), "metadata": ("metadata_json", lambda value: _json_or_none(value or {})), } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key, (column, normalizer) in column_map.items(): if key not in payload: continue assignments.append(f"{column} = {placeholder}") params.append(normalizer(payload[key])) if not assignments: return self.get_route(route_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(route_id) conn = self.database.connect() try: conn.execute( f""" UPDATE model_routes SET {", ".join(assignments)} WHERE route_id = {placeholder} """, tuple(params), ) conn.commit() finally: conn.close() return self.get_route(route_id) def get_route(self, route_id: str) -> dict[str, Any] | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT * FROM model_routes WHERE route_id = {placeholder}", (route_id,), ).fetchone() finally: conn.close() return _row_to_route(row) if row else None def list_routes(self, *, enabled: bool | None = None) -> list[dict[str, Any]]: params: list[Any] = [] where = "" if enabled is not None: where = f"WHERE enabled = {self.placeholder}" params.append(_bool_int(enabled)) conn = self.database.connect() try: rows = conn.execute( f""" SELECT * FROM model_routes {where} ORDER BY route_name ASC, priority ASC, route_id ASC """, tuple(params), ).fetchall() finally: conn.close() return [_row_to_route(row) for row in rows] def resolve_route(self, route_name: str, *, modality: str | None = None) -> dict[str, Any] | None: params: list[Any] = [route_name] modality_clause = "" if modality: modality_clause = f"AND route.modality = {self.placeholder}" params.append(modality) conn = self.database.connect() try: row = conn.execute( f""" SELECT route.*, provider.display_name AS provider_display_name, provider.provider_type, provider.base_url, provider.image_endpoint, provider.api_key_env_var, provider.api_key_secret_ref, provider.timeout_seconds, provider.capabilities_json AS provider_capabilities_json, provider.extra_headers_json AS provider_extra_headers_json FROM model_routes route JOIN model_providers provider ON provider.provider_id = route.provider_id WHERE route.route_name = {self.placeholder} AND route.enabled = 1 AND provider.enabled = 1 {modality_clause} ORDER BY route.priority ASC, route.route_id ASC """, tuple(params), ).fetchone() finally: conn.close() return _row_to_resolved_route(row) if row else None def resolve_provider_model( self, provider_id: str, model_id: str, *, modality: str | None = None, ) -> dict[str, Any] | None: """Resolve an enabled route from the provider/model identity used by discovery UIs.""" params: list[Any] = [provider_id, model_id] modality_clause = "" if modality: modality_clause = f"AND route.modality = {self.placeholder}" params.append(modality) conn = self.database.connect() try: row = conn.execute( f""" SELECT route.*, provider.display_name AS provider_display_name, provider.provider_type, provider.base_url, provider.image_endpoint, provider.api_key_env_var, provider.api_key_secret_ref, provider.timeout_seconds, provider.capabilities_json AS provider_capabilities_json, provider.extra_headers_json AS provider_extra_headers_json FROM model_routes route JOIN model_providers provider ON provider.provider_id = route.provider_id WHERE route.provider_id = {self.placeholder} AND route.model_id = {self.placeholder} AND route.enabled = 1 AND provider.enabled = 1 {modality_clause} ORDER BY route.priority ASC, route.route_id ASC """, tuple(params), ).fetchone() finally: conn.close() return _row_to_resolved_route(row) if row else None def _row_to_provider(row) -> dict[str, Any]: return { "provider_id": row["provider_id"], "display_name": row["display_name"], "provider_type": row["provider_type"], "base_url": row["base_url"], "image_endpoint": row["image_endpoint"], "api_key_env_var": row["api_key_env_var"], "api_key_secret_ref": row["api_key_secret_ref"], "enabled": bool(row["enabled"]), "timeout_seconds": int(row["timeout_seconds"]), "capabilities": _json_loads(row["capabilities_json"]), "extra_headers": _json_loads(row["extra_headers_json"]), "metadata": _json_loads(row["metadata_json"]), "created_at": str(row["created_at"]), "updated_at": str(row["updated_at"]), } def _row_to_route(row) -> dict[str, Any]: return { "route_id": row["route_id"], "route_name": row["route_name"], "provider_id": row["provider_id"], "model_id": row["model_id"], "modality": row["modality"], "priority": int(row["priority"]), "enabled": bool(row["enabled"]), "settings": _json_loads(row["settings_json"]), "metadata": _json_loads(row["metadata_json"]), "created_at": str(row["created_at"]), "updated_at": str(row["updated_at"]), } def _row_to_resolved_route(row) -> dict[str, Any]: route = _row_to_route(row) route["provider"] = { "provider_id": row["provider_id"], "display_name": row["provider_display_name"], "provider_type": row["provider_type"], "base_url": row["base_url"], "image_endpoint": row["image_endpoint"], "api_key_env_var": row["api_key_env_var"], "api_key_secret_ref": row["api_key_secret_ref"], "timeout_seconds": int(row["timeout_seconds"]), "capabilities": _json_loads(row["provider_capabilities_json"]), "extra_headers": _json_loads(row["provider_extra_headers_json"]), } return route def _json_or_none(value: Any | None) -> str | None: if value is None: return None return json.dumps(value, ensure_ascii=False, sort_keys=True) def _json_loads(value: str | None) -> dict[str, Any]: if not value: return {} return json.loads(value) def _optional_text(value: Any) -> str | None: text = str(value or "").strip() return text or None def _bool_int(value: Any) -> int: if isinstance(value, str): return 1 if value.strip().lower() in {"1", "true", "yes", "on"} else 0 return 1 if bool(value) else 0 def _int_or_default(value: Any, default: int) -> int: try: return int(value) except (TypeError, ValueError): return default