2026-07-11 21:50:34 +08:00
|
|
|
"""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"))
|
|
|
|
|
default_route = _text(generation.get("default_model"))
|
2026-07-11 22:27:35 +08:00
|
|
|
configured_adapters = generation.get("adapters")
|
|
|
|
|
adapters = [
|
|
|
|
|
_mapping(item)
|
|
|
|
|
for item in configured_adapters
|
|
|
|
|
if isinstance(item, Mapping)
|
|
|
|
|
] if isinstance(configured_adapters, list) else []
|
|
|
|
|
if not adapters:
|
|
|
|
|
legacy_provider = _mapping(generation.get("provider"))
|
|
|
|
|
if legacy_provider:
|
|
|
|
|
adapters = [legacy_provider]
|
|
|
|
|
if not adapters and not default_route:
|
2026-07-11 21:50:34 +08:00
|
|
|
_disable_config_routes(service, "image_generation")
|
|
|
|
|
return {"configured": False, "status": "not_configured"}
|
|
|
|
|
|
2026-07-11 22:27:35 +08:00
|
|
|
ready: list[dict[str, Any]] = []
|
|
|
|
|
errors: list[dict[str, Any]] = []
|
|
|
|
|
active_route_ids: set[str] = set()
|
|
|
|
|
for index, provider in enumerate(adapters):
|
|
|
|
|
provider_id = _text(provider.get("provider_id") or provider.get("id")) or f"imagestudio_adapter_{index + 1}"
|
|
|
|
|
route_name = _text(provider.get("route_name")) or (default_route if index == 0 else provider_id)
|
|
|
|
|
model_id = _text(provider.get("model_id")) or route_name
|
|
|
|
|
base_url = _text(provider.get("base_url"))
|
|
|
|
|
missing = [
|
|
|
|
|
field
|
|
|
|
|
for field, value in (
|
|
|
|
|
("route_name", route_name),
|
|
|
|
|
("model_id", model_id),
|
|
|
|
|
("base_url", base_url),
|
|
|
|
|
)
|
|
|
|
|
if not value
|
|
|
|
|
]
|
|
|
|
|
if missing:
|
|
|
|
|
errors.append({"adapter_id": provider_id, "index": index, "missing_fields": missing})
|
|
|
|
|
continue
|
|
|
|
|
provider_payload: dict[str, Any] = {
|
2026-07-11 21:50:34 +08:00
|
|
|
"provider_id": provider_id,
|
2026-07-11 22:27:35 +08:00
|
|
|
"display_name": _text(provider.get("display_name") or provider.get("name")) or provider_id,
|
|
|
|
|
"provider_type": _text(provider.get("provider_type")) or "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),
|
2026-07-11 21:50:34 +08:00
|
|
|
"enabled": _bool(provider.get("enabled", True)),
|
2026-07-11 22:27:35 +08:00
|
|
|
"metadata": {"source": "config_bootstrap", "adapter_index": index},
|
2026-07-11 21:50:34 +08:00
|
|
|
}
|
2026-07-11 22:27:35 +08:00
|
|
|
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 + index),
|
|
|
|
|
"enabled": _bool(provider.get("enabled", True)),
|
|
|
|
|
"metadata": {
|
|
|
|
|
"source": "config_bootstrap",
|
|
|
|
|
"adapter_index": index,
|
|
|
|
|
"is_default": index == 0 or route_name == default_route,
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
disable_others=False,
|
|
|
|
|
)
|
|
|
|
|
active_route_ids.add(str(route["route_id"]))
|
|
|
|
|
ready.append(
|
|
|
|
|
{
|
|
|
|
|
"provider_id": provider_id,
|
|
|
|
|
"route_name": route["route_name"],
|
|
|
|
|
"model_id": route["model_id"],
|
|
|
|
|
"enabled": bool(route["enabled"]),
|
|
|
|
|
"api_key_source": "env" if api_key_env_var else "secret_ref" if api_key_secret_ref else "none",
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
_disable_config_routes_except(service, "image_generation", active_route_ids)
|
|
|
|
|
if not ready:
|
|
|
|
|
_disable_config_routes(service, "image_generation")
|
|
|
|
|
missing_fields = [
|
|
|
|
|
f"generation.provider.{field}"
|
|
|
|
|
for field in ((errors[0].get("missing_fields") if errors else ["base_url", "model_id"]))
|
|
|
|
|
]
|
|
|
|
|
return {
|
|
|
|
|
"configured": False,
|
|
|
|
|
"status": "incomplete",
|
|
|
|
|
"missing_fields": missing_fields,
|
|
|
|
|
"adapter_errors": errors,
|
|
|
|
|
}
|
|
|
|
|
default = next((item for item in ready if item["route_name"] == default_route), ready[0])
|
2026-07-11 21:50:34 +08:00
|
|
|
return {
|
|
|
|
|
"configured": True,
|
2026-07-11 22:27:35 +08:00
|
|
|
"status": "ready" if not errors else "partial",
|
|
|
|
|
**default,
|
|
|
|
|
"adapter_count": len(ready),
|
|
|
|
|
"adapters": ready,
|
|
|
|
|
"adapter_errors": errors,
|
2026-07-11 21:50:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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",
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2026-07-11 22:27:35 +08:00
|
|
|
def _upsert_config_route(
|
|
|
|
|
service: ModelProviderService,
|
|
|
|
|
payload: dict[str, Any],
|
|
|
|
|
*,
|
|
|
|
|
disable_others: bool = True,
|
|
|
|
|
) -> dict[str, Any]:
|
2026-07-11 21:50:34 +08:00
|
|
|
"""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})
|
2026-07-11 22:27:35 +08:00
|
|
|
if disable_others:
|
|
|
|
|
_disable_config_routes(service, modality, except_route_id=stable_route_id)
|
2026-07-11 21:50:34 +08:00
|
|
|
return route
|
|
|
|
|
|
|
|
|
|
|
2026-07-11 22:27:35 +08:00
|
|
|
def _disable_config_routes_except(
|
|
|
|
|
service: ModelProviderService,
|
|
|
|
|
modality: str,
|
|
|
|
|
active_route_ids: set[str],
|
|
|
|
|
) -> None:
|
|
|
|
|
all_routes = service.list_routes()
|
|
|
|
|
active_by_name = {
|
|
|
|
|
str(route.get("route_name")): str(route.get("route_id"))
|
|
|
|
|
for route in all_routes
|
|
|
|
|
if route.get("route_id") in active_route_ids
|
|
|
|
|
}
|
|
|
|
|
for existing in all_routes:
|
|
|
|
|
metadata = _mapping(existing.get("metadata"))
|
|
|
|
|
if (
|
|
|
|
|
existing.get("route_id") in active_route_ids
|
|
|
|
|
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": active_by_name[str(existing.get("route_name"))]}
|
|
|
|
|
if str(existing.get("route_name")) in active_by_name
|
|
|
|
|
else {"disabled_by": "config"}
|
|
|
|
|
),
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
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)
|