astrbot_plugin_imagestudio/backend/services/model_provider_bootstrap.py

376 行
14 KiB
Python

"""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"))
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:
_disable_config_routes(service, "image_generation")
return {"configured": False, "status": "not_configured"}
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] = {
"provider_id": provider_id,
"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),
"enabled": _bool(provider.get("enabled", True)),
"metadata": {"source": "config_bootstrap", "adapter_index": index},
}
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])
return {
"configured": True,
"status": "ready" if not errors else "partial",
**default,
"adapter_count": len(ready),
"adapters": ready,
"adapter_errors": errors,
}
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],
*,
disable_others: bool = True,
) -> 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})
if disable_others:
_disable_config_routes(service, modality, except_route_id=stable_route_id)
return route
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"}
),
},
}
)
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)