2580 行
116 KiB
Python
2580 行
116 KiB
Python
"""AstrBot ImageStudio plugin entrypoint helpers.
|
||
|
||
The plugin is mounted inside AstrBot. This module exposes pure metadata and
|
||
dispatch helpers for the runtime layer without starting a standalone server.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import base64
|
||
import binascii
|
||
import inspect
|
||
import importlib
|
||
import json
|
||
import re
|
||
import sys
|
||
from uuid import uuid4
|
||
from pathlib import Path
|
||
from typing import Any, Callable, Mapping
|
||
|
||
|
||
PLUGIN_ROOT = Path(__file__).resolve().parent
|
||
if str(PLUGIN_ROOT) not in sys.path:
|
||
# AstrBot may import the plugin entrypoint without adding the plugin root.
|
||
sys.path.insert(0, str(PLUGIN_ROOT))
|
||
|
||
|
||
def _prepend_plugin_package_path(package_name: str) -> None:
|
||
"""Let absolute legacy imports resolve inside the plugin package.
|
||
|
||
AstrBot itself may already have imported a top-level package named
|
||
``core``. In that case, merely adding the plugin root to ``sys.path`` is
|
||
insufficient because Python reuses the existing package from
|
||
``sys.modules``. Prepending our package directory to that package's
|
||
search path keeps the host package intact while allowing imports such as
|
||
``core.config_service`` to resolve to ImageStudio's implementation.
|
||
"""
|
||
|
||
package_dir = PLUGIN_ROOT / package_name
|
||
loaded_package = sys.modules.get(package_name)
|
||
search_path = getattr(loaded_package, "__path__", None)
|
||
if search_path is None or not package_dir.is_dir():
|
||
return
|
||
package_path = str(package_dir)
|
||
if package_path in search_path:
|
||
search_path.remove(package_path)
|
||
search_path.insert(0, package_path)
|
||
|
||
|
||
for _package_name in ("core", "adapters", "backend", "database", "engines"):
|
||
_prepend_plugin_package_path(_package_name)
|
||
|
||
from adapters.astrbot_adapter import (
|
||
dispatch_extension_request,
|
||
normalize_extension_path,
|
||
register_astrbot_runtime,
|
||
runtime_health,
|
||
runtime_registration_manifest,
|
||
runtime_route_table,
|
||
)
|
||
from adapters.astrbot_command_adapter import (
|
||
accepted_text,
|
||
access_denied_text,
|
||
command_allowed,
|
||
command_context_from_event,
|
||
help_text,
|
||
message_text_from_event,
|
||
)
|
||
from adapters.astrbot_card_renderer import render_help_card, render_profile_card, render_status_card
|
||
from adapters.astrbot_command_parser import parse_single_image_command, single_image_usage
|
||
from adapters.astrbot_media_adapter import image_references_from_event
|
||
from backend.dto.chat_command_dto import ChatCommandParseError
|
||
from backend.services.chat_workflow_service import ChatWorkflowService
|
||
from backend.services.chat_session_service import ChatSessionStore
|
||
from adapters.webui_adapter import get_web_mount_manifest
|
||
from backend.route_registry import ROUTES
|
||
from backend.services.model_provider_bootstrap import (
|
||
sync_generation_provider_from_config,
|
||
sync_vision_provider_from_config,
|
||
)
|
||
from backend.services.model_provider_service import ModelProviderService
|
||
from backend.services.ui_service import API_BASE
|
||
from core.config_service import PLUGIN_VERSION
|
||
from core.astrbot_provider_bridge import configure_astrbot_provider_bridge
|
||
from core.identity import RequestContext
|
||
from core.media_proxy import MediaProxy
|
||
from database import db_helper as _database_db_helper
|
||
from database.repositories.model_provider_repository import ModelProviderRepository
|
||
from database.seed import seed_default_material_categories
|
||
|
||
try:
|
||
if not hasattr(_database_db_helper, "set_runtime_config_overrides"):
|
||
_database_db_helper = importlib.reload(_database_db_helper)
|
||
except Exception:
|
||
pass
|
||
|
||
Database = _database_db_helper.Database
|
||
DatabaseSettings = _database_db_helper.DatabaseSettings
|
||
load_database_settings = _database_db_helper.load_database_settings
|
||
|
||
|
||
PLUGIN_NAME = "astrbot_plugin_imagestudio"
|
||
PLUGIN_DESC = "AstrBot ImageStudio role asset production and image-generation workspace."
|
||
BRIDGE_PERMISSIONS = frozenset(
|
||
{"can_write", "can_manage_config", "can_manage_materials", "can_retry_tasks"}
|
||
)
|
||
_MISSING = object()
|
||
_RUNTIME_PATH_TO_ASTRBOT_KEY = {
|
||
"plugin.display_name": "display_name",
|
||
"generation.default_model": "default_generation_model",
|
||
"generation.provider.provider_id": "generation_provider_id",
|
||
"generation.provider.base_url": "generation_provider_base_url",
|
||
"generation.provider.image_endpoint": "generation_provider_image_endpoint",
|
||
"generation.provider.model_id": "generation_provider_model",
|
||
"generation.provider.route_name": "generation_provider_route",
|
||
"generation.provider.api_key_env_var": "generation_provider_api_key_env_var",
|
||
"generation.provider.timeout_seconds": "generation_provider_timeout_seconds",
|
||
"vision.default_route": "vision_provider_route",
|
||
"vision.provider.provider_id": "vision_provider_id",
|
||
"vision.provider.base_url": "vision_provider_base_url",
|
||
"vision.provider.vision_endpoint": "vision_provider_endpoint",
|
||
"vision.provider.model_id": "vision_provider_model",
|
||
"vision.provider.route_name": "vision_provider_route",
|
||
"vision.provider.api_key_env_var": "vision_provider_api_key_env_var",
|
||
"vision.provider.timeout_seconds": "vision_provider_timeout_seconds",
|
||
"vision.provider.enabled": "vision_provider_enabled",
|
||
"model_assignments.material_recognition": "model_material_recognition",
|
||
"model_assignments.advanced_material_recognition": "model_advanced_material_recognition",
|
||
"model_assignments.advanced_style_consensus": "model_advanced_style_consensus",
|
||
"model_assignments.advanced_material_validation_generation": "model_advanced_material_validation_generation",
|
||
"advanced_materials.cost_budget.enabled": "advanced_material_budget_enabled",
|
||
"advanced_materials.cost_budget.days": "advanced_material_budget_days",
|
||
"advanced_materials.cost_budget.max_task_count": "advanced_material_budget_max_task_count",
|
||
"advanced_materials.cost_budget.max_image_count": "advanced_material_budget_max_image_count",
|
||
"advanced_materials.cost_budget.max_estimated_cost": "advanced_material_budget_max_estimated_cost",
|
||
"advanced_materials.cost_budget.price_key": "advanced_material_budget_price_key",
|
||
"advanced_materials.cost_budget.per_request": "advanced_material_budget_per_request",
|
||
"advanced_materials.cost_budget.per_image": "advanced_material_budget_per_image",
|
||
"advanced_materials.cost_budget.per_1k_tokens": "advanced_material_budget_per_1k_tokens",
|
||
"model_assignments.profile_parse": "model_profile_parse",
|
||
"model_assignments.persona_split": "model_persona_split",
|
||
"model_assignments.prompt_planning": "model_prompt_planning",
|
||
"model_assignments.visual_review_routes": "model_visual_review_routes",
|
||
"model_assignments.cross_review_primary": "model_cross_review_primary",
|
||
"model_assignments.cross_review_secondary": "model_cross_review_secondary",
|
||
"model_assignments.cross_review_routes": "model_cross_review_routes",
|
||
"model_assignments.generation_cross_review_primary": "model_generation_cross_review_primary",
|
||
"model_assignments.generation_cross_review_secondary": "model_generation_cross_review_secondary",
|
||
"model_assignments.generation_cross_review_routes": "model_generation_cross_review_routes",
|
||
"model_assignments.quick_generation": "model_quick_generation",
|
||
"model_assignments.portrait_generation": "model_portrait_generation",
|
||
"model_assignments.halfbody_generation": "model_halfbody_generation",
|
||
"model_assignments.fullbody_generation": "model_fullbody_generation",
|
||
"model_assignments.sheet_generation": "model_sheet_generation",
|
||
"model_assignments.hires_fix": "model_hires_fix",
|
||
"chat_access.group_allowlist": "chat_group_allowlist",
|
||
"chat_access.user_allowlist": "chat_user_allowlist",
|
||
"chat_access.user_concurrency_limit": "chat_user_concurrency_limit",
|
||
"chat_access.group_concurrency_limit": "chat_group_concurrency_limit",
|
||
"chat_access.daily_user_generation_limit": "chat_daily_user_generation_limit",
|
||
"chat_access.daily_group_generation_limit": "chat_daily_group_generation_limit",
|
||
"chat_access.allow_2k": "chat_allow_2k",
|
||
"chat_access.allow_4k": "chat_allow_4k",
|
||
"features.private_companion_integration": "enable_private_companion_integration",
|
||
"storage.advanced_materials_path": "advanced_materials_path",
|
||
"database.backend": "database_backend",
|
||
"database.sqlite.path": "sqlite_path",
|
||
"database.postgresql.enabled": "postgresql_enabled",
|
||
"database.postgresql.dsn": "postgresql_dsn",
|
||
"database.postgresql.host": "postgresql_host",
|
||
"database.postgresql.port": "postgresql_port",
|
||
"database.postgresql.database": "postgresql_database",
|
||
"database.postgresql.user": "postgresql_user",
|
||
"database.postgresql.password": "postgresql_password",
|
||
}
|
||
|
||
try:
|
||
from astrbot.api.star import Star as AstrBotStar
|
||
from astrbot.api.star import register as astrbot_star_register
|
||
from astrbot.api.event import AstrMessageEvent, filter as astrbot_filter
|
||
from astrbot.api.event import MessageChain as AstrBotMessageChain
|
||
from astrbot.api.message_components import Image as AstrBotImage
|
||
from astrbot.api.message_components import Plain as AstrBotPlain
|
||
except Exception: # pragma: no cover - AstrBot is only present in runtime.
|
||
class AstrBotStar: # type: ignore[no-redef]
|
||
def __init__(self, context: Any | None = None, *args: Any, **kwargs: Any) -> None:
|
||
self.context = context
|
||
|
||
def astrbot_star_register(*args: Any, **kwargs: Any) -> Any:
|
||
def decorator(cls: type[Any]) -> type[Any]:
|
||
return cls
|
||
|
||
return decorator
|
||
|
||
AstrMessageEvent = Any # type: ignore[misc,assignment]
|
||
AstrBotImage = None # type: ignore[assignment]
|
||
AstrBotPlain = None # type: ignore[assignment]
|
||
AstrBotMessageChain = None # type: ignore[assignment]
|
||
|
||
class _FallbackCommandGroup:
|
||
def __call__(self, function: Callable[..., Any]) -> Callable[..., Any]:
|
||
setattr(function, "command", self.command)
|
||
return function
|
||
|
||
def command(self, *args: Any, **kwargs: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
|
||
return lambda function: function
|
||
|
||
class _FallbackFilter:
|
||
class EventMessageType:
|
||
ALL = "all"
|
||
|
||
@staticmethod
|
||
def command_group(*args: Any, **kwargs: Any) -> _FallbackCommandGroup:
|
||
return _FallbackCommandGroup()
|
||
|
||
@staticmethod
|
||
def event_message_type(*args: Any, **kwargs: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
|
||
return lambda function: function
|
||
|
||
astrbot_filter = _FallbackFilter()
|
||
|
||
|
||
def get_plugin_manifest() -> dict[str, Any]:
|
||
web_manifest = get_web_mount_manifest()
|
||
runtime = runtime_registration_manifest()
|
||
return {
|
||
"plugin_name": PLUGIN_NAME,
|
||
"api_base": API_BASE,
|
||
"contract_url": f"{API_BASE}/contract",
|
||
"web": web_manifest,
|
||
"routes": runtime_route_table(),
|
||
"runtime": runtime,
|
||
"health": runtime["health"],
|
||
}
|
||
|
||
|
||
def register_plugin(runtime: Any) -> dict[str, Any]:
|
||
result = register_astrbot_runtime(runtime, runtime_registration_manifest())
|
||
result["bridge_api"] = register_bridge_api(runtime)
|
||
return result
|
||
|
||
|
||
def get_runtime_health() -> dict[str, Any]:
|
||
return runtime_health()
|
||
|
||
|
||
def initialize_runtime_database(settings: DatabaseSettings | None = None) -> dict[str, Any]:
|
||
database = Database(settings or load_database_settings())
|
||
database.initialize()
|
||
seed = seed_default_material_categories(database)
|
||
model_provider_service = ModelProviderService(ModelProviderRepository(database))
|
||
config_payload = _database_db_helper.load_config_payload()
|
||
generation_provider = sync_generation_provider_from_config(model_provider_service, config_payload)
|
||
vision_provider = sync_vision_provider_from_config(model_provider_service, config_payload)
|
||
return {
|
||
"initialized": True,
|
||
"backend": database.backend,
|
||
"seed": {"material_categories": seed},
|
||
"generation_provider": generation_provider,
|
||
"vision_provider": vision_provider,
|
||
}
|
||
|
||
|
||
def apply_astrbot_config_overrides(config: Any | None) -> dict[str, Any]:
|
||
mapping = _mapping_from_runtime_config(config)
|
||
patch = _runtime_config_patch_from_mapping(mapping)
|
||
_set_runtime_config_overrides(patch)
|
||
_set_runtime_config_persister(config)
|
||
return {"applied": bool(patch), "keys": _flatten_config_keys(patch)}
|
||
|
||
|
||
def dispatch_web_request(
|
||
ctx: RequestContext,
|
||
method: str,
|
||
path: str,
|
||
*,
|
||
query: dict[str, Any] | None = None,
|
||
payload: dict[str, Any] | None = None,
|
||
) -> dict[str, Any]:
|
||
return dispatch_extension_request(ctx, method, path, query=query, payload=payload)
|
||
|
||
|
||
def register_bridge_api(runtime: Any) -> dict[str, Any]:
|
||
"""Register AstrBot Plugin Page bridge endpoints under /api/plug/{plugin}."""
|
||
|
||
registrar = getattr(runtime, "register_web_api", None)
|
||
if not callable(registrar):
|
||
return {"registered": False, "routes_registered": 0, "missing_capabilities": ["register_web_api"]}
|
||
|
||
registered = 0
|
||
errors: list[dict[str, Any]] = []
|
||
for route in _bridge_registration_routes():
|
||
handler = _make_bridge_handler(endpoint=route["endpoint"], method=route["method"])
|
||
try:
|
||
if _call_web_api_registrar(registrar, route["path"], handler, route["method"]):
|
||
registered += 1
|
||
except Exception as exc: # pragma: no cover - depends on AstrBot runtime version.
|
||
errors.append(
|
||
{
|
||
"method": route["method"],
|
||
"path": route["path"],
|
||
"message": str(exc),
|
||
"exception": exc.__class__.__name__,
|
||
}
|
||
)
|
||
|
||
return {
|
||
"registered": registered > 0,
|
||
"routes_registered": registered,
|
||
"missing_capabilities": [],
|
||
"errors": errors,
|
||
}
|
||
|
||
|
||
async def dispatch_bridge_request(
|
||
endpoint: str,
|
||
*,
|
||
method: str = "GET",
|
||
request: Any | None = None,
|
||
query: dict[str, Any] | None = None,
|
||
payload: dict[str, Any] | None = None,
|
||
) -> Any:
|
||
ctx = _request_context_from_astrbot_request(request)
|
||
request_method = _request_method(request, fallback=method)
|
||
request_payload = payload if payload is not None else await _request_payload(request)
|
||
dispatch_method, dispatch_payload = _unwrap_method_override(request_method, request_payload)
|
||
dispatch_endpoint = _bridge_endpoint(endpoint, request)
|
||
dispatch_query = query if query is not None else _request_query(request)
|
||
if dispatch_method == "GET" and normalize_extension_path(dispatch_endpoint) == "media/fetch":
|
||
file_response = await _to_media_file_response(dispatch_query)
|
||
if file_response is not None:
|
||
return file_response
|
||
response = await asyncio.to_thread(
|
||
dispatch_web_request,
|
||
ctx,
|
||
dispatch_method,
|
||
dispatch_endpoint,
|
||
query=dispatch_query,
|
||
payload=dispatch_payload,
|
||
)
|
||
media_response = _to_media_http_response(dispatch_endpoint, response)
|
||
if media_response is not None:
|
||
return media_response
|
||
return _to_bridge_response(response)
|
||
|
||
|
||
def _register_star_class(cls: type[Any]) -> type[Any]:
|
||
try:
|
||
return astrbot_star_register(PLUGIN_NAME, "YokiiroBW", PLUGIN_DESC, PLUGIN_VERSION)(cls)
|
||
except Exception:
|
||
return cls
|
||
|
||
|
||
@_register_star_class
|
||
class Main(AstrBotStar):
|
||
"""Minimal AstrBot plugin class for runtime discovery."""
|
||
|
||
def __init__(self, context: Any | None = None, *args: Any, **kwargs: Any) -> None:
|
||
runtime_config = _runtime_config_argument(args, kwargs)
|
||
try:
|
||
super().__init__(context, *args, **kwargs)
|
||
except TypeError:
|
||
try:
|
||
super().__init__(*args, **kwargs)
|
||
except TypeError:
|
||
super().__init__()
|
||
self.context = context
|
||
self.astrbot_config = runtime_config if runtime_config is not None else _attr(self, "config")
|
||
self.registration_result: dict[str, Any] | None = None
|
||
self.database_result: dict[str, Any] | None = None
|
||
self.runtime_config_result: dict[str, Any] | None = None
|
||
self.chat_workflow_service = ChatWorkflowService(dispatch_web_request)
|
||
self.chat_sessions = ChatSessionStore(ttl_seconds=600, max_sessions=1000)
|
||
self.chat_background_tasks: set[asyncio.Task[Any]] = set()
|
||
self.round_worker_runtime: Any | None = None
|
||
self.round_worker_result: dict[str, Any] | None = None
|
||
self.advanced_material_worker_runtime: Any | None = None
|
||
self.advanced_material_worker_result: dict[str, Any] | None = None
|
||
self.runtime_loop: asyncio.AbstractEventLoop | None = None
|
||
|
||
async def initialize(self) -> None:
|
||
self.runtime_loop = asyncio.get_running_loop()
|
||
configure_astrbot_provider_bridge(self.context, self.runtime_loop)
|
||
self.runtime_config_result = apply_astrbot_config_overrides(self.astrbot_config)
|
||
# Database migrations must complete before AstrBot registers or inspects
|
||
# any route handlers. Registration is not guaranteed to be passive on
|
||
# every supported AstrBot version.
|
||
self.database_result = initialize_runtime_database()
|
||
try:
|
||
from backend.services.workflow_round_worker_runtime import (
|
||
create_workflow_round_worker_runtime,
|
||
)
|
||
|
||
self.round_worker_runtime = create_workflow_round_worker_runtime(
|
||
terminal_notification_callback=self._schedule_round_terminal_notification,
|
||
)
|
||
self.round_worker_result = self.round_worker_runtime.start()
|
||
replay_task = asyncio.create_task(self._replay_round_terminal_notifications())
|
||
self.chat_background_tasks.add(replay_task)
|
||
replay_task.add_done_callback(self.chat_background_tasks.discard)
|
||
except Exception as exc:
|
||
# Keep the plugin and its recovery UI available even when a worker
|
||
# cannot start. The persisted queue remains intact for the next
|
||
# reload, and status diagnostics can expose the startup reason.
|
||
self.round_worker_runtime = None
|
||
self.round_worker_result = {
|
||
"running": False,
|
||
"error_type": type(exc).__name__,
|
||
"message": " ".join(str(exc).split())[:500],
|
||
}
|
||
try:
|
||
from backend.services.advanced_material_worker_runtime import (
|
||
create_advanced_material_worker_runtime,
|
||
)
|
||
|
||
self.advanced_material_worker_runtime = create_advanced_material_worker_runtime()
|
||
self.advanced_material_worker_result = self.advanced_material_worker_runtime.start()
|
||
except Exception as exc:
|
||
# Keep the normal material library and recovery UI usable when the
|
||
# optional advanced-material worker cannot start. Its persisted
|
||
# imports/tasks remain available for retry after configuration is
|
||
# corrected or the plugin is reloaded.
|
||
self.advanced_material_worker_runtime = None
|
||
self.advanced_material_worker_result = {
|
||
"running": False,
|
||
"error_type": type(exc).__name__,
|
||
"message": " ".join(str(exc).split())[:500],
|
||
}
|
||
if self.context is not None:
|
||
self.registration_result = register_plugin(self.context)
|
||
return None
|
||
|
||
async def terminate(self) -> None:
|
||
if self.advanced_material_worker_runtime is not None:
|
||
self.advanced_material_worker_result = self.advanced_material_worker_runtime.stop()
|
||
self.advanced_material_worker_runtime = None
|
||
if self.round_worker_runtime is not None:
|
||
self.round_worker_result = self.round_worker_runtime.stop()
|
||
self.round_worker_runtime = None
|
||
configure_astrbot_provider_bridge(None, None)
|
||
self.runtime_loop = None
|
||
_set_runtime_config_persister(None)
|
||
for task in list(self.chat_background_tasks):
|
||
task.cancel()
|
||
if self.chat_background_tasks:
|
||
await asyncio.gather(*self.chat_background_tasks, return_exceptions=True)
|
||
return None
|
||
|
||
@astrbot_filter.command_group("影棚")
|
||
def imagestudio_command(self) -> None:
|
||
"""ImageStudio chat command group."""
|
||
return None
|
||
|
||
@imagestudio_command.command("帮助")
|
||
async def imagestudio_help(self, event: AstrMessageEvent):
|
||
yield self._card_result(event, self._help_card, help_text())
|
||
|
||
@imagestudio_command.command("状态")
|
||
async def imagestudio_status(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
health = get_runtime_health()
|
||
state = "正常" if health.get("healthy") is not False else "异常"
|
||
database = "已初始化" if self.database_result else "等待初始化"
|
||
details: list[str] = []
|
||
workflow_summary: dict[str, Any] = {}
|
||
try:
|
||
workflow_summary = await asyncio.to_thread(
|
||
self.chat_workflow_service.chat_status,
|
||
command_context_from_event(event),
|
||
workflow_id.strip(),
|
||
)
|
||
except Exception:
|
||
workflow_summary = {}
|
||
workflow = workflow_summary.get("workflow") if isinstance(workflow_summary.get("workflow"), dict) else None
|
||
current = workflow_summary.get("current_node") if isinstance(workflow_summary.get("current_node"), dict) else None
|
||
current_round = workflow_summary.get("current_round") if isinstance(workflow_summary.get("current_round"), dict) else None
|
||
round_record = current_round.get("round") if isinstance(current_round, dict) and isinstance(current_round.get("round"), dict) else None
|
||
if workflow:
|
||
details.extend(
|
||
[
|
||
f"分支 {workflow_summary.get('branch_name') or 'main'}",
|
||
f"节点 {(current or {}).get('title') or (current or {}).get('node_key') or '已完成'}",
|
||
f"轮次 {(round_record or {}).get('display_code') or '暂无'}",
|
||
f"下一动作 {workflow_summary.get('next_action') or '查看工作流'}",
|
||
]
|
||
)
|
||
else:
|
||
details.append("下一动作 使用 /yp 工作流 <角色名>")
|
||
text = (
|
||
f"🛰 ImageStudio 状态:{state}\n版本:{PLUGIN_VERSION}\nAPI:{API_BASE}\n数据库:{database}"
|
||
+ ("\n" + "\n".join(details) if details else "")
|
||
)
|
||
yield self._card_result(
|
||
event,
|
||
lambda: render_status_card(
|
||
state=state,
|
||
version=PLUGIN_VERSION,
|
||
database=database,
|
||
api=API_BASE,
|
||
details=details,
|
||
),
|
||
text,
|
||
)
|
||
|
||
@imagestudio_command.command("快速角色")
|
||
async def imagestudio_quick_profile(self, event: AstrMessageEvent, description: str = ""):
|
||
context = command_context_from_event(event)
|
||
config = _database_db_helper.load_config_payload()
|
||
if not command_allowed(config, "quick_profile", context):
|
||
self._record_chat_denied(context, "quick_profile")
|
||
yield event.plain_result(access_denied_text("快速角色", context))
|
||
return
|
||
try:
|
||
draft = await asyncio.to_thread(self.chat_workflow_service.create_quick_profile_draft, description, context)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 快速角色草稿创建失败:{exc}")
|
||
return
|
||
self.chat_sessions.put(self._session_key(context), "confirm_quick_profile", {"draft": draft})
|
||
preview = draft.get("profile_preview", {})
|
||
text = (
|
||
f"🧩 快速角色草稿\n\n名称:{preview.get('name')}\n基础:{preview.get('base_prompt') or '—'}\n"
|
||
f"外观:{preview.get('appearance_prompt') or '—'}\n风格:{preview.get('style_prompt') or '—'}\n\n"
|
||
"发送 /yp 确认 保存,或 /yp 放弃 取消。"
|
||
)
|
||
yield self._card_result(
|
||
event,
|
||
lambda: render_profile_card(
|
||
name=str(preview.get("name") or ""), base=str(preview.get("base_prompt") or ""),
|
||
appearance=str(preview.get("appearance_prompt") or ""), style=str(preview.get("style_prompt") or ""),
|
||
),
|
||
text,
|
||
)
|
||
|
||
@imagestudio_command.command("工作流")
|
||
async def imagestudio_workflow(self, event: AstrMessageEvent, profile: str = ""):
|
||
context = command_context_from_event(event)
|
||
config = _database_db_helper.load_config_payload()
|
||
if not command_allowed(config, "character_workflow", context):
|
||
self._record_chat_denied(context, "character_workflow")
|
||
yield event.plain_result(access_denied_text("角色工作流", context))
|
||
return
|
||
try:
|
||
detail = await asyncio.to_thread(self.chat_workflow_service.create_or_resume_character_workflow, profile, context)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 工作流创建失败:{exc}")
|
||
return
|
||
yield event.plain_result(self._format_workflow(detail))
|
||
|
||
@imagestudio_command.command("确认")
|
||
async def imagestudio_confirm(self, event: AstrMessageEvent):
|
||
context = command_context_from_event(event)
|
||
session = self.chat_sessions.pop(self._session_key(context))
|
||
if session is None:
|
||
yield event.plain_result("当前没有等待确认的 ImageStudio 操作。")
|
||
return
|
||
if session.action == "confirm_quick_profile":
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.save_quick_profile_draft, session.payload["draft"], context)
|
||
workflow_id = str(result.get("workflow", {}).get("workflow_id") or "")
|
||
if not workflow_id:
|
||
raise ValueError("快速角色四图工作流未创建")
|
||
request_id = f"chatfast_{uuid4().hex}"
|
||
task = asyncio.create_task(
|
||
self._run_quick_character_background(workflow_id, context, request_id)
|
||
)
|
||
self.chat_background_tasks.add(task)
|
||
task.add_done_callback(self.chat_background_tasks.discard)
|
||
yield event.plain_result(
|
||
f"✅ 快速角色已保存,四张角色图已并行加入生成队列\n"
|
||
f"角色:{result['profile']['name']}\nID:{result['profile']['profile_id']}\n"
|
||
f"工作流:{workflow_id}\n请求:{request_id}\n"
|
||
"头像、半身像、立绘与设定图相互独立,完成后会主动回传。"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 保存失败:{exc}")
|
||
return
|
||
if session.action == "confirm_materials":
|
||
confirmed = []
|
||
try:
|
||
for material_id in session.payload["material_ids"]:
|
||
confirmed.append(await asyncio.to_thread(self.chat_workflow_service.confirm_material, material_id, context))
|
||
yield event.plain_result("✅ 素材已确认:" + "、".join(item["material_id"] for item in confirmed))
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 素材确认失败:{exc}")
|
||
return
|
||
if session.action == "confirm_material":
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.confirm_material, session.payload["material_id"], context)
|
||
yield event.plain_result(f"✅ 素材已确认:{result['material_id']}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 素材确认失败:{exc}")
|
||
return
|
||
if session.action == "confirm_candidate":
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.confirm_node_image,
|
||
session.payload["node_id"],
|
||
session.payload["image_id"],
|
||
context,
|
||
)
|
||
next_node = result.get("next_node") or {}
|
||
next_hint = (
|
||
f"\n下一节点:{next_node.get('title') or next_node.get('node_key')}"
|
||
if next_node
|
||
else "\n当前阶段链路已到末尾。"
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 已确认采用图片:{result.get('image_id')}" + next_hint
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 确认候选失败:{exc}")
|
||
return
|
||
yield event.plain_result("该会话暂不支持确认。")
|
||
|
||
@imagestudio_command.command("放弃")
|
||
async def imagestudio_discard(self, event: AstrMessageEvent):
|
||
session = self.chat_sessions.pop(self._session_key(command_context_from_event(event)))
|
||
yield event.plain_result("已取消当前操作。" if session else "当前没有待取消的操作。")
|
||
|
||
@imagestudio_command.command("修改")
|
||
async def imagestudio_modify_draft(self, event: AstrMessageEvent, addition: str = ""):
|
||
context = command_context_from_event(event)
|
||
session = self.chat_sessions.get(self._session_key(context))
|
||
if session is None or session.action != "confirm_quick_profile":
|
||
yield event.plain_result("当前没有等待修改的快速角色草稿。")
|
||
return
|
||
preview = session.payload["draft"].get("profile_preview", {})
|
||
description = f"{preview.get('name', '')} {preview.get('base_prompt', '')} {addition}".strip()
|
||
try:
|
||
draft = await asyncio.to_thread(self.chat_workflow_service.create_quick_profile_draft, description, context)
|
||
self.chat_sessions.put(self._session_key(context), "confirm_quick_profile", {"draft": draft})
|
||
updated = draft.get("profile_preview", {})
|
||
yield event.plain_result(f"📝 草稿已更新\n名称:{updated.get('name')}\n设定:{updated.get('base_prompt')}\n发送 /yp 确认 保存。")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 修改失败:{exc}")
|
||
|
||
@imagestudio_command.command("节点")
|
||
async def imagestudio_nodes(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
try:
|
||
detail = await asyncio.to_thread(self.chat_workflow_service.workflow_detail, workflow_id.strip(), command_context_from_event(event))
|
||
yield event.plain_result(self._format_workflow(detail))
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 节点查询失败:{exc}")
|
||
|
||
@imagestudio_command.command("生成")
|
||
async def imagestudio_generate_node(self, event: AstrMessageEvent, node_id: str = ""):
|
||
context = command_context_from_event(event)
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.generate_node, node_id.strip(), context)
|
||
if isinstance(result.get("round"), dict):
|
||
round_record = result["round"]
|
||
round_id = str(round_record.get("round_id") or "")
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"round_feedback",
|
||
{"round_id": round_id, "node_id": node_id.strip()},
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 已加入候选生成队列\n节点:{node_id}\n"
|
||
f"轮次:{round_record.get('display_code') or round_id}\n"
|
||
f"候选:{round_record.get('requested_count') or 4} 个独立任务\n"
|
||
"生成结束后会主动回传;也可使用 /yp 轮次状态 <round_id> 查询。"
|
||
)
|
||
return
|
||
images = result.get("images", [])
|
||
if images:
|
||
self.chat_sessions.put(self._session_key(context), "select_image", {"node_id": node_id.strip(), "image_ids": [item["image_id"] for item in images]})
|
||
yield self._generation_result(event, f"✅ 节点生成完成\n节点:{node_id}\n任务:{result.get('task_id') or result.get('request_id') or '—'}\n回复数字选图,或使用 /yp 选择 <序号>。", images)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 节点生成失败:{exc}")
|
||
|
||
@imagestudio_command.command("重试节点")
|
||
async def imagestudio_retry_node(self, event: AstrMessageEvent, node_id: str = ""):
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.retry_node, node_id.strip(), command_context_from_event(event))
|
||
yield event.plain_result(f"✅ 节点已重试:{result.get('task_id') or node_id}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 节点重试失败:{exc}")
|
||
|
||
@imagestudio_command.command("完成节点")
|
||
async def imagestudio_complete_node(self, event: AstrMessageEvent, node_id: str = ""):
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.complete_node, node_id.strip(), command_context_from_event(event))
|
||
yield event.plain_result(f"✅ 节点已完成:{result.get('node_id', node_id)}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 完成节点失败:{exc}")
|
||
|
||
@imagestudio_command.command("下一步")
|
||
async def imagestudio_next_step(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.next_workflow_step, workflow_id.strip(), command_context_from_event(event))
|
||
if result.get("completed"):
|
||
yield event.plain_result(f"✅ 工作流已没有待执行节点:{workflow_id}")
|
||
elif result.get("requires_profile_card"):
|
||
yield event.plain_result(
|
||
f"📦 当前已到档案卡节点\n下一动作:{result.get('next_action')}"
|
||
)
|
||
elif result.get("requires_node_input"):
|
||
yield event.plain_result(
|
||
f"📝 当前节点需要先填写或确认内容\n节点:{result['node'].get('title') or result['node'].get('node_key')}\n"
|
||
f"下一动作:{result.get('next_action')}"
|
||
)
|
||
else:
|
||
generation = result.get("generation") if isinstance(result.get("generation"), dict) else {}
|
||
round_record = generation.get("round") if isinstance(generation.get("round"), dict) else None
|
||
if round_record:
|
||
self.chat_sessions.put(
|
||
self._session_key(command_context_from_event(event)),
|
||
"round_feedback",
|
||
{"round_id": round_record["round_id"], "node_id": result["node"]["node_id"]},
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 下一节点候选已入队\n节点:{result['node']['node_id']}\n"
|
||
f"轮次:{round_record.get('display_code') or round_record.get('round_id')}"
|
||
)
|
||
else:
|
||
yield event.plain_result(f"✅ 已执行下一节点\n节点:{result['node']['node_id']}\n任务:{generation.get('task_id') or '—'}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 下一步执行失败:{exc}")
|
||
|
||
@imagestudio_command.command("轮次")
|
||
async def imagestudio_round(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=2)
|
||
if not parts:
|
||
yield event.plain_result("用法:/yp 轮次 <node_id> [4|5] [可选提示词]")
|
||
return
|
||
node_id = parts[0]
|
||
count = 4
|
||
prompt = ""
|
||
if len(parts) >= 2 and parts[1].isdigit():
|
||
count = int(parts[1])
|
||
prompt = parts[2] if len(parts) >= 3 else ""
|
||
elif len(parts) >= 2:
|
||
prompt = " ".join(parts[1:])
|
||
if count not in {4, 5}:
|
||
yield event.plain_result("详细工作流每轮候选数量只能是 4 或 5。")
|
||
return
|
||
context = command_context_from_event(event)
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.create_round,
|
||
node_id,
|
||
context,
|
||
count=count,
|
||
prompt=prompt,
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 创建候选轮次失败:{exc}")
|
||
return
|
||
round_record = result.get("round", {})
|
||
round_id = str(round_record.get("round_id") or "")
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"round_feedback",
|
||
{"round_id": round_id, "node_id": node_id},
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 已加入候选生成队列\n轮次:{round_record.get('display_code') or round_id}\n"
|
||
f"节点:{node_id}\n候选:{round_record.get('requested_count') or count} 个独立任务\n"
|
||
f"ID:{round_id}\n生成结束后会主动回传。"
|
||
)
|
||
|
||
@imagestudio_command.command("轮次状态")
|
||
async def imagestudio_round_status(self, event: AstrMessageEvent, round_id: str = ""):
|
||
try:
|
||
detail = await asyncio.to_thread(
|
||
self.chat_workflow_service.round_detail,
|
||
round_id.strip(),
|
||
command_context_from_event(event),
|
||
)
|
||
yield event.plain_result(self._format_round(detail, include_failures=True))
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 轮次查询失败:{exc}")
|
||
|
||
@imagestudio_command.command("候选")
|
||
async def imagestudio_round_candidates(self, event: AstrMessageEvent, round_id: str = ""):
|
||
context = command_context_from_event(event)
|
||
try:
|
||
detail = await asyncio.to_thread(
|
||
self.chat_workflow_service.round_detail,
|
||
round_id.strip(),
|
||
context,
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 候选读取失败:{exc}")
|
||
return
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"round_feedback",
|
||
{"round_id": round_id.strip(), "node_id": detail.get("round", {}).get("node_id")},
|
||
)
|
||
images = [
|
||
{
|
||
**item["image"],
|
||
"display_code": item.get("display_code"),
|
||
}
|
||
for item in detail.get("candidates", [])
|
||
if isinstance(item, dict) and isinstance(item.get("image"), dict)
|
||
]
|
||
yield self._generation_result(
|
||
event,
|
||
self._format_round(detail) + "\n可直接回复:1、2喜欢,3严格拒绝。",
|
||
images,
|
||
)
|
||
|
||
@imagestudio_command.command("反馈")
|
||
async def imagestudio_round_feedback(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if len(parts) < 2:
|
||
yield event.plain_result("用法:/yp 反馈 <round_id> <自然语言反馈>")
|
||
return
|
||
round_id, feedback = parts
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.submit_round_feedback,
|
||
round_id,
|
||
feedback,
|
||
command_context_from_event(event),
|
||
)
|
||
yield event.plain_result("✅ 候选反馈已保存\n" + self._format_round_feedback(result))
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 候选反馈失败:{exc}")
|
||
|
||
@imagestudio_command.command("下一轮")
|
||
async def imagestudio_next_round(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if not parts:
|
||
yield event.plain_result("用法:/yp 下一轮 <round_id> [4|5]")
|
||
return
|
||
count = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else None
|
||
if count is not None and count not in {4, 5}:
|
||
yield event.plain_result("下一轮候选数量只能是 4 或 5。")
|
||
return
|
||
context = command_context_from_event(event)
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.create_next_round,
|
||
parts[0],
|
||
context,
|
||
count=count,
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 创建下一轮失败:{exc}")
|
||
return
|
||
round_record = result.get("round", {})
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"round_feedback",
|
||
{"round_id": round_record.get("round_id"), "node_id": round_record.get("node_id")},
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 优化轮次已入队\n轮次:{round_record.get('display_code')}\n"
|
||
f"父轮次:{result.get('parent_round_id')}\n候选:{round_record.get('requested_count')}"
|
||
)
|
||
|
||
@imagestudio_command.command("定稿")
|
||
async def imagestudio_confirm_round(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if len(parts) < 2:
|
||
yield event.plain_result("用法:/yp 定稿 <round_id> <候选编号>")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.confirm_round_candidate,
|
||
parts[0],
|
||
parts[1],
|
||
command_context_from_event(event),
|
||
)
|
||
next_node = result.get("next_node") or {}
|
||
yield event.plain_result(
|
||
f"✅ 已明确定稿:{parts[1]}\n轮次:{parts[0]}\n"
|
||
+ (
|
||
f"下一节点:{next_node.get('title') or next_node.get('node_key')}"
|
||
if next_node
|
||
else "当前分支已到末尾。"
|
||
)
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 定稿失败:{exc}")
|
||
|
||
@imagestudio_command.command("审查")
|
||
async def imagestudio_generation_cross_review(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=2)
|
||
if len(parts) < 2:
|
||
yield event.plain_result("用法:/yp 审查 <round_id> <候选编号> [审核|跳过]")
|
||
return
|
||
decision = parts[2] if len(parts) > 2 else "审核"
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.decide_generation_cross_review,
|
||
parts[0],
|
||
parts[1],
|
||
decision,
|
||
command_context_from_event(event),
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 生成式交叉审查失败:{exc}")
|
||
return
|
||
if result.get("review_decision", {}).get("decision") == "skip":
|
||
yield event.plain_result(f"✅ 已跳过交叉审查并采用候选 {parts[1]}")
|
||
return
|
||
round_record = result.get("round", {})
|
||
yield event.plain_result(
|
||
f"✅ 交叉审查候选已入队\n轮次:{round_record.get('display_code') or round_record.get('round_id')}\n"
|
||
"原始候选保留为 01,其余候选由不同生图模型生成;完成后会主动回传。"
|
||
)
|
||
|
||
@imagestudio_command.command("审查重做")
|
||
async def imagestudio_cross_review_regenerate(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=2)
|
||
if len(parts) < 2:
|
||
yield event.plain_result("用法:/yp 审查重做 <round_id> <候选编号,候选编号> [提示词修订]")
|
||
return
|
||
refs = [value for value in re.split(r"[,,、]", parts[1]) if value.strip()]
|
||
prompt_patch = parts[2] if len(parts) > 2 else ""
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.regenerate_cross_review,
|
||
parts[0],
|
||
refs,
|
||
command_context_from_event(event),
|
||
prompt_patch=prompt_patch,
|
||
)
|
||
round_record = result.get("round", {})
|
||
yield event.plain_result(
|
||
f"✅ 选中的审查候选已重新入队\n轮次:{round_record.get('display_code') or round_record.get('round_id')}"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 审查重做失败:{exc}")
|
||
|
||
@imagestudio_command.command("审查通过")
|
||
async def imagestudio_cross_review_approve(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if len(parts) < 2:
|
||
yield event.plain_result("用法:/yp 审查通过 <round_id> <候选编号>")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.approve_cross_review,
|
||
parts[0],
|
||
parts[1],
|
||
command_context_from_event(event),
|
||
)
|
||
next_node = result.get("next_node") or {}
|
||
yield event.plain_result(
|
||
f"✅ 交叉审查候选已采用:{parts[1]}\n"
|
||
f"下一节点:{next_node.get('title') or next_node.get('node_key') or '当前阶段末尾'}"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 审查通过失败:{exc}")
|
||
|
||
@imagestudio_command.command("素材")
|
||
async def imagestudio_node_materials(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if not parts:
|
||
yield event.plain_result("用法:/yp 素材 <node_id> [material_id,material_id];不填素材 ID 时仅查看")
|
||
return
|
||
context = command_context_from_event(event)
|
||
try:
|
||
if len(parts) == 1:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.get_node_materials,
|
||
parts[0],
|
||
context,
|
||
)
|
||
else:
|
||
material_ids = [value.strip() for value in re.split(r"[,,、]", parts[1]) if value.strip()]
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.save_node_materials,
|
||
parts[0],
|
||
material_ids,
|
||
context,
|
||
)
|
||
bindings = result.get("material_bindings") if isinstance(result.get("material_bindings"), dict) else {}
|
||
selected = bindings.get("selected_material_ids") or []
|
||
temporary = result.get("temporary_references") or []
|
||
yield event.plain_result(
|
||
f"🧵 节点素材\n节点:{parts[0]}\n"
|
||
f"素材:{'、'.join(selected) if selected else '未绑定'}\n临时参考:{len(temporary)}\n"
|
||
f"状态:{'可修改' if result.get('writable') else '只读'}"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 节点素材操作失败:{exc}")
|
||
|
||
@imagestudio_command.command("分支")
|
||
async def imagestudio_branches(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
try:
|
||
branches = await asyncio.to_thread(
|
||
self.chat_workflow_service.list_branches,
|
||
workflow_id.strip(),
|
||
command_context_from_event(event),
|
||
)
|
||
lines = [f"🌿 工作流分支 · {workflow_id}"]
|
||
for branch in branches:
|
||
lines.append(
|
||
f"• {branch.get('branch_name')} · {branch.get('status')} · 父分支 {branch.get('base_branch_name') or '—'}"
|
||
)
|
||
yield event.plain_result("\n".join(lines))
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 分支查询失败:{exc}")
|
||
|
||
@imagestudio_command.command("新建分支")
|
||
async def imagestudio_create_branch(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=2)
|
||
if len(parts) < 3:
|
||
yield event.plain_result("用法:/yp 新建分支 <workflow_id> <已完成切点node_id> <新分支名>")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.create_branch,
|
||
parts[0],
|
||
parts[2],
|
||
parts[1],
|
||
command_context_from_event(event),
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 分支已创建:{result.get('branch_name')}\n父分支:{result.get('base_branch_name') or 'main'}"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 新建分支失败:{exc}")
|
||
|
||
@imagestudio_command.command("切换分支")
|
||
async def imagestudio_switch_branch(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if len(parts) < 2:
|
||
yield event.plain_result("用法:/yp 切换分支 <workflow_id> <分支名>")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.switch_branch,
|
||
parts[0],
|
||
parts[1],
|
||
command_context_from_event(event),
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 已切换到分支:{result.get('current_branch')}\n当前节点:{result.get('current_node_id') or '—'}"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 切换分支失败:{exc}")
|
||
|
||
@imagestudio_command.command("档案卡")
|
||
async def imagestudio_profile_card(self, event: AstrMessageEvent, argument: str = ""):
|
||
parts = str(argument or "").strip().split(maxsplit=1)
|
||
if not parts:
|
||
yield event.plain_result("用法:/yp 档案卡 <workflow_id> [可选人设文档]")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.finalize_profile_card,
|
||
parts[0],
|
||
command_context_from_event(event),
|
||
persona_document=parts[1] if len(parts) > 1 else "",
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 角色档案卡已原子封存\nID:{result.get('card_id')}\n"
|
||
f"分支:{result.get('branch_name')}\n资产:{len(result.get('assets') or [])}"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 档案卡封存失败:{exc}")
|
||
|
||
@imagestudio_command.command("选图")
|
||
async def imagestudio_select_image(self, event: AstrMessageEvent, node_id: str = "", image_id: str = ""):
|
||
context = command_context_from_event(event)
|
||
try:
|
||
if image_id.strip().isdigit():
|
||
result = await asyncio.to_thread(self.chat_workflow_service.select_node_image_by_number, node_id.strip(), int(image_id), context)
|
||
else:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.select_node_image, node_id.strip(), image_id.strip(), context)
|
||
selected_image_id = result.get("image_id", image_id)
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"confirm_candidate",
|
||
{"node_id": node_id.strip(), "image_id": selected_image_id},
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 已暂选图片:{selected_image_id}\n发送 /yp 确认 正式采用并推进,或 /yp 放弃 取消。"
|
||
)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 选图失败:{exc}")
|
||
|
||
@imagestudio_command.command("候选图")
|
||
async def imagestudio_candidate_images(self, event: AstrMessageEvent, node_id: str = ""):
|
||
context = command_context_from_event(event)
|
||
try:
|
||
images = await asyncio.to_thread(self.chat_workflow_service.list_node_images, node_id.strip(), context)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 候选图读取失败:{exc}")
|
||
return
|
||
if not images:
|
||
yield event.plain_result("当前节点没有候选图。")
|
||
return
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"select_image",
|
||
{"node_id": node_id.strip(), "image_ids": [item["image_id"] for item in images]},
|
||
)
|
||
yield self._generation_result(event, "回复 /yp 选择 1 采用第一张候选图。", images)
|
||
|
||
@imagestudio_command.command("选择")
|
||
async def imagestudio_choose_candidate(self, event: AstrMessageEvent, number: str = ""):
|
||
context = command_context_from_event(event)
|
||
session = self.chat_sessions.get(self._session_key(context))
|
||
if session is None or session.action != "select_image":
|
||
yield event.plain_result("当前没有等待选择的候选图。")
|
||
return
|
||
try:
|
||
index = int(number) - 1
|
||
image_id = session.payload["image_ids"][index]
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.select_node_image,
|
||
session.payload["node_id"],
|
||
image_id,
|
||
context,
|
||
)
|
||
self.chat_sessions.put(
|
||
self._session_key(context),
|
||
"confirm_candidate",
|
||
{"node_id": session.payload["node_id"], "image_id": result.get("image_id", image_id)},
|
||
)
|
||
yield event.plain_result(
|
||
f"✅ 已暂选第 {index + 1} 张:{result.get('image_id', image_id)}\n"
|
||
"发送 /yp 确认 正式采用并推进,或 /yp 放弃 取消。"
|
||
)
|
||
except (ValueError, IndexError):
|
||
yield event.plain_result(f"请输入 1 到 {len(session.payload['image_ids'])} 之间的序号。")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 选图失败:{exc}")
|
||
|
||
@imagestudio_command.command("审核")
|
||
async def imagestudio_review(self, event: AstrMessageEvent, target_id: str = ""):
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.review, target_id.strip(), command_context_from_event(event))
|
||
yield event.plain_result("🔎 审核结果\n" + json.dumps(result, ensure_ascii=False, indent=2)[:3000])
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 审核失败:{exc}")
|
||
|
||
@imagestudio_command.command("高清")
|
||
async def imagestudio_hires(self, event: AstrMessageEvent, image_id: str = "", size: str = "2K"):
|
||
normalized_size = {"1K": "1920x1080", "2K": "2560x1440", "4K": "3840x2160"}.get(size.upper())
|
||
if not image_id.strip() or normalized_size is None:
|
||
yield event.plain_result("用法:/yp 高清 <image_id> 2K|4K")
|
||
return
|
||
context = command_context_from_event(event)
|
||
request_id = f"chathires_{uuid4().hex}"
|
||
task = asyncio.create_task(
|
||
self._run_hires_background(
|
||
image_id.strip(),
|
||
normalized_size,
|
||
context,
|
||
request_id,
|
||
)
|
||
)
|
||
self.chat_background_tasks.add(task)
|
||
task.add_done_callback(self.chat_background_tasks.discard)
|
||
yield event.plain_result(
|
||
f"✅ 高清修复请求已进入后台\n请求:{request_id}\n原图:{image_id}\n"
|
||
f"尺寸:{normalized_size}\n完成或失败后会主动回传。"
|
||
)
|
||
|
||
@imagestudio_command.command("素材导入")
|
||
async def imagestudio_import_material(self, event: AstrMessageEvent, category: str = ""):
|
||
references = image_references_from_event(event)
|
||
if not category.strip() or not references:
|
||
yield event.plain_result("用法:发送图片并附带 /yp 素材导入 <现有分类名称或ID>")
|
||
return
|
||
context = command_context_from_event(event)
|
||
try:
|
||
results = [await asyncio.to_thread(self.chat_workflow_service.import_material, reference, category.strip(), context) for reference in references]
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 素材导入或识别失败:{exc}")
|
||
return
|
||
material = results[0]["material"]
|
||
material_ids = [item["material"]["material_id"] for item in results]
|
||
profile_names = [item.get("name") for item in results[0].get("profiles", []) if item.get("name")]
|
||
self.chat_sessions.put(self._session_key(context), "confirm_materials", {"material_ids": material_ids})
|
||
yield event.plain_result(
|
||
f"🧵 已识别 {len(results)} 个素材\nID:{'、'.join(material_ids)}\n分类:{results[0]['category']['name']}\n"
|
||
f"提示词:{material.get('prompt') or '—'}\n标签:{'、'.join(material.get('tags') or [])}\n\n"
|
||
f"可用角色:{'、'.join(profile_names[:10]) or '暂无'}\n\n发送 /yp 确认 保存素材,或 /yp 放弃 取消。"
|
||
)
|
||
|
||
@imagestudio_command.command("重新识别")
|
||
async def imagestudio_re_recognize_material(self, event: AstrMessageEvent, material_id: str = ""):
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.re_recognize_material, material_id.strip(), command_context_from_event(event))
|
||
yield event.plain_result(f"✅ 素材已重新识别\nID:{result['material_id']}\n提示词:{result.get('prompt') or '—'}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 重新识别失败:{exc}")
|
||
|
||
@imagestudio_command.command("加入衣橱")
|
||
async def imagestudio_add_wardrobe(self, event: AstrMessageEvent, material_id: str = "", profile: str = "", category: str = "top"):
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.add_material_to_wardrobe, material_id.strip(), profile.strip(), category.strip(), command_context_from_event(event))
|
||
yield event.plain_result(f"✅ 素材已加入角色衣橱:{result.get('wardrobe_item_id') or material_id}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 加入衣橱失败:{exc}")
|
||
|
||
@imagestudio_command.command("单图")
|
||
async def imagestudio_single_image(self, event: AstrMessageEvent, prompt: str = ""):
|
||
context = command_context_from_event(event)
|
||
config = _database_db_helper.load_config_payload()
|
||
if not command_allowed(config, "single_image", context):
|
||
self._record_chat_denied(context, "single_image")
|
||
yield event.plain_result(access_denied_text("单图生成", context))
|
||
return
|
||
try:
|
||
command = parse_single_image_command(prompt)
|
||
except ChatCommandParseError as exc:
|
||
yield event.plain_result(single_image_usage(str(exc)))
|
||
return
|
||
request_id = f"chatreq_{uuid4().hex}"
|
||
task = asyncio.create_task(self._run_single_image_background(command, context, request_id))
|
||
self.chat_background_tasks.add(task)
|
||
task.add_done_callback(self.chat_background_tasks.discard)
|
||
yield event.plain_result(
|
||
"✅ 单图请求已进入后台执行\n\n"
|
||
f"请求:{request_id}\n尺寸:{command.size}\n数量:{command.count}\n"
|
||
f"模型:{command.model_route or 'quick_generation'}\n\n生成完成后会自动发送到当前会话。"
|
||
)
|
||
|
||
@imagestudio_command.command("任务")
|
||
async def imagestudio_jobs(self, event: AstrMessageEvent, task_id: str = ""):
|
||
context = command_context_from_event(event)
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.list_jobs, context, task_id=task_id.strip() or None)
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 任务查询失败:{exc}")
|
||
return
|
||
yield event.plain_result(self._format_jobs(result))
|
||
|
||
@imagestudio_command.command("取消")
|
||
async def imagestudio_cancel_job(self, event: AstrMessageEvent, task_id: str = ""):
|
||
if not task_id.strip():
|
||
yield event.plain_result("请提供任务 ID,例如:/yp 取消 task_xxx")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.cancel_job, command_context_from_event(event), task_id.strip())
|
||
yield event.plain_result(f"✅ 任务已取消:{result.get('task_id', task_id)}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 取消失败:{exc}")
|
||
|
||
@imagestudio_command.command("重试")
|
||
async def imagestudio_retry_job(self, event: AstrMessageEvent, task_id: str = ""):
|
||
if not task_id.strip():
|
||
yield event.plain_result("请提供任务 ID,例如:/yp 重试 task_xxx")
|
||
return
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.retry_job, command_context_from_event(event), task_id.strip())
|
||
yield event.plain_result(f"✅ 已创建重试任务:{result.get('task_id', task_id)}")
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 重试失败:{exc}")
|
||
|
||
async def _chat_command_result(self, event: AstrMessageEvent, action: str, label: str, argument: str):
|
||
context = command_context_from_event(event)
|
||
config = _database_db_helper.load_config_payload()
|
||
if not command_allowed(config, action, context):
|
||
yield event.plain_result(access_denied_text(label, context))
|
||
return
|
||
yield event.plain_result(accepted_text(label, argument, context))
|
||
|
||
@astrbot_filter.event_message_type(astrbot_filter.EventMessageType.ALL)
|
||
async def imagestudio_session_reply(self, event: AstrMessageEvent):
|
||
text = message_text_from_event(event)
|
||
if not text or text.startswith(("/", "!", "!")):
|
||
return
|
||
context = command_context_from_event(event)
|
||
session = self.chat_sessions.get(self._session_key(context))
|
||
if session is None:
|
||
return
|
||
normalized = text.strip().lower()
|
||
if normalized in {"取消", "退出", "放弃", "cancel"}:
|
||
self.chat_sessions.pop(self._session_key(context))
|
||
yield event.plain_result("已取消当前 ImageStudio 会话。")
|
||
return
|
||
if normalized in {"确认", "保存", "confirm"}:
|
||
async for result in self.imagestudio_confirm(event):
|
||
yield result
|
||
return
|
||
if session.action == "select_image" and normalized.isdigit():
|
||
async for result in self.imagestudio_choose_candidate(event, normalized):
|
||
yield result
|
||
return
|
||
if session.action == "round_feedback":
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.submit_round_feedback,
|
||
str(session.payload["round_id"]),
|
||
text,
|
||
context,
|
||
)
|
||
yield event.plain_result("✅ 候选反馈已保存\n" + self._format_round_feedback(result))
|
||
except Exception as exc:
|
||
yield event.plain_result(f"❌ 候选反馈失败:{exc}")
|
||
return
|
||
if session.action == "quick_profile_ready" and normalized in {"生成", "开始", "generate"}:
|
||
self.chat_sessions.pop(self._session_key(context))
|
||
async for result in self.imagestudio_generate_node(event, session.payload["node_id"]):
|
||
yield result
|
||
|
||
@astrbot_filter.command_group("yp")
|
||
def imagestudio_short_command(self) -> None:
|
||
"""Short alias for the ImageStudio command group."""
|
||
return None
|
||
|
||
@imagestudio_short_command.command("帮助")
|
||
async def imagestudio_short_help(self, event: AstrMessageEvent):
|
||
async for result in self.imagestudio_help(event):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("状态")
|
||
async def imagestudio_short_status(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
async for result in self.imagestudio_status(event, workflow_id):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("快速角色")
|
||
async def imagestudio_short_quick_profile(self, event: AstrMessageEvent, description: str = ""):
|
||
async for result in self.imagestudio_quick_profile(event, description):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("工作流")
|
||
async def imagestudio_short_workflow(self, event: AstrMessageEvent, profile: str = ""):
|
||
async for result in self.imagestudio_workflow(event, profile):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("单图")
|
||
async def imagestudio_short_single_image(self, event: AstrMessageEvent, prompt: str = ""):
|
||
async for result in self.imagestudio_single_image(event, prompt):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("任务")
|
||
async def imagestudio_short_jobs(self, event: AstrMessageEvent, task_id: str = ""):
|
||
async for result in self.imagestudio_jobs(event, task_id):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("取消")
|
||
async def imagestudio_short_cancel_job(self, event: AstrMessageEvent, task_id: str = ""):
|
||
async for result in self.imagestudio_cancel_job(event, task_id):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("重试")
|
||
async def imagestudio_short_retry_job(self, event: AstrMessageEvent, task_id: str = ""):
|
||
async for result in self.imagestudio_retry_job(event, task_id):
|
||
yield result
|
||
|
||
@imagestudio_short_command.command("确认")
|
||
async def imagestudio_short_confirm(self, event: AstrMessageEvent):
|
||
async for result in self.imagestudio_confirm(event): yield result
|
||
|
||
@imagestudio_short_command.command("放弃")
|
||
async def imagestudio_short_discard(self, event: AstrMessageEvent):
|
||
async for result in self.imagestudio_discard(event): yield result
|
||
|
||
@imagestudio_short_command.command("修改")
|
||
async def imagestudio_short_modify_draft(self, event: AstrMessageEvent, addition: str = ""):
|
||
async for result in self.imagestudio_modify_draft(event, addition): yield result
|
||
|
||
@imagestudio_short_command.command("节点")
|
||
async def imagestudio_short_nodes(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
async for result in self.imagestudio_nodes(event, workflow_id): yield result
|
||
|
||
@imagestudio_short_command.command("生成")
|
||
async def imagestudio_short_generate_node(self, event: AstrMessageEvent, node_id: str = ""):
|
||
async for result in self.imagestudio_generate_node(event, node_id): yield result
|
||
|
||
@imagestudio_short_command.command("重试节点")
|
||
async def imagestudio_short_retry_node(self, event: AstrMessageEvent, node_id: str = ""):
|
||
async for result in self.imagestudio_retry_node(event, node_id): yield result
|
||
|
||
@imagestudio_short_command.command("完成节点")
|
||
async def imagestudio_short_complete_node(self, event: AstrMessageEvent, node_id: str = ""):
|
||
async for result in self.imagestudio_complete_node(event, node_id): yield result
|
||
|
||
@imagestudio_short_command.command("下一步")
|
||
async def imagestudio_short_next_step(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
async for result in self.imagestudio_next_step(event, workflow_id): yield result
|
||
|
||
@imagestudio_short_command.command("轮次")
|
||
async def imagestudio_short_round(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_round(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("轮次状态")
|
||
async def imagestudio_short_round_status(self, event: AstrMessageEvent, round_id: str = ""):
|
||
async for result in self.imagestudio_round_status(event, round_id): yield result
|
||
|
||
@imagestudio_short_command.command("候选")
|
||
async def imagestudio_short_round_candidates(self, event: AstrMessageEvent, round_id: str = ""):
|
||
async for result in self.imagestudio_round_candidates(event, round_id): yield result
|
||
|
||
@imagestudio_short_command.command("反馈")
|
||
async def imagestudio_short_round_feedback(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_round_feedback(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("下一轮")
|
||
async def imagestudio_short_next_round(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_next_round(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("定稿")
|
||
async def imagestudio_short_confirm_round(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_confirm_round(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("审查")
|
||
async def imagestudio_short_generation_cross_review(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_generation_cross_review(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("审查重做")
|
||
async def imagestudio_short_cross_review_regenerate(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_cross_review_regenerate(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("审查通过")
|
||
async def imagestudio_short_cross_review_approve(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_cross_review_approve(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("素材")
|
||
async def imagestudio_short_node_materials(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_node_materials(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("分支")
|
||
async def imagestudio_short_branches(self, event: AstrMessageEvent, workflow_id: str = ""):
|
||
async for result in self.imagestudio_branches(event, workflow_id): yield result
|
||
|
||
@imagestudio_short_command.command("新建分支")
|
||
async def imagestudio_short_create_branch(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_create_branch(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("切换分支")
|
||
async def imagestudio_short_switch_branch(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_switch_branch(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("档案卡")
|
||
async def imagestudio_short_profile_card(self, event: AstrMessageEvent, argument: str = ""):
|
||
async for result in self.imagestudio_profile_card(event, argument): yield result
|
||
|
||
@imagestudio_short_command.command("选图")
|
||
async def imagestudio_short_select_image(self, event: AstrMessageEvent, node_id: str = "", image_id: str = ""):
|
||
async for result in self.imagestudio_select_image(event, node_id, image_id): yield result
|
||
|
||
@imagestudio_short_command.command("审核")
|
||
async def imagestudio_short_review(self, event: AstrMessageEvent, target_id: str = ""):
|
||
async for result in self.imagestudio_review(event, target_id): yield result
|
||
|
||
@imagestudio_short_command.command("高清")
|
||
async def imagestudio_short_hires(self, event: AstrMessageEvent, image_id: str = "", size: str = "2K"):
|
||
async for result in self.imagestudio_hires(event, image_id, size): yield result
|
||
|
||
@imagestudio_short_command.command("素材导入")
|
||
async def imagestudio_short_import_material(self, event: AstrMessageEvent, category: str = ""):
|
||
async for result in self.imagestudio_import_material(event, category): yield result
|
||
|
||
@imagestudio_short_command.command("重新识别")
|
||
async def imagestudio_short_re_recognize_material(self, event: AstrMessageEvent, material_id: str = ""):
|
||
async for result in self.imagestudio_re_recognize_material(event, material_id): yield result
|
||
|
||
@imagestudio_short_command.command("加入衣橱")
|
||
async def imagestudio_short_add_wardrobe(self, event: AstrMessageEvent, material_id: str = "", profile: str = "", category: str = "top"):
|
||
async for result in self.imagestudio_add_wardrobe(event, material_id, profile, category): yield result
|
||
|
||
@imagestudio_short_command.command("候选图")
|
||
async def imagestudio_short_candidate_images(self, event: AstrMessageEvent, node_id: str = ""):
|
||
async for result in self.imagestudio_candidate_images(event, node_id): yield result
|
||
|
||
@imagestudio_short_command.command("选择")
|
||
async def imagestudio_short_choose_candidate(self, event: AstrMessageEvent, number: str = ""):
|
||
async for result in self.imagestudio_choose_candidate(event, number): yield result
|
||
|
||
@staticmethod
|
||
def _format_jobs(result: Any) -> str:
|
||
if isinstance(result, dict) and "task_id" in result:
|
||
request = result.get("request") if isinstance(result.get("request"), dict) else {}
|
||
return (
|
||
f"📋 任务 {result['task_id']}\n状态:{result.get('status', 'unknown')}\n"
|
||
f"进度:{result.get('progress', 0)}%\n模型:{result.get('model_route') or '—'}\n"
|
||
f"尺寸:{request.get('size') or '—'}\n数量:{request.get('count') or '—'}\n"
|
||
f"节点:{result.get('node_id') or '—'}\n创建:{result.get('created_at') or '—'}"
|
||
)
|
||
items = result.get("items", []) if isinstance(result, dict) else result if isinstance(result, list) else []
|
||
if not items:
|
||
return "当前没有任务。"
|
||
lines = ["📋 最近任务"]
|
||
for item in items[:10]:
|
||
request = item.get("request") if isinstance(item.get("request"), dict) else {}
|
||
lines.append(f"• {item.get('task_id')} · {item.get('status')} · {item.get('progress', 0)}% · {request.get('size') or '默认尺寸'} · {item.get('model_route') or '默认模型'}")
|
||
return "\n".join(lines)
|
||
|
||
@staticmethod
|
||
def _session_key(context: Any) -> str:
|
||
return f"{context.platform}:{context.message_origin}:{context.user_id}"
|
||
|
||
@staticmethod
|
||
def _format_workflow(detail: dict[str, Any]) -> str:
|
||
workflow = detail.get("workflow", detail)
|
||
nodes = detail.get("nodes", [])
|
||
lines = [f"📋 {detail.get('profile', {}).get('name', '角色')} 工作流", f"ID:{workflow.get('workflow_id')}", f"状态:{workflow.get('status')}"]
|
||
for node in nodes:
|
||
marker = "▶" if node.get("node_id") == workflow.get("current_node_id") else "✅" if node.get("status") == "completed" else "○"
|
||
lines.append(f"{marker} {node.get('display_name') or node.get('node_key')} · {node.get('status')}")
|
||
return "\n".join(lines)
|
||
|
||
@staticmethod
|
||
def _format_round(detail: dict[str, Any], *, include_failures: bool = False) -> str:
|
||
round_record = detail.get("round") if isinstance(detail.get("round"), dict) else {}
|
||
lines = [
|
||
f"🎞 候选轮次 {round_record.get('display_code') or round_record.get('round_id') or '—'}",
|
||
f"状态:{round_record.get('status') or 'unknown'}",
|
||
f"分支:{round_record.get('branch_name') or 'main'}",
|
||
]
|
||
for item in detail.get("candidates", []):
|
||
if not isinstance(item, dict):
|
||
continue
|
||
candidate = item.get("candidate") if isinstance(item.get("candidate"), dict) else {}
|
||
line = (
|
||
f"• {item.get('display_code') or item.get('display_index')} · "
|
||
f"{candidate.get('generation_status') or 'unknown'} · "
|
||
f"{item.get('preference_status') or 'neutral'}"
|
||
)
|
||
if item.get("is_final"):
|
||
line += " · 已定稿"
|
||
if include_failures:
|
||
failure = candidate.get("failure") if isinstance(candidate.get("failure"), dict) else {}
|
||
if failure.get("message"):
|
||
line += f" · {str(failure['message'])[:180]}"
|
||
lines.append(line)
|
||
return "\n".join(lines)
|
||
|
||
@staticmethod
|
||
def _format_round_feedback(detail: dict[str, Any]) -> str:
|
||
lines: list[str] = []
|
||
interpretation = detail.get("interpretation") if isinstance(detail.get("interpretation"), dict) else {}
|
||
for label, key in (("喜欢", "liked"), ("拒绝", "rejected"), ("严格拒绝", "strict_rejected")):
|
||
values = interpretation.get(key) if isinstance(interpretation.get(key), list) else []
|
||
codes = [str(item.get("display_code") or "") for item in values if isinstance(item, dict)]
|
||
if codes:
|
||
lines.append(f"{label}:{'、'.join(codes)}")
|
||
final = interpretation.get("final") if isinstance(interpretation.get("final"), dict) else None
|
||
if final:
|
||
lines.append(f"草稿定稿:{final.get('display_code')}")
|
||
snapshot = detail.get("round", {}).get("feedback_snapshot") if isinstance(detail.get("round"), dict) else {}
|
||
if not lines and isinstance(snapshot, dict):
|
||
lines.append("反馈快照已更新。")
|
||
lines.append("正式推进仍需使用 /yp 定稿 <round_id> <候选编号>。")
|
||
return "\n".join(lines)
|
||
|
||
def _help_card(self) -> Path:
|
||
return render_help_card([
|
||
"/影棚 帮助 /yp 帮助",
|
||
"/影棚 状态 /yp 状态",
|
||
"/影棚 快速角色 <角色描述>",
|
||
"/影棚 工作流 <角色名或 ID>",
|
||
"/影棚 单图 <提示词>",
|
||
"/yp 轮次 <node_id> 4|5",
|
||
"/yp 候选 / 反馈 / 下一轮 / 定稿",
|
||
"/yp 审查 / 素材 / 分支 / 档案卡",
|
||
])
|
||
|
||
def _card_result(self, event: AstrMessageEvent, renderer: Callable[[], Path], fallback: str):
|
||
if AstrBotImage is not None and hasattr(event, "chain_result"):
|
||
try:
|
||
return event.chain_result([AstrBotImage.fromFileSystem(str(renderer()))])
|
||
except Exception:
|
||
pass
|
||
return event.plain_result(fallback)
|
||
|
||
def _generation_result(self, event: AstrMessageEvent, text: str, images: list[dict[str, Any]]):
|
||
if AstrBotImage is not None and AstrBotPlain is not None and hasattr(event, "chain_result"):
|
||
try:
|
||
chain: list[Any] = [AstrBotPlain(text)]
|
||
for index, item in enumerate(images, 1):
|
||
url = item.get("image_url") or item.get("thumbnail_url")
|
||
if url:
|
||
chain.extend([AstrBotPlain(f"\n候选图 {index}\n"), AstrBotImage.fromURL(str(url))])
|
||
if len(chain) > 1:
|
||
return event.chain_result(chain)
|
||
except Exception:
|
||
pass
|
||
suffix = "".join(
|
||
f"\n候选图 {index}:{item.get('image_url') or item.get('image_id')}"
|
||
for index, item in enumerate(images, 1)
|
||
)
|
||
return event.plain_result(text + suffix)
|
||
|
||
async def _run_single_image_background(self, command: Any, context: Any, request_id: str) -> None:
|
||
try:
|
||
result = await asyncio.to_thread(self.chat_workflow_service.submit_single_image, command, context)
|
||
generation = result["generation"]
|
||
text = (
|
||
f"✅ 单图生成完成\n请求:{request_id}\n任务:{generation.get('task_id') or '—'}\n"
|
||
f"工作流:{result['workflow']['workflow_id']}\n节点:{result['node']['node_id']}"
|
||
)
|
||
await self._send_proactive(context.message_origin, text, result.get("images", []))
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception as exc:
|
||
await self._send_proactive(context.message_origin, f"❌ 单图生成失败\n请求:{request_id}\n错误:{exc}", [])
|
||
|
||
async def _run_quick_character_background(
|
||
self,
|
||
workflow_id: str,
|
||
context: Any,
|
||
request_id: str,
|
||
) -> None:
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.generate_quick_character,
|
||
workflow_id,
|
||
context,
|
||
)
|
||
text = (
|
||
f"🎭 快速角色四图生成结束\n请求:{request_id}\n工作流:{workflow_id}\n"
|
||
f"成功:{result.get('succeeded', 0)} / 4\n失败:{result.get('failed', 0)}"
|
||
)
|
||
failures = result.get("failures") if isinstance(result.get("failures"), list) else []
|
||
for item in failures:
|
||
text += f"\n• {item.get('node_key') or item.get('node_id')}:{item.get('message')}"
|
||
await self._send_proactive(context.message_origin, text, result.get("images", []))
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception as exc:
|
||
await self._send_proactive(
|
||
context.message_origin,
|
||
f"❌ 快速角色生成失败\n请求:{request_id}\n工作流:{workflow_id}\n错误:{exc}",
|
||
[],
|
||
)
|
||
|
||
async def _run_hires_background(
|
||
self,
|
||
image_id: str,
|
||
normalized_size: str,
|
||
context: Any,
|
||
request_id: str,
|
||
) -> None:
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
self.chat_workflow_service.hires_fix,
|
||
image_id,
|
||
normalized_size,
|
||
context,
|
||
)
|
||
await self._send_proactive(
|
||
context.message_origin,
|
||
f"✅ 高清修复完成\n请求:{request_id}\n原图:{image_id}\n尺寸:{normalized_size}",
|
||
result.get("images", []),
|
||
)
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception as exc:
|
||
await self._send_proactive(
|
||
context.message_origin,
|
||
f"❌ 高清修复失败\n请求:{request_id}\n原图:{image_id}\n错误:{exc}",
|
||
[],
|
||
)
|
||
|
||
async def _send_proactive(self, message_origin: str, text: str, images: list[dict[str, Any]]) -> bool:
|
||
sender = getattr(self.context, "send_message", None)
|
||
if not callable(sender) or not message_origin:
|
||
return False
|
||
try:
|
||
components: list[Any] = []
|
||
if AstrBotPlain is not None:
|
||
components.append(AstrBotPlain(text))
|
||
for index, item in enumerate(images, 1):
|
||
url = item.get("image_url") or item.get("thumbnail_url")
|
||
if url and AstrBotImage is not None:
|
||
if AstrBotPlain is not None:
|
||
components.append(AstrBotPlain(f"\n候选图 {index}\n"))
|
||
components.append(AstrBotImage.fromURL(str(url)))
|
||
message = AstrBotMessageChain(components) if AstrBotMessageChain is not None else components
|
||
result = sender(message_origin, message)
|
||
if inspect.isawaitable(result):
|
||
await result
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
def _schedule_round_terminal_notification(self, notification: dict[str, Any]) -> None:
|
||
loop = self.runtime_loop
|
||
if loop is None or loop.is_closed():
|
||
raise RuntimeError("AstrBot event loop is unavailable for terminal notification")
|
||
|
||
def schedule() -> None:
|
||
task = asyncio.create_task(self._deliver_round_terminal_notification(notification))
|
||
self.chat_background_tasks.add(task)
|
||
task.add_done_callback(self.chat_background_tasks.discard)
|
||
|
||
loop.call_soon_threadsafe(schedule)
|
||
|
||
async def _replay_round_terminal_notifications(self) -> None:
|
||
runtime = self.round_worker_runtime
|
||
if runtime is None:
|
||
return
|
||
try:
|
||
pending = await asyncio.to_thread(runtime.pending_terminal_notifications)
|
||
except Exception:
|
||
return
|
||
for notification in pending:
|
||
await self._deliver_round_terminal_notification(notification)
|
||
|
||
async def _deliver_round_terminal_notification(self, notification: dict[str, Any]) -> None:
|
||
runtime = self.round_worker_runtime
|
||
round_id = str(notification.get("round_id") or "")
|
||
target = notification.get("reply_target")
|
||
target = target if isinstance(target, dict) else {}
|
||
candidates = [
|
||
item for item in notification.get("candidates", []) if isinstance(item, dict)
|
||
]
|
||
succeeded = [item for item in candidates if item.get("generation_status") == "succeeded"]
|
||
failed = [item for item in candidates if item.get("generation_status") in {"failed", "cancelled"}]
|
||
status_labels = {
|
||
"completed": "全部完成",
|
||
"partial_success": "部分完成",
|
||
"all_failed": "全部失败",
|
||
"cancelled": "已取消",
|
||
}
|
||
lines = [
|
||
"🎨 候选轮次已结束",
|
||
f"轮次:{notification.get('display_code') or round_id}",
|
||
f"状态:{status_labels.get(str(notification.get('status')), notification.get('status') or '未知')}",
|
||
f"成功:{len(succeeded)} / {len(candidates)}",
|
||
]
|
||
for item in candidates:
|
||
line = f"• {item.get('display_code') or item.get('candidate_id')} · {item.get('generation_status')}"
|
||
failure = item.get("failure") if isinstance(item.get("failure"), dict) else {}
|
||
if failure.get("message"):
|
||
line += f" · {str(failure['message'])[:160]}"
|
||
lines.append(line)
|
||
if succeeded:
|
||
lines.append(f"使用 /yp 候选 {round_id} 查看;/yp 反馈 {round_id} <自然语言反馈>")
|
||
elif failed:
|
||
lines.append("请检查模型/网络错误后重新创建轮次。")
|
||
delivered = await self._send_proactive(
|
||
str(target.get("message_origin") or ""),
|
||
"\n".join(lines),
|
||
succeeded,
|
||
)
|
||
if runtime is not None and round_id:
|
||
await asyncio.to_thread(
|
||
runtime.mark_terminal_notification,
|
||
round_id,
|
||
delivered=delivered,
|
||
error_message=None if delivered else "AstrBot send_message returned no delivery",
|
||
)
|
||
|
||
def _record_chat_denied(self, context: Any, action: str) -> None:
|
||
try:
|
||
self.chat_workflow_service.guard.record(context, action, allowed=False, details={"reason": "allowlist"})
|
||
except Exception:
|
||
return
|
||
|
||
def get_plugin_manifest(self) -> dict[str, Any]:
|
||
return get_plugin_manifest()
|
||
|
||
def register_plugin(self, runtime: Any) -> dict[str, Any]:
|
||
return register_plugin(runtime)
|
||
|
||
|
||
def _bridge_registration_routes() -> list[dict[str, str]]:
|
||
path = f"/{PLUGIN_NAME}/<path:endpoint>"
|
||
return [
|
||
{"method": method, "path": path, "endpoint": ""}
|
||
for method in sorted({route.method for route in ROUTES})
|
||
]
|
||
|
||
|
||
def _mapping_from_runtime_config(config: Any | None) -> dict[str, Any]:
|
||
if config is None:
|
||
return {}
|
||
mapping = _mapping_from_any(config)
|
||
if mapping:
|
||
return mapping
|
||
for method_name in ("to_dict", "dict", "model_dump"):
|
||
method = getattr(config, method_name, None)
|
||
if not callable(method):
|
||
continue
|
||
try:
|
||
mapping = _mapping_from_any(method())
|
||
except Exception:
|
||
mapping = {}
|
||
if mapping:
|
||
return mapping
|
||
for attr_name in ("config", "data", "_config", "_data"):
|
||
mapping = _mapping_from_any(_attr(config, attr_name))
|
||
if mapping:
|
||
return mapping
|
||
|
||
known_keys = (
|
||
"default_generation_model",
|
||
"generation_provider_id",
|
||
"generation_provider_base_url",
|
||
"generation_provider_image_endpoint",
|
||
"generation_provider_model",
|
||
"generation_provider_route",
|
||
"generation_provider_api_key_env_var",
|
||
"generation_provider_timeout_seconds",
|
||
"vision_provider_id",
|
||
"vision_provider_base_url",
|
||
"vision_provider_endpoint",
|
||
"vision_provider_model",
|
||
"vision_provider_route",
|
||
"vision_provider_api_key_env_var",
|
||
"vision_provider_timeout_seconds",
|
||
"vision_provider_enabled",
|
||
"model_material_recognition",
|
||
"model_advanced_material_recognition",
|
||
"model_advanced_style_consensus",
|
||
"model_advanced_material_validation_generation",
|
||
"advanced_material_budget_enabled",
|
||
"advanced_material_budget_days",
|
||
"advanced_material_budget_max_task_count",
|
||
"advanced_material_budget_max_image_count",
|
||
"advanced_material_budget_max_estimated_cost",
|
||
"advanced_material_budget_price_key",
|
||
"advanced_material_budget_per_request",
|
||
"advanced_material_budget_per_image",
|
||
"advanced_material_budget_per_1k_tokens",
|
||
"model_profile_parse",
|
||
"model_persona_split",
|
||
"model_prompt_planning",
|
||
"model_visual_review_routes",
|
||
"model_cross_review_primary",
|
||
"model_cross_review_secondary",
|
||
"model_cross_review_routes",
|
||
"model_generation_cross_review_primary",
|
||
"model_generation_cross_review_secondary",
|
||
"model_generation_cross_review_routes",
|
||
"model_quick_generation",
|
||
"model_portrait_generation",
|
||
"model_halfbody_generation",
|
||
"model_fullbody_generation",
|
||
"model_sheet_generation",
|
||
"model_hires_fix",
|
||
"chat_group_allowlist",
|
||
"chat_user_allowlist",
|
||
"chat_user_concurrency_limit",
|
||
"chat_group_concurrency_limit",
|
||
"chat_daily_user_generation_limit",
|
||
"chat_daily_group_generation_limit",
|
||
"chat_allow_2k",
|
||
"chat_allow_4k",
|
||
"enable_private_companion_integration",
|
||
"advanced_materials_path",
|
||
"database_backend",
|
||
"sqlite_path",
|
||
"postgresql_enabled",
|
||
"postgresql_dsn",
|
||
"postgresql_host",
|
||
"postgresql_port",
|
||
"postgresql_database",
|
||
"postgresql_user",
|
||
"postgresql_password",
|
||
)
|
||
getter = getattr(config, "get", None)
|
||
if not callable(getter):
|
||
return {}
|
||
values: dict[str, Any] = {}
|
||
for key in known_keys:
|
||
try:
|
||
value = getter(key, _MISSING)
|
||
except TypeError:
|
||
try:
|
||
value = getter(key)
|
||
except Exception:
|
||
value = _MISSING
|
||
except Exception:
|
||
value = _MISSING
|
||
if value is not _MISSING:
|
||
values[key] = value
|
||
return values
|
||
|
||
|
||
def _set_runtime_config_overrides(patch: Mapping[str, Any]) -> None:
|
||
setter = getattr(_database_db_helper, "set_runtime_config_overrides", None)
|
||
if callable(setter):
|
||
setter(patch)
|
||
|
||
|
||
def _set_runtime_config_persister(config: Any | None) -> None:
|
||
setter = getattr(_database_db_helper, "set_runtime_config_persister", None)
|
||
if not callable(setter):
|
||
return
|
||
save_config = getattr(config, "save_config", None)
|
||
if config is None or not callable(save_config):
|
||
setter(None)
|
||
return
|
||
|
||
def persist(values: Mapping[str, Any]) -> dict[str, Any]:
|
||
return _persist_astrbot_config_values(config, values)
|
||
|
||
setter(persist)
|
||
|
||
|
||
def _persist_astrbot_config_values(config: Any, values: Mapping[str, Any]) -> dict[str, Any]:
|
||
"""Write ImageStudio runtime-managed paths back to AstrBot's plugin config."""
|
||
|
||
updated_keys: list[str] = []
|
||
previous: dict[str, Any] = {}
|
||
for path, value in values.items():
|
||
source_key = _RUNTIME_PATH_TO_ASTRBOT_KEY.get(str(path))
|
||
if not source_key:
|
||
continue
|
||
previous[source_key] = config.get(source_key, _MISSING)
|
||
config[source_key] = value
|
||
updated_keys.append(source_key)
|
||
if not updated_keys:
|
||
return {"available": True, "saved": False, "paths": [], "astrbot_keys": []}
|
||
try:
|
||
config.save_config()
|
||
except Exception:
|
||
for key, value in previous.items():
|
||
if value is _MISSING:
|
||
config.pop(key, None)
|
||
else:
|
||
config[key] = value
|
||
raise
|
||
patch = _runtime_config_patch_from_mapping(_mapping_from_runtime_config(config))
|
||
_set_runtime_config_overrides(patch)
|
||
return {
|
||
"available": True,
|
||
"saved": True,
|
||
"paths": sorted(str(path) for path in values),
|
||
"astrbot_keys": sorted(updated_keys),
|
||
}
|
||
|
||
|
||
def _runtime_config_argument(args: tuple[Any, ...], kwargs: Mapping[str, Any]) -> Any | None:
|
||
if "config" in kwargs and kwargs["config"] is not None:
|
||
return kwargs["config"]
|
||
if "plugin_config" in kwargs and kwargs["plugin_config"] is not None:
|
||
return kwargs["plugin_config"]
|
||
return args[0] if args else None
|
||
|
||
|
||
def _runtime_config_patch_from_mapping(mapping: Mapping[str, Any]) -> dict[str, Any]:
|
||
patch: dict[str, Any] = {}
|
||
if not mapping:
|
||
return patch
|
||
|
||
database = _mapping_from_any(mapping.get("database"))
|
||
sqlite = _mapping_from_any(database.get("sqlite")) if database else {}
|
||
postgresql = _mapping_from_any(database.get("postgresql")) if database else {}
|
||
storage = _mapping_from_any(mapping.get("storage"))
|
||
features = _mapping_from_any(mapping.get("features"))
|
||
plugin = _mapping_from_any(mapping.get("plugin"))
|
||
vision = _mapping_from_any(mapping.get("vision"))
|
||
vision_provider_config = _mapping_from_any(vision.get("provider")) if vision else {}
|
||
|
||
display_name = _runtime_text(_runtime_value(mapping, "display_name", fallback=plugin.get("display_name", _MISSING)))
|
||
if display_name:
|
||
_set_nested(patch, ("plugin", "display_name"), display_name)
|
||
|
||
default_model = _runtime_text(_runtime_value(mapping, "default_generation_model"))
|
||
if default_model:
|
||
_set_nested(patch, ("generation", "default_model"), default_model)
|
||
|
||
generation_provider_fields = {
|
||
"provider_id": "generation_provider_id",
|
||
"base_url": "generation_provider_base_url",
|
||
"image_endpoint": "generation_provider_image_endpoint",
|
||
"model_id": "generation_provider_model",
|
||
"route_name": "generation_provider_route",
|
||
"api_key_env_var": "generation_provider_api_key_env_var",
|
||
}
|
||
generation_provider: dict[str, Any] = {}
|
||
for target_key, source_key in generation_provider_fields.items():
|
||
value = _runtime_text(_runtime_value(mapping, source_key))
|
||
if value:
|
||
generation_provider[target_key] = value
|
||
timeout = _runtime_text(_runtime_value(mapping, "generation_provider_timeout_seconds"))
|
||
if timeout:
|
||
try:
|
||
generation_provider["timeout_seconds"] = int(timeout)
|
||
except ValueError:
|
||
generation_provider["timeout_seconds"] = timeout
|
||
if generation_provider:
|
||
_set_nested(patch, ("generation", "provider"), generation_provider)
|
||
|
||
vision_route = _runtime_text(
|
||
_runtime_value(
|
||
mapping,
|
||
"vision_provider_route",
|
||
fallback=vision_provider_config.get("route_name", vision.get("default_route", _MISSING)),
|
||
)
|
||
)
|
||
if vision_route:
|
||
_set_nested(patch, ("vision", "default_route"), vision_route)
|
||
|
||
vision_provider_fields = {
|
||
"provider_id": "vision_provider_id",
|
||
"base_url": "vision_provider_base_url",
|
||
"vision_endpoint": "vision_provider_endpoint",
|
||
"model_id": "vision_provider_model",
|
||
"route_name": "vision_provider_route",
|
||
"api_key_env_var": "vision_provider_api_key_env_var",
|
||
}
|
||
vision_provider: dict[str, Any] = {}
|
||
for target_key, source_key in vision_provider_fields.items():
|
||
value = _runtime_text(
|
||
_runtime_value(mapping, source_key, fallback=vision_provider_config.get(target_key, _MISSING))
|
||
)
|
||
if value:
|
||
vision_provider[target_key] = value
|
||
vision_timeout = _runtime_text(
|
||
_runtime_value(
|
||
mapping,
|
||
"vision_provider_timeout_seconds",
|
||
fallback=vision_provider_config.get("timeout_seconds", _MISSING),
|
||
)
|
||
)
|
||
if vision_timeout:
|
||
try:
|
||
vision_provider["timeout_seconds"] = int(vision_timeout)
|
||
except ValueError:
|
||
vision_provider["timeout_seconds"] = vision_timeout
|
||
vision_enabled = _runtime_value(
|
||
mapping,
|
||
"vision_provider_enabled",
|
||
fallback=vision_provider_config.get("enabled", _MISSING),
|
||
)
|
||
if vision_enabled is not _MISSING:
|
||
vision_provider["enabled"] = _runtime_bool(vision_enabled)
|
||
if vision_provider:
|
||
_set_nested(patch, ("vision", "provider"), vision_provider)
|
||
|
||
assignment_fields = {
|
||
"material_recognition": "model_material_recognition",
|
||
"profile_parse": "model_profile_parse",
|
||
"persona_split": "model_persona_split",
|
||
"prompt_planning": "model_prompt_planning",
|
||
"cross_review_primary": "model_cross_review_primary",
|
||
"cross_review_secondary": "model_cross_review_secondary",
|
||
"quick_generation": "model_quick_generation",
|
||
"portrait_generation": "model_portrait_generation",
|
||
"halfbody_generation": "model_halfbody_generation",
|
||
"fullbody_generation": "model_fullbody_generation",
|
||
"sheet_generation": "model_sheet_generation",
|
||
"hires_fix": "model_hires_fix",
|
||
}
|
||
for target_key, source_key in assignment_fields.items():
|
||
value = _runtime_text(_runtime_value(mapping, source_key))
|
||
if value:
|
||
_set_nested(patch, ("model_assignments", target_key), value)
|
||
|
||
# Advanced-material assignments deliberately preserve an empty value so
|
||
# administrators can clear a dedicated route and return to its documented
|
||
# fallback without a stale AstrBot runtime override restoring it.
|
||
for target_key, source_key in {
|
||
"advanced_material_recognition": "model_advanced_material_recognition",
|
||
"advanced_material_validation_generation": "model_advanced_material_validation_generation",
|
||
}.items():
|
||
value = _runtime_value(mapping, source_key)
|
||
if value is not _MISSING:
|
||
_set_nested(patch, ("model_assignments", target_key), _runtime_text(value))
|
||
|
||
consensus_route = _runtime_text(_runtime_value(mapping, "model_advanced_style_consensus"))
|
||
if consensus_route:
|
||
_set_nested(patch, ("model_assignments", "advanced_style_consensus"), consensus_route)
|
||
|
||
advanced_materials_path = _runtime_text(
|
||
_runtime_value(
|
||
mapping,
|
||
"advanced_materials_path",
|
||
fallback=storage.get("advanced_materials_path", _MISSING),
|
||
)
|
||
)
|
||
if advanced_materials_path:
|
||
_set_nested(patch, ("storage", "advanced_materials_path"), advanced_materials_path)
|
||
|
||
advanced_materials = mapping.get("advanced_materials") if isinstance(mapping.get("advanced_materials"), Mapping) else {}
|
||
current_budget = advanced_materials.get("cost_budget") if isinstance(advanced_materials.get("cost_budget"), Mapping) else {}
|
||
budget_enabled = _runtime_value(
|
||
mapping,
|
||
"advanced_material_budget_enabled",
|
||
fallback=current_budget.get("enabled", _MISSING),
|
||
)
|
||
if budget_enabled is not _MISSING:
|
||
_set_nested(patch, ("advanced_materials", "cost_budget", "enabled"), _runtime_bool(budget_enabled))
|
||
for target_key, source_key, converter in (
|
||
("days", "advanced_material_budget_days", int),
|
||
("max_task_count", "advanced_material_budget_max_task_count", int),
|
||
("max_image_count", "advanced_material_budget_max_image_count", int),
|
||
("max_estimated_cost", "advanced_material_budget_max_estimated_cost", float),
|
||
("per_request", "advanced_material_budget_per_request", float),
|
||
("per_image", "advanced_material_budget_per_image", float),
|
||
("per_1k_tokens", "advanced_material_budget_per_1k_tokens", float),
|
||
):
|
||
raw_value = _runtime_value(mapping, source_key, fallback=current_budget.get(target_key, _MISSING))
|
||
if raw_value is _MISSING:
|
||
continue
|
||
text_value = _runtime_text(raw_value)
|
||
if text_value == "" and target_key in {"max_task_count", "max_image_count", "max_estimated_cost"}:
|
||
_set_nested(patch, ("advanced_materials", "cost_budget", target_key), None)
|
||
continue
|
||
try:
|
||
normalized_value = converter(text_value or 0)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
_set_nested(patch, ("advanced_materials", "cost_budget", target_key), normalized_value)
|
||
budget_price_key = _runtime_value(
|
||
mapping,
|
||
"advanced_material_budget_price_key",
|
||
fallback=current_budget.get("price_key", _MISSING),
|
||
)
|
||
if budget_price_key is not _MISSING:
|
||
_set_nested(
|
||
patch,
|
||
("advanced_materials", "cost_budget", "price_key"),
|
||
_runtime_text(budget_price_key),
|
||
)
|
||
|
||
# Multi-route assignments are first-class AstrBot plugin settings. Keep
|
||
# empty lists as explicit values so clearing a selection in the Web UI is
|
||
# persisted back to AstrBot instead of being restored from a stale runtime
|
||
# override on the next settings reload.
|
||
assignment_list_fields = {
|
||
"visual_review_routes": "model_visual_review_routes",
|
||
"cross_review_routes": "model_cross_review_routes",
|
||
"generation_cross_review_routes": "model_generation_cross_review_routes",
|
||
}
|
||
for target_key, source_key in assignment_list_fields.items():
|
||
value = _runtime_value(mapping, source_key)
|
||
if value is _MISSING:
|
||
continue
|
||
if isinstance(value, (list, tuple, set, frozenset)):
|
||
normalized = [str(item).strip() for item in value if str(item).strip()]
|
||
elif value in (None, ""):
|
||
normalized = []
|
||
else:
|
||
normalized = [str(value).strip()]
|
||
_set_nested(patch, ("model_assignments", target_key), normalized)
|
||
|
||
# Unlike legacy assignment fields, these routes intentionally accept an
|
||
# empty string. That value means "not configured" and still has to remain
|
||
# runtime-managed so a later UI selection can round-trip through
|
||
# AstrBotConfig.save_config().
|
||
for target_key, source_key in {
|
||
"generation_cross_review_primary": "model_generation_cross_review_primary",
|
||
"generation_cross_review_secondary": "model_generation_cross_review_secondary",
|
||
}.items():
|
||
value = _runtime_value(mapping, source_key)
|
||
if value is not _MISSING:
|
||
_set_nested(patch, ("model_assignments", target_key), _runtime_text(value))
|
||
|
||
for target_key, source_key in {
|
||
"group_allowlist": "chat_group_allowlist",
|
||
"user_allowlist": "chat_user_allowlist",
|
||
}.items():
|
||
value = _runtime_value(mapping, source_key)
|
||
if isinstance(value, (list, tuple, set, frozenset)):
|
||
_set_nested(patch, ("chat_access", target_key), [str(item).strip() for item in value if str(item).strip()])
|
||
for target_key, source_key in {
|
||
"user_concurrency_limit": "chat_user_concurrency_limit",
|
||
"group_concurrency_limit": "chat_group_concurrency_limit",
|
||
"daily_user_generation_limit": "chat_daily_user_generation_limit",
|
||
"daily_group_generation_limit": "chat_daily_group_generation_limit",
|
||
"allow_2k": "chat_allow_2k",
|
||
"allow_4k": "chat_allow_4k",
|
||
}.items():
|
||
value = _runtime_value(mapping, source_key)
|
||
if value is not None:
|
||
_set_nested(patch, ("chat_access", target_key), value)
|
||
|
||
private_companion = _runtime_value(
|
||
mapping,
|
||
"enable_private_companion_integration",
|
||
fallback=features.get("private_companion_integration", _MISSING),
|
||
)
|
||
if private_companion is not _MISSING:
|
||
_set_nested(patch, ("features", "private_companion_integration"), _runtime_bool(private_companion))
|
||
|
||
backend = _runtime_text(_runtime_value(mapping, "database_backend", fallback=database.get("backend", _MISSING))).lower()
|
||
if backend:
|
||
_set_nested(patch, ("database", "backend"), backend)
|
||
|
||
sqlite_path = _runtime_text(_runtime_value(mapping, "sqlite_path", fallback=sqlite.get("path", _MISSING)))
|
||
if sqlite_path:
|
||
_set_nested(patch, ("database", "sqlite", "path"), sqlite_path)
|
||
|
||
pg_patch: dict[str, Any] = {}
|
||
pg_enabled = _runtime_value(mapping, "postgresql_enabled", fallback=postgresql.get("enabled", _MISSING))
|
||
if pg_enabled is not _MISSING and (_runtime_bool(pg_enabled) or backend == "sqlite"):
|
||
pg_patch["enabled"] = _runtime_bool(pg_enabled)
|
||
elif backend in {"postgresql", "postgres", "pg"}:
|
||
pg_patch["enabled"] = True
|
||
|
||
pg_text_fields = {
|
||
"dsn": ("postgresql_dsn", "dsn"),
|
||
"host": ("postgresql_host", "host"),
|
||
"database": ("postgresql_database", "database"),
|
||
"user": ("postgresql_user", "user"),
|
||
"password": ("postgresql_password", "password"),
|
||
}
|
||
for target_key, (flat_key, nested_key) in pg_text_fields.items():
|
||
value = _runtime_text(_runtime_value(mapping, flat_key, fallback=postgresql.get(nested_key, _MISSING)))
|
||
if value:
|
||
pg_patch[target_key] = value
|
||
|
||
pg_port = _runtime_text(_runtime_value(mapping, "postgresql_port", fallback=postgresql.get("port", _MISSING)))
|
||
if pg_port:
|
||
try:
|
||
pg_patch["port"] = int(pg_port)
|
||
except ValueError:
|
||
pg_patch["port"] = pg_port
|
||
|
||
has_connection_fields = any(key in pg_patch for key in ("dsn", "host", "database", "user", "password"))
|
||
if has_connection_fields and backend != "sqlite" and "enabled" not in pg_patch:
|
||
pg_patch["enabled"] = True
|
||
if pg_patch:
|
||
_set_nested(patch, ("database", "postgresql"), pg_patch)
|
||
return patch
|
||
|
||
|
||
def _runtime_value(mapping: Mapping[str, Any], key: str, *, fallback: Any = _MISSING) -> Any:
|
||
if key in mapping:
|
||
return mapping[key]
|
||
return fallback
|
||
|
||
|
||
def _runtime_text(value: Any) -> str:
|
||
if value is _MISSING or value is None:
|
||
return ""
|
||
return str(value).strip()
|
||
|
||
|
||
def _runtime_bool(value: Any) -> bool:
|
||
if isinstance(value, bool):
|
||
return value
|
||
if isinstance(value, str):
|
||
return value.strip().lower() in {"1", "true", "yes", "on", "enabled", "启用", "是"}
|
||
return bool(value)
|
||
|
||
|
||
def _set_nested(target: dict[str, Any], path: tuple[str, ...], value: Any) -> None:
|
||
current = target
|
||
for key in path[:-1]:
|
||
child = current.get(key)
|
||
if not isinstance(child, dict):
|
||
child = {}
|
||
current[key] = child
|
||
current = child
|
||
current[path[-1]] = value
|
||
|
||
|
||
def _flatten_config_keys(value: Mapping[str, Any], prefix: str = "") -> list[str]:
|
||
keys: list[str] = []
|
||
for key, child in value.items():
|
||
path = f"{prefix}.{key}" if prefix else str(key)
|
||
if isinstance(child, Mapping):
|
||
keys.extend(_flatten_config_keys(child, path))
|
||
else:
|
||
keys.append(path)
|
||
return sorted(keys)
|
||
|
||
|
||
def _call_web_api_registrar(registrar: Callable[..., Any], path: str, handler: Callable[..., Any], method: str) -> bool:
|
||
methods = [method]
|
||
desc = f"ImageStudio {method} {path}"
|
||
attempts = (
|
||
lambda: registrar(route=path, view_handler=handler, methods=methods, desc=desc),
|
||
lambda: registrar(route=path, view_handler=handler, methods=methods),
|
||
lambda: registrar(path=path, handler=handler, methods=methods),
|
||
lambda: registrar(path=path, handler=handler, methods=methods, desc=desc),
|
||
lambda: registrar(path=path, handler=handler, method=method),
|
||
lambda: registrar(endpoint=path, handler=handler, methods=methods),
|
||
lambda: registrar(path, handler, methods, desc),
|
||
lambda: registrar(path, handler, methods=methods),
|
||
lambda: registrar(path, handler, methods=methods, desc=desc),
|
||
lambda: registrar(path, handler, method=method),
|
||
lambda: registrar(path, methods, handler),
|
||
lambda: registrar(path, method, handler),
|
||
lambda: registrar(path, handler),
|
||
)
|
||
last_error: TypeError | None = None
|
||
for attempt in attempts:
|
||
try:
|
||
attempt()
|
||
return True
|
||
except TypeError as exc:
|
||
last_error = exc
|
||
if last_error is not None:
|
||
raise last_error
|
||
return False
|
||
|
||
|
||
def _make_bridge_handler(endpoint: str, method: str) -> Callable[..., Any]:
|
||
async def handler(request: Any | None = None, **kwargs: Any) -> Any:
|
||
positional_endpoint = request if isinstance(request, str) else None
|
||
actual_request = None if positional_endpoint is not None else request or kwargs.get("request")
|
||
actual_request = actual_request or _current_astrbot_web_request()
|
||
actual_endpoint = endpoint or _first_text(
|
||
positional_endpoint,
|
||
kwargs.get("endpoint"),
|
||
kwargs.get("path"),
|
||
kwargs.get("route_path"),
|
||
kwargs.get("wildcard"),
|
||
)
|
||
actual_query = _mapping_from_any(kwargs.get("query") or kwargs.get("params"))
|
||
actual_payload = _mapping_from_any(kwargs.get("payload") or kwargs.get("body") or kwargs.get("data"))
|
||
return await dispatch_bridge_request(
|
||
actual_endpoint,
|
||
method=method,
|
||
request=actual_request,
|
||
query=actual_query or None,
|
||
payload=actual_payload or None,
|
||
)
|
||
|
||
return handler
|
||
|
||
|
||
def _current_astrbot_web_request() -> Any | None:
|
||
try:
|
||
from astrbot.api.web import request as astrbot_web_request
|
||
except Exception:
|
||
astrbot_web_request = None
|
||
if astrbot_web_request is not None:
|
||
try:
|
||
getattr(astrbot_web_request, "method")
|
||
return astrbot_web_request
|
||
except Exception:
|
||
pass
|
||
try:
|
||
from quart import request as quart_request
|
||
getattr(quart_request, "method")
|
||
return quart_request
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def _request_context_from_astrbot_request(request: Any | None) -> RequestContext:
|
||
username = _first_text(
|
||
_attr(request, "username"),
|
||
_current_quart_username(),
|
||
) or None
|
||
user_id = _first_text(
|
||
_attr(request, "user_id"),
|
||
username,
|
||
) or None
|
||
# AstrBot authenticates extension routes before invoking the plugin, but
|
||
# PluginRequest currently exposes only the authenticated username. Grant
|
||
# the capabilities that exist today explicitly instead of a wildcard so a
|
||
# future permission cannot become enabled accidentally.
|
||
permissions = BRIDGE_PERMISSIONS if username or user_id else frozenset()
|
||
return RequestContext.from_astrbot(
|
||
username=username,
|
||
user_id=user_id,
|
||
client_ip=_client_ip(request),
|
||
source="astrbot_plugin_page",
|
||
permissions=permissions,
|
||
)
|
||
|
||
|
||
def _request_method(request: Any | None, *, fallback: str) -> str:
|
||
return (_first_text(_attr(request, "method"), fallback) or "GET").upper()
|
||
|
||
|
||
def _bridge_endpoint(endpoint: str | None, request: Any | None) -> str:
|
||
candidate = _first_text(
|
||
endpoint,
|
||
_mapping_value(_attr(request, "path_params"), "endpoint", "path", "route_path", "wildcard"),
|
||
_mapping_value(_attr(request, "match_info"), "endpoint", "path", "route_path", "wildcard"),
|
||
_attr(request, "path"),
|
||
_nested_attr(request, "url", "path"),
|
||
_attr(request, "rel_url"),
|
||
)
|
||
normalized = str(candidate or "").split("?", 1)[0].replace("\\", "/").strip("/")
|
||
prefixes = (
|
||
f"api/plug/{PLUGIN_NAME}/",
|
||
f"api/v1/plugins/extensions/{PLUGIN_NAME}/",
|
||
f"{API_BASE.strip('/')}/",
|
||
)
|
||
for prefix in prefixes:
|
||
if normalized.startswith(prefix):
|
||
normalized = normalized[len(prefix) :]
|
||
break
|
||
return normalize_extension_path(normalized)
|
||
|
||
|
||
def _request_query(request: Any | None) -> dict[str, Any]:
|
||
for candidate in (
|
||
_attr(request, "query"),
|
||
_attr(request, "query_params"),
|
||
_attr(request, "args"),
|
||
_attr(request, "GET"),
|
||
):
|
||
query = _mapping_from_any(candidate)
|
||
if query:
|
||
return query
|
||
return {}
|
||
|
||
|
||
async def _request_payload(request: Any | None) -> dict[str, Any]:
|
||
if request is None or _request_method(request, fallback="GET") == "GET":
|
||
return {}
|
||
for name in ("json", "get_json"):
|
||
loader = getattr(request, name, None)
|
||
if inspect.isawaitable(loader):
|
||
try:
|
||
loaded = await loader
|
||
except Exception:
|
||
continue
|
||
return _mapping_from_any(loaded)
|
||
payload = _mapping_from_any(loader)
|
||
if payload:
|
||
return payload
|
||
if not callable(loader):
|
||
continue
|
||
try:
|
||
try:
|
||
loaded = loader(default={}) if name == "json" else loader(silent=True)
|
||
except TypeError:
|
||
loaded = loader()
|
||
if inspect.isawaitable(loaded):
|
||
loaded = await loaded
|
||
payload = _mapping_from_any(loaded)
|
||
return payload
|
||
except Exception:
|
||
continue
|
||
body = getattr(request, "body", None)
|
||
if callable(body):
|
||
body = body()
|
||
if inspect.isawaitable(body):
|
||
body = await body
|
||
if isinstance(body, bytes):
|
||
body = body.decode("utf-8")
|
||
if isinstance(body, str) and body.strip():
|
||
try:
|
||
return _mapping_from_any(json.loads(body))
|
||
except json.JSONDecodeError:
|
||
return {}
|
||
return {}
|
||
|
||
|
||
def _unwrap_method_override(method: str, payload: dict[str, Any]) -> tuple[str, dict[str, Any]]:
|
||
normalized_method = str(method or "GET").upper()
|
||
if normalized_method != "POST":
|
||
return normalized_method, payload
|
||
override = str(payload.get("__imagestudio_method") or "").strip().upper()
|
||
if override not in {"PUT", "DELETE", "PATCH"}:
|
||
return normalized_method, payload
|
||
body = payload.get("__imagestudio_body", {})
|
||
return override, _mapping_from_any(body)
|
||
|
||
|
||
def _to_bridge_response(response: dict[str, Any]) -> dict[str, Any]:
|
||
if response.get("ok"):
|
||
return {
|
||
"status": "ok",
|
||
"message": "",
|
||
"data": response.get("data"),
|
||
"request_id": response.get("request_id"),
|
||
}
|
||
return {
|
||
"status": "error",
|
||
"message": str(response.get("message") or "request failed"),
|
||
"data": response,
|
||
"request_id": response.get("request_id"),
|
||
}
|
||
|
||
|
||
def _to_media_http_response(endpoint: str, response: dict[str, Any]) -> Any | None:
|
||
if normalize_extension_path(endpoint) != "media/fetch" or not response.get("ok"):
|
||
return None
|
||
data = _mapping_from_any(response.get("data"))
|
||
encoded = str(data.get("body_base64") or "")
|
||
try:
|
||
body = base64.urlsafe_b64decode(encoded + ("=" * (-len(encoded) % 4)))
|
||
except (binascii.Error, ValueError):
|
||
return None
|
||
content_type = str(data.get("content_type") or "application/octet-stream")
|
||
cache_control = str(data.get("cache_control") or "private, max-age=300")
|
||
headers = {"Cache-Control": cache_control}
|
||
|
||
try:
|
||
from astrbot.api.web import request as _astrbot_request # noqa: F401
|
||
from starlette.responses import Response
|
||
|
||
return Response(content=body, media_type=content_type, headers=headers)
|
||
except Exception:
|
||
pass
|
||
try:
|
||
from quart import Response
|
||
|
||
return Response(body, content_type=content_type, headers=headers)
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
async def _to_media_file_response(query: dict[str, Any]) -> Any | None:
|
||
"""Use AstrBot/Quart native file responses to avoid base64 memory copies."""
|
||
|
||
token = str(query.get("token") or "").strip()
|
||
if not token:
|
||
return None
|
||
try:
|
||
path, metadata = MediaProxy().resolve_file(token)
|
||
except Exception:
|
||
return None
|
||
content_type = str(metadata.get("content_type") or "application/octet-stream")
|
||
headers = {"Cache-Control": "private, max-age=300"}
|
||
try:
|
||
from astrbot.api.web import file_response
|
||
|
||
return file_response(path, content_type=content_type, headers=headers)
|
||
except Exception:
|
||
pass
|
||
try:
|
||
from quart import send_file
|
||
|
||
response = send_file(path, mimetype=content_type, conditional=True, max_age=300)
|
||
if inspect.isawaitable(response):
|
||
response = await response
|
||
response.headers["Cache-Control"] = headers["Cache-Control"]
|
||
return response
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def _mapping_from_any(value: Any) -> dict[str, Any]:
|
||
if value is None:
|
||
return {}
|
||
if isinstance(value, dict):
|
||
return dict(value)
|
||
if hasattr(value, "items"):
|
||
return {str(key): item for key, item in value.items()}
|
||
return {}
|
||
|
||
|
||
def _mapping_value(value: Any, *keys: str) -> Any:
|
||
mapping = _mapping_from_any(value)
|
||
for key in keys:
|
||
if key in mapping:
|
||
return mapping[key]
|
||
return None
|
||
|
||
|
||
def _attr(value: Any, name: str) -> Any:
|
||
if value is None:
|
||
return None
|
||
try:
|
||
return getattr(value, name, None)
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def _nested_attr(value: Any, *names: str) -> Any:
|
||
current = value
|
||
for name in names:
|
||
current = _attr(current, name)
|
||
if current is None:
|
||
return None
|
||
return current
|
||
|
||
|
||
def _first_text(*values: Any) -> str:
|
||
for value in values:
|
||
if value is None:
|
||
continue
|
||
text = str(value).strip()
|
||
if text:
|
||
return text
|
||
return ""
|
||
|
||
|
||
def _current_quart_username() -> str:
|
||
try:
|
||
from quart import g
|
||
|
||
return _first_text(getattr(g, "username", None))
|
||
except Exception:
|
||
return ""
|
||
|
||
|
||
def _client_ip(request: Any | None) -> str | None:
|
||
client_host = _attr(request, "client_host")
|
||
if client_host:
|
||
return str(client_host)
|
||
remote_addr = _attr(request, "remote_addr")
|
||
if remote_addr:
|
||
return str(remote_addr)
|
||
client = _attr(request, "client")
|
||
host = _attr(client, "host")
|
||
if host:
|
||
return str(host)
|
||
remote = _attr(request, "remote")
|
||
return str(remote) if remote else None
|