"""Runtime helpers for building provider clients from persisted routes.""" from __future__ import annotations import base64 import json import urllib.request from typing import Any from urllib.parse import urlsplit from backend.services.model_provider_service import ModelProviderService from core.secret_service import SecretStore, resolve_secret_value from core.remote_fetch import read_http_response_limited, validate_http_url from core.image_formats import detect_image_format from core.storage import VfsStorage from database.db_helper import load_config_payload from engines.image_provider import FallbackImageProvider, ImageProvider, ImageProviderConfig, OpenAIImageProvider from engines.vision_provider import OpenAIVisionProvider, VisionProvider, VisionProviderConfig class ModelProviderRuntime: def __init__( self, model_provider_service: ModelProviderService, *, secret_store: SecretStore | None = None, ): self.model_provider_service = model_provider_service self.secret_store = secret_store def image_provider_for_route(self, route_context: dict[str, Any]) -> ImageProvider | None: route_name = str(route_context.get("route_name") or "").strip() if not route_name: return None resolved = self.model_provider_service.resolve_route(route_name, modality="image_generation") if not resolved: return None candidates = [resolved] route_settings = resolved.get("settings") if isinstance(resolved.get("settings"), dict) else {} # A model selected in the UI must only call its own provider. Generic # cross-provider fallback can silently switch models and used to hide # the selected provider's real error. Safety routing is handled by the # generation governance layer instead. fallback_enabled = _configured_bool( route_context.get("allow_provider_fallback"), route_settings.get("allow_provider_fallback"), default=False, ) if fallback_enabled: seen = {str(resolved.get("route_id"))} excluded_routes = {str(item).strip() for item in route_context.get("excluded_fallback_routes", []) if str(item).strip()} if isinstance(route_context.get("excluded_fallback_routes"), list) else set() fallback_routes = sorted( self.model_provider_service.list_routes(enabled=True), key=lambda item: (int(item.get("priority") or 100), str(item.get("route_id") or "")), ) for route in fallback_routes: if str(route.get("route_name") or "") in excluded_routes: continue if route.get("modality") != "image_generation" or str(route.get("route_id")) in seen: continue candidate = self.model_provider_service.resolve_route(str(route.get("route_name")), modality="image_generation") if candidate: candidates.append(candidate); seen.add(str(candidate.get("route_id"))) providers = [provider for candidate in candidates if (provider := self._image_provider_from_resolved(candidate))] if not providers: return None return providers[0] if len(providers) == 1 else FallbackImageProvider(providers) def _image_provider_from_resolved(self, resolved: dict[str, Any]) -> ImageProvider | None: provider = resolved.get("provider") or {} if str(provider.get("provider_type") or "openai_compatible") != "openai_compatible": return None secret = resolve_secret_value( env_var=provider.get("api_key_env_var"), secret_ref=provider.get("api_key_secret_ref"), plaintext=_saved_provider_api_key(str(resolved.get("provider_id") or "")), secret_store=self.secret_store, ) secret_configured = bool(provider.get("api_key_env_var") or provider.get("api_key_secret_ref")) if secret_configured and not secret.value: return None settings = dict(resolved.get("settings") or {}) capabilities = dict(provider.get("capabilities") or {}) base_url = str(provider.get("base_url") or "") return OpenAIImageProvider( ImageProviderConfig( provider_id=str(resolved["provider_id"]), base_url=base_url, api_key=secret.value or "", image_model=str(resolved["model_id"]), image_endpoint=str(provider.get("image_endpoint") or "/v1/images/generations"), provider_type=str(provider.get("provider_type") or "openai_compatible"), timeout_seconds=int(provider.get("timeout_seconds") or 180), extra_headers=dict(provider.get("extra_headers") or {}), supports_negative_prompt=_configured_bool( settings.get("supports_negative_prompt"), capabilities.get("supports_negative_prompt"), capabilities.get("negative_prompt"), default=_default_negative_prompt_support(base_url), ), ) ) def vision_provider_for_route(self, route_context: dict[str, Any]) -> VisionProvider | None: route_name = str(route_context.get("route_name") or "").strip() if not route_name: return None if route_name.startswith("astrbot:"): # AstrBot owns this provider's credentials and runtime client. Do # not mirror those secrets into ImageStudio's provider tables. from core.astrbot_provider_bridge import astrbot_vision_provider return astrbot_vision_provider(route_name) resolved = self.model_provider_service.resolve_route(route_name, modality="vision_recognition") if not resolved: return None provider = resolved.get("provider") or {} if str(provider.get("provider_type") or "openai_compatible") != "openai_compatible": return None secret = resolve_secret_value( env_var=provider.get("api_key_env_var"), secret_ref=provider.get("api_key_secret_ref"), plaintext=_saved_provider_api_key(str(resolved.get("provider_id") or "")), secret_store=self.secret_store, ) secret_configured = bool(provider.get("api_key_env_var") or provider.get("api_key_secret_ref")) if secret_configured and not secret.value: return None base_url = str(provider.get("base_url") or "").strip() if not base_url: return None settings = dict(resolved.get("settings") or {}) capabilities = dict(provider.get("capabilities") or {}) return OpenAIVisionProvider( VisionProviderConfig( provider_id=str(resolved["provider_id"]), base_url=base_url, api_key=secret.value or "", vision_model=str(resolved["model_id"]), vision_endpoint=str( settings.get("vision_endpoint") or capabilities.get("vision_endpoint") or "/v1/chat/completions" ), provider_type=str(provider.get("provider_type") or "openai_compatible"), timeout_seconds=int(provider.get("timeout_seconds") or 180), extra_headers=dict(provider.get("extra_headers") or {}), ) ) def structured_text_callable(self, route_name: str): """Return an OpenAI-compatible JSON completion callable for a configured route.""" resolved = self.model_provider_service.resolve_route(route_name) if not resolved: return None provider = resolved.get("provider") or {} if str(provider.get("provider_type") or "openai_compatible") != "openai_compatible": return None secret = resolve_secret_value( env_var=provider.get("api_key_env_var"), secret_ref=provider.get("api_key_secret_ref"), plaintext=_saved_provider_api_key(str(resolved.get("provider_id") or "")), secret_store=self.secret_store, ) if (provider.get("api_key_env_var") or provider.get("api_key_secret_ref")) and not secret.value: return None base_url = str(provider.get("base_url") or "").rstrip("/") if not base_url: return None settings = dict(resolved.get("settings") or {}) capabilities = dict(provider.get("capabilities") or {}) endpoint = str(settings.get("chat_endpoint") or capabilities.get("chat_endpoint") or "/v1/chat/completions") url = f"{base_url}{endpoint if endpoint.startswith('/') else '/' + endpoint}" validate_http_url(url, allow_private=True) headers = { "Content-Type": "application/json", **({"Authorization": f"Bearer {secret.value}"} if secret.value else {}), **dict(provider.get("extra_headers") or {}), } timeout = int(provider.get("timeout_seconds") or 180) model = str(resolved.get("model_id") or "") def complete(request_payload: dict[str, Any]) -> dict[str, Any]: purpose = str(request_payload.get("purpose") or "structured prompt processing") body = { "model": model, "messages": [ {"role": "system", "content": f"Perform {purpose}. Return one JSON object only. Preserve safety-relevant meaning and do not invent facts."}, {"role": "user", "content": json.dumps(request_payload, ensure_ascii=False)}, ], "temperature": 0.1, "response_format": {"type": "json_object"}, } raw = read_http_response_limited( urllib.request.Request(url, data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers=headers, method="POST"), timeout_seconds=timeout, max_bytes=4 * 1024 * 1024, allow_private=True, same_origin_redirects_only=True, ).decode("utf-8-sig") response = json.loads(raw) content = _completion_content(response) parsed = json.loads(content) if not isinstance(parsed, dict): raise ValueError("structured completion must return an object") return parsed return complete def structured_vision_callable(self, route_name: str, *, storage: VfsStorage | None = None): resolved = self.model_provider_service.resolve_route(route_name) if not resolved: return None provider = resolved.get("provider") or {} secret = resolve_secret_value( env_var=provider.get("api_key_env_var"), secret_ref=provider.get("api_key_secret_ref"), plaintext=_saved_provider_api_key(str(resolved.get("provider_id") or "")), secret_store=self.secret_store, ) if (provider.get("api_key_env_var") or provider.get("api_key_secret_ref")) and not secret.value: return None base_url = str(provider.get("base_url") or "").rstrip("/") if not base_url: return None settings = dict(resolved.get("settings") or {}) capabilities = dict(provider.get("capabilities") or {}) endpoint = str(settings.get("vision_endpoint") or capabilities.get("vision_endpoint") or settings.get("chat_endpoint") or "/v1/chat/completions") url = f"{base_url}{endpoint if endpoint.startswith('/') else '/' + endpoint}" validate_http_url(url, allow_private=True) headers = {"Content-Type": "application/json", **({"Authorization": f"Bearer {secret.value}"} if secret.value else {}), **dict(provider.get("extra_headers") or {})} timeout = int(provider.get("timeout_seconds") or 180) model = str(resolved.get("model_id") or "") vfs = storage or VfsStorage() def review(request_payload: dict[str, Any]) -> dict[str, Any]: image = request_payload.get("image") if isinstance(request_payload.get("image"), dict) else {} uri = str(image.get("image_uri") or image.get("thumbnail_uri") or "").strip() if uri.startswith("storage://"): path = vfs.ensure_file(uri) body = path.read_bytes() if len(body) > 25 * 1024 * 1024: raise ValueError("image moderation input exceeds size limit") image_format = detect_image_format(body) if image_format is None: raise ValueError("image moderation input is not a supported image") uri = f"data:{image_format.mime_type};base64,{base64.b64encode(body).decode('ascii')}" if not uri.startswith(("data:image/", "http://", "https://")): raise ValueError("image moderation requires a storage, data, or HTTP image URI") instruction = { "requested_level": request_payload.get("requested_level"), "route_kind": request_payload.get("route_kind"), "reference_binding_mapping": (image.get("metadata") or {}).get("reference_binding_mapping") if isinstance(image.get("metadata"), dict) else {}, "actions": ["allow", "warn", "quarantine", "regenerate", "reject"], "requirements": ["detect age ambiguity", "detect unexpected nudity", "detect terrorism or high-risk violence", "detect content beyond the allowed request", "when material IDs are available, return material_restoration_scores from 0 to 1"], } payload = { "model": model, "messages": [ {"role": "system", "content": "Review the generated image for content safety. Return JSON with action, categories, confidence, reason_codes, and version. Terrorism, high-risk violence, sexual minors, and extreme gore must be reject or quarantine."}, {"role": "user", "content": [{"type": "text", "text": json.dumps(instruction, ensure_ascii=False)}, {"type": "image_url", "image_url": {"url": uri}}]}, ], "temperature": 0.0, "response_format": {"type": "json_object"}, } raw = read_http_response_limited(urllib.request.Request(url, data=json.dumps(payload, ensure_ascii=False).encode("utf-8"), headers=headers, method="POST"), timeout_seconds=timeout, max_bytes=4 * 1024 * 1024, allow_private=True, same_origin_redirects_only=True).decode("utf-8-sig") parsed = json.loads(_completion_content(json.loads(raw))) if not isinstance(parsed, dict): raise ValueError("image moderation response must be an object") return parsed return review def _saved_provider_api_key(provider_id: str) -> str | None: """Read the UI-saved adapter credential without copying it into the DB.""" if not provider_id: return None config = load_config_payload() generation = config.get("generation") if isinstance(config.get("generation"), dict) else {} adapters = generation.get("adapters") if isinstance(generation.get("adapters"), list) else [] candidates = adapters if not candidates and isinstance(generation.get("provider"), dict): candidates = [generation["provider"]] for candidate in candidates: if not isinstance(candidate, dict): continue candidate_id = str(candidate.get("id") or candidate.get("provider_id") or "").strip() if candidate_id != provider_id: continue value = str(candidate.get("api_key_plaintext") or "").strip() if value and value != "***MASKED***": return value return None def _configured_bool(*values: Any, default: bool) -> bool: for value in values: if value is None: continue if isinstance(value, str): normalized = value.strip().lower() if normalized in {"1", "true", "yes", "on", "enabled"}: return True if normalized in {"0", "false", "no", "off", "disabled"}: return False return bool(value) return default def _default_negative_prompt_support(base_url: str) -> bool: try: hostname = str(urlsplit(base_url).hostname or "").lower() except ValueError: return True return not (hostname == "api.openai.com" or hostname.endswith(".openai.azure.com")) def _completion_content(response: dict[str, Any]) -> str: if isinstance(response.get("output_text"), str): return response["output_text"].strip() choices = response.get("choices") if isinstance(choices, list) and choices and isinstance(choices[0], dict): message = choices[0].get("message") if isinstance(choices[0].get("message"), dict) else {} content = message.get("content") if isinstance(content, str): return content.strip() if isinstance(content, list): return " ".join(str(item.get("text") or "") for item in content if isinstance(item, dict)).strip() raise ValueError("structured completion response has no text content")