astrbot_plugin_imagestudio/backend/services/model_provider_bootstrap.py

293 行
11 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"))
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)