"""Bootstrap image-generation and material-vision routes from configuration.""" from __future__ import annotations from collections.abc import Mapping import re from typing import Any from backend.services.model_provider_service import ModelProviderService def sync_generation_provider_from_config( service: ModelProviderService, config: Mapping[str, Any], ) -> dict[str, Any]: generation = _mapping(config.get("generation")) provider = _mapping(generation.get("provider")) default_route = _text(generation.get("default_model")) route_name = _text(provider.get("route_name")) or default_route model_id = _text(provider.get("model_id")) or default_route base_url = _text(provider.get("base_url")) if not any((default_route, route_name, model_id, base_url)): _disable_config_routes(service, "image_generation") return {"configured": False, "status": "not_configured"} missing = [ field for field, value in ( ("generation.default_model", route_name), ("generation.provider.model_id", model_id), ("generation.provider.base_url", base_url), ) if not value ] if missing: _disable_config_routes(service, "image_generation") return {"configured": False, "status": "incomplete", "missing_fields": missing} provider_id = _text(provider.get("provider_id")) or "imagestudio_default" provider_payload: dict[str, Any] = { "provider_id": provider_id, "display_name": _text(provider.get("display_name")) or "ImageStudio default provider", "provider_type": "openai_compatible", "base_url": base_url, "image_endpoint": _text(provider.get("image_endpoint")) or "/v1/images/generations", "timeout_seconds": _positive_int(provider.get("timeout_seconds"), 180), "enabled": _bool(provider.get("enabled", True)), "metadata": {"source": "config_bootstrap"}, } api_key_env_var = _text(provider.get("api_key_env_var")) api_key_secret_ref = _text(provider.get("api_key_secret_ref")) if api_key_env_var: provider_payload["api_key_env_var"] = api_key_env_var if api_key_secret_ref: provider_payload["api_key_secret_ref"] = api_key_secret_ref service.upsert_provider(provider_payload) route = _upsert_config_route( service, { "route_name": route_name, "provider_id": provider_id, "model_id": model_id, "modality": "image_generation", "priority": _int(provider.get("priority"), 10), "enabled": _bool(provider.get("enabled", True)), "metadata": {"source": "config_bootstrap"}, } ) return { "configured": True, "status": "ready", "provider_id": provider_id, "route_name": route["route_name"], "model_id": route["model_id"], "api_key_source": "env" if api_key_env_var else "secret_ref" if api_key_secret_ref else "none", } def sync_vision_provider_from_config( service: ModelProviderService, config: Mapping[str, Any], ) -> dict[str, Any]: """Persist the configured material-recognition route. Vision settings may omit provider connection fields. In that case they inherit the generation provider's ID, base URL, key reference, timeout and compatible image endpoint. The vision model remains explicit because an image-generation model is not necessarily multimodal. """ generation = _mapping(config.get("generation")) generation_provider = _mapping(generation.get("provider")) vision = _mapping(config.get("vision")) vision_provider = _mapping(vision.get("provider")) default_route = _text(vision.get("default_route")) route_name = _text(vision_provider.get("route_name")) or default_route model_id = _text(vision_provider.get("model_id")) base_url = _text(vision_provider.get("base_url")) or _text(generation_provider.get("base_url")) vision_endpoint = _text(vision_provider.get("vision_endpoint")) or "/v1/chat/completions" configured_values = ( model_id, _text(vision_provider.get("base_url")), _text(vision_provider.get("provider_id")), _text(vision_provider.get("api_key_env_var")), _text(vision_provider.get("api_key_secret_ref")), ) if not any(configured_values): _disable_config_routes(service, "vision_recognition") return { "configured": False, "status": "not_configured", "route_name": route_name or None, } missing = [ field for field, value in ( ("vision.default_route", route_name), ("vision.provider.model_id", model_id), ("vision.provider.base_url", base_url), ) if not value ] if missing: _disable_config_routes(service, "vision_recognition") return { "configured": False, "status": "incomplete", "route_name": route_name or None, "missing_fields": missing, } generation_provider_id = _text(generation_provider.get("provider_id")) or "imagestudio_default" requested_provider_id = _text(vision_provider.get("provider_id")) generation_api_key_env_var = _text(generation_provider.get("api_key_env_var")) generation_api_key_secret_ref = _text(generation_provider.get("api_key_secret_ref")) api_key_env_var = _text(vision_provider.get("api_key_env_var")) or generation_api_key_env_var api_key_secret_ref = _text(vision_provider.get("api_key_secret_ref")) or generation_api_key_secret_ref generation_timeout = _positive_int(generation_provider.get("timeout_seconds"), 180) vision_timeout = _positive_int( vision_provider.get("timeout_seconds", generation_provider.get("timeout_seconds")), 180, ) connection_differs = any( ( requested_provider_id and requested_provider_id != generation_provider_id, _text(vision_provider.get("base_url")) and _text(vision_provider.get("base_url")) != _text(generation_provider.get("base_url")), _text(vision_provider.get("api_key_env_var")) and api_key_env_var != generation_api_key_env_var, _text(vision_provider.get("api_key_secret_ref")) and api_key_secret_ref != generation_api_key_secret_ref, _text(vision_provider.get("provider_type")) and _text(vision_provider.get("provider_type")) != (_text(generation_provider.get("provider_type")) or "openai_compatible"), _text(vision_provider.get("display_name")) and _text(vision_provider.get("display_name")) != _text(generation_provider.get("display_name")), vision_timeout != generation_timeout, ) ) reuses_generation_provider = not connection_differs provider_id = ( generation_provider_id if reuses_generation_provider else requested_provider_id or f"{generation_provider_id}_vision" ) route_enabled = _bool(vision_provider.get("enabled", True)) provider_enabled = ( _bool(generation_provider.get("enabled", True)) if reuses_generation_provider else route_enabled ) provider_payload: dict[str, Any] = { "provider_id": provider_id, "display_name": ( _text(vision_provider.get("display_name")) or _text(generation_provider.get("display_name")) or "ImageStudio vision provider" ), "provider_type": ( _text(vision_provider.get("provider_type")) or _text(generation_provider.get("provider_type")) or "openai_compatible" ), "base_url": base_url, "image_endpoint": _text(generation_provider.get("image_endpoint")) or "/v1/images/generations", "timeout_seconds": vision_timeout if not reuses_generation_provider else generation_timeout, "enabled": provider_enabled, "metadata": {"source": "config_bootstrap", "vision_enabled": True}, } if api_key_env_var: provider_payload["api_key_env_var"] = api_key_env_var if api_key_secret_ref: provider_payload["api_key_secret_ref"] = api_key_secret_ref service.upsert_provider(provider_payload) route = _upsert_config_route( service, { "route_name": route_name, "provider_id": provider_id, "model_id": model_id, "modality": "vision_recognition", "priority": _int(vision_provider.get("priority"), 10), "enabled": route_enabled, "settings": {"vision_endpoint": vision_endpoint}, "metadata": { "source": "config_bootstrap", "reuses_generation_provider": reuses_generation_provider, }, } ) return { "configured": True, "status": "ready", "provider_id": provider_id, "route_name": route["route_name"], "model_id": route["model_id"], "vision_endpoint": vision_endpoint, "reuses_generation_provider": reuses_generation_provider, "provider_id_auto_derived": bool(not reuses_generation_provider and not requested_provider_id), "api_key_source": "env" if api_key_env_var else "secret_ref" if api_key_secret_ref else "none", } def _upsert_config_route(service: ModelProviderService, payload: dict[str, Any]) -> dict[str, Any]: """Keep a single active config-owned route across provider/model changes.""" route_name = _text(payload.get("route_name")) modality = _text(payload.get("modality")) or "image_generation" stable_route_id = _config_route_id(route_name, modality) route = service.upsert_route({**payload, "route_id": stable_route_id}) _disable_config_routes(service, modality, except_route_id=stable_route_id) return route def _disable_config_routes( service: ModelProviderService, modality: str, *, except_route_id: str | None = None, ) -> None: for existing in service.list_routes(): metadata = _mapping(existing.get("metadata")) if ( existing.get("route_id") == except_route_id or existing.get("modality") != modality or metadata.get("source") != "config_bootstrap" or not existing.get("enabled") ): continue service.upsert_route( { **existing, "enabled": False, "metadata": { **metadata, **({"superseded_by": except_route_id} if except_route_id else {"disabled_by": "config"}), }, } ) def _config_route_id(route_name: str, modality: str) -> str: stem = re.sub(r"[^A-Za-z0-9_]+", "_", f"{modality}_{route_name}").strip("_").lower() return f"route_config_{stem or 'model'}" def _mapping(value: Any) -> dict[str, Any]: return dict(value) if isinstance(value, Mapping) else {} def _text(value: Any) -> str: return str(value or "").strip() def _bool(value: Any) -> bool: if isinstance(value, str): return value.strip().lower() in {"1", "true", "yes", "on", "enabled"} return bool(value) def _int(value: Any, default: int) -> int: try: return int(value) except (TypeError, ValueError): return default def _positive_int(value: Any, default: int) -> int: return max(_int(value, default), 1)