diff --git a/backend/services/model_provider_service.py b/backend/services/model_provider_service.py new file mode 100644 index 0000000..0e757cb --- /dev/null +++ b/backend/services/model_provider_service.py @@ -0,0 +1,62 @@ +"""Model provider pool service.""" + +from __future__ import annotations + +import re +from typing import Any + +from database.repositories.model_provider_repository import ModelProviderRepository + + +class ModelProviderService: + def __init__(self, repository: ModelProviderRepository): + self.repository = repository + + def upsert_provider(self, payload: dict[str, Any]) -> dict[str, Any]: + provider_id = _required_text(payload.get("provider_id"), "provider_id") + return self.repository.upsert_provider( + { + **payload, + "provider_id": provider_id, + "display_name": str(payload.get("display_name") or provider_id), + "provider_type": str(payload.get("provider_type") or "openai_compatible"), + "image_endpoint": str(payload.get("image_endpoint") or "/v1/images/generations"), + } + ) + + def upsert_route(self, payload: dict[str, Any]) -> dict[str, Any]: + route_name = _required_text(payload.get("route_name"), "route_name") + provider_id = _required_text(payload.get("provider_id"), "provider_id") + model_id = _required_text(payload.get("model_id"), "model_id") + return self.repository.upsert_route( + { + **payload, + "route_id": str(payload.get("route_id") or _route_id(route_name, provider_id, model_id)), + "route_name": route_name, + "provider_id": provider_id, + "model_id": model_id, + "modality": str(payload.get("modality") or "image_generation"), + } + ) + + def list_providers(self, *, enabled: bool | None = None) -> list[dict[str, Any]]: + return self.repository.list_providers(enabled=enabled) + + def list_routes(self, *, enabled: bool | None = None) -> list[dict[str, Any]]: + return self.repository.list_routes(enabled=enabled) + + def resolve_route(self, route_name: str, *, modality: str | None = None) -> dict[str, Any] | None: + return self.repository.resolve_route(route_name, modality=modality) + + +def _required_text(value: Any, field: str) -> str: + text = str(value or "").strip() + if not text: + raise ValueError(f"{field} is required") + return text + + +def _route_id(route_name: str, provider_id: str, model_id: str) -> str: + stem = "_".join([route_name, provider_id, model_id]) + normalized = re.sub(r"[^A-Za-z0-9_]+", "_", stem).strip("_").lower() + return f"route_{normalized or 'model'}" diff --git a/database/migrations/0013_model_providers.sql b/database/migrations/0013_model_providers.sql new file mode 100644 index 0000000..1eea19f --- /dev/null +++ b/database/migrations/0013_model_providers.sql @@ -0,0 +1,37 @@ +CREATE TABLE IF NOT EXISTS model_providers ( + provider_id TEXT PRIMARY KEY, + display_name TEXT NOT NULL, + provider_type TEXT NOT NULL DEFAULT 'openai_compatible', + base_url TEXT NOT NULL, + image_endpoint TEXT NOT NULL DEFAULT '/v1/images/generations', + api_key_env_var TEXT, + api_key_secret_ref TEXT, + enabled INTEGER NOT NULL DEFAULT 1, + timeout_seconds INTEGER NOT NULL DEFAULT 180, + capabilities_json TEXT, + extra_headers_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS model_routes ( + route_id TEXT PRIMARY KEY, + route_name TEXT NOT NULL, + provider_id TEXT NOT NULL, + model_id TEXT NOT NULL, + modality TEXT NOT NULL DEFAULT 'image_generation', + priority INTEGER NOT NULL DEFAULT 100, + enabled INTEGER NOT NULL DEFAULT 1, + settings_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + FOREIGN KEY(provider_id) REFERENCES model_providers(provider_id) +); + +CREATE INDEX IF NOT EXISTS idx_model_routes_provider + ON model_routes(provider_id); + +CREATE INDEX IF NOT EXISTS idx_model_routes_name_enabled_priority + ON model_routes(route_name, enabled, priority); diff --git a/database/models.py b/database/models.py index 2316dd1..2596244 100644 --- a/database/models.py +++ b/database/models.py @@ -114,6 +114,28 @@ TABLES: tuple[TableSpec, ...] = ( ColumnSpec("config_json", nullable=False, sensitive=True), ), ), + TableSpec( + "model_providers", + "provider_id", + ( + ColumnSpec("provider_id", nullable=False), + ColumnSpec("display_name", nullable=False), + ColumnSpec("provider_type", nullable=False), + ColumnSpec("base_url", nullable=False), + ColumnSpec("api_key_secret_ref", sensitive=True), + ), + ), + TableSpec( + "model_routes", + "route_id", + ( + ColumnSpec("route_id", nullable=False), + ColumnSpec("route_name", nullable=False), + ColumnSpec("provider_id", nullable=False), + ColumnSpec("model_id", nullable=False), + ColumnSpec("modality", nullable=False), + ), + ), ) diff --git a/database/repositories/model_provider_repository.py b/database/repositories/model_provider_repository.py new file mode 100644 index 0000000..5fa40b9 --- /dev/null +++ b/database/repositories/model_provider_repository.py @@ -0,0 +1,354 @@ +"""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 _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 diff --git a/tests/test_model_provider_service.py b/tests/test_model_provider_service.py new file mode 100644 index 0000000..6d168e5 --- /dev/null +++ b/tests/test_model_provider_service.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from backend.services.model_provider_service import ModelProviderService +from database.db_helper import Database, DatabaseSettings, SqliteSettings +from database.models import table_spec +from database.repositories.model_provider_repository import ModelProviderRepository + + +class ModelProviderServiceTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.database = Database( + DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db"))) + ) + self.database.initialize() + self.service = ModelProviderService(ModelProviderRepository(self.database)) + + def tearDown(self): + self.tmp.cleanup() + + def test_provider_and_route_are_persisted_and_resolved(self): + provider = self.service.upsert_provider( + { + "provider_id": "site_b", + "display_name": "B Site", + "base_url": "https://botcf.com", + "image_endpoint": "/v1/images/generations", + "api_key_env_var": "IMAGESTUDIO_SITE_B_KEY", + "timeout_seconds": 180, + "capabilities": {"image_generation": True}, + } + ) + route = self.service.upsert_route( + { + "route_name": "image_high", + "provider_id": "site_b", + "model_id": "image2", + "priority": 10, + "settings": {"size": "1024x1024"}, + } + ) + + resolved = self.service.resolve_route("image_high", modality="image_generation") + + self.assertEqual(provider["provider_id"], "site_b") + self.assertEqual(route["route_id"], "route_image_high_site_b_image2") + self.assertIsNotNone(resolved) + self.assertEqual(resolved["model_id"], "image2") + self.assertEqual(resolved["provider"]["base_url"], "https://botcf.com") + self.assertEqual(resolved["provider"]["api_key_env_var"], "IMAGESTUDIO_SITE_B_KEY") + + def test_route_resolution_prefers_lower_priority_enabled_provider(self): + self.service.upsert_provider({"provider_id": "slow", "base_url": "https://slow.example"}) + self.service.upsert_provider({"provider_id": "fast", "base_url": "https://fast.example"}) + self.service.upsert_route( + {"route_name": "image_low", "provider_id": "slow", "model_id": "slow-model", "priority": 50} + ) + self.service.upsert_route( + {"route_name": "image_low", "provider_id": "fast", "model_id": "fast-model", "priority": 5} + ) + + resolved = self.service.resolve_route("image_low") + + self.assertEqual(resolved["provider_id"], "fast") + self.assertEqual(resolved["model_id"], "fast-model") + + def test_model_tables_are_registered_as_metadata(self): + self.assertEqual(table_spec("model_providers").primary_key, "provider_id") + self.assertEqual(table_spec("model_routes").primary_key, "route_id") + self.assertEqual(table_spec("model_providers").sensitive_columns(), ["api_key_secret_ref"]) + + +if __name__ == "__main__": + unittest.main()