484 行
20 KiB
Python
484 行
20 KiB
Python
"""Workflow node route handlers."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from uuid import uuid4
|
|
|
|
from backend.dto.common import ApiError, ErrorCode
|
|
from backend.routes.common import handle_request
|
|
from backend.services.event_stream_service import get_default_event_bus
|
|
from backend.services.cost_guard_service import CostGuardService
|
|
from backend.services.cost_service import CostService
|
|
from backend.services.generation_service import GenerationService
|
|
from backend.services.image_service import ImageService
|
|
from backend.services.model_provider_runtime import ModelProviderRuntime
|
|
from core.astrbot_provider_bridge import astrbot_structured_text_callable
|
|
from backend.services.model_provider_bootstrap import sync_generation_provider_from_config
|
|
from backend.services.model_provider_service import ModelProviderService
|
|
from backend.services.node_dependency_context_service import NodeDependencyContextService
|
|
from backend.services.prompt_expansion_service import PromptExpansionService
|
|
from backend.services.prompt_governance_service import (
|
|
GenerationRouteService,
|
|
ImageModerationService,
|
|
PromptModerationService,
|
|
PromptSemanticNormalizer,
|
|
PromptTranslationService,
|
|
)
|
|
from backend.services.queue_service import QueueService
|
|
from backend.services.workflow_service import (
|
|
LOCKED_NODE_STATUSES,
|
|
WorkflowService,
|
|
is_repeatable_single_image_node,
|
|
locked_node_edit_error,
|
|
)
|
|
from backend.services.workflow_material_snapshot_service import WorkflowMaterialSnapshotService
|
|
from core.audit_service import AuditService
|
|
from core.identity import RequestContext
|
|
from engines.character_flow import canonical_gradual_node_key
|
|
from core.security import require_authenticated, require_task_retry, require_write
|
|
from database.db_helper import Database, load_config_payload, load_database_settings
|
|
from database.repositories.image_repository import ImageRepository
|
|
from database.repositories.job_repository import JobRepository
|
|
from database.repositories.material_repository import MaterialRepository
|
|
from database.repositories.model_provider_repository import ModelProviderRepository
|
|
from database.repositories.profile_repository import ProfileRepository
|
|
from database.repositories.workflow_repository import WorkflowRepository
|
|
from engines.single_flow import SingleFlowEngine
|
|
|
|
|
|
def list_workflow_nodes(
|
|
ctx: RequestContext,
|
|
workflow_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> list[dict[str, Any]]:
|
|
require_authenticated(ctx)
|
|
return [node.to_dict() for node in workflow_service.list_nodes(workflow_id)]
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def create_workflow_node(
|
|
ctx: RequestContext,
|
|
workflow_id: str,
|
|
payload: dict[str, Any],
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return workflow_service.create_node(workflow_id, payload, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def get_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_authenticated(ctx)
|
|
return workflow_service.get_node(node_id).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def get_node_dependency_context(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
query: dict[str, Any] | None = None,
|
|
service: NodeDependencyContextService | None = None,
|
|
workflow_service: WorkflowService | None = None,
|
|
image_service: ImageService | None = None,
|
|
) -> dict:
|
|
params = query or {}
|
|
if service:
|
|
context_service = service
|
|
else:
|
|
resolved_image_service, resolved_workflow_service = _resolve_services(image_service, workflow_service)
|
|
context_service = NodeDependencyContextService(resolved_workflow_service, resolved_image_service)
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_authenticated(ctx)
|
|
return context_service.get_context(node_id, include_draft=_bool(params.get("include_draft")))
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def update_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any],
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return workflow_service.update_node(node_id, payload, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def generate_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowService | None = None,
|
|
generation_service: GenerationService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
resolved_generation_service = generation_service or (None if service else _create_generation_service())
|
|
request_payload = payload or {}
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
if resolved_generation_service:
|
|
return resolved_generation_service.generate_node(node_id, request_payload, ctx)
|
|
update_payload: dict[str, Any] = {
|
|
"status": "queued",
|
|
"metadata": {
|
|
"last_generate_request": request_payload,
|
|
"queue_placeholder": True,
|
|
},
|
|
}
|
|
if "model_route" in request_payload:
|
|
update_payload["model_route"] = request_payload["model_route"]
|
|
node = workflow_service.update_node(node_id, update_payload, ctx)
|
|
return {
|
|
"task_id": None,
|
|
"request_id": f"genreq_{uuid4().hex}",
|
|
"node_status": node.status,
|
|
"queue_placeholder": True,
|
|
}
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def retry_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowService | None = None,
|
|
generation_service: GenerationService | None = None,
|
|
) -> dict:
|
|
resolved_generation_service = generation_service
|
|
if resolved_generation_service is None and service is None:
|
|
resolved_generation_service = _create_generation_service()
|
|
workflow_service = (
|
|
service
|
|
or getattr(resolved_generation_service, "workflow_service", None)
|
|
or _create_workflow_service()
|
|
)
|
|
request_overrides = payload or {}
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_task_retry(ctx)
|
|
node = workflow_service.get_node(node_id)
|
|
workflow_service.ensure_node_action_allowed(node_id, "retry", node=node)
|
|
if node.status in LOCKED_NODE_STATUSES and not is_repeatable_single_image_node(node):
|
|
raise locked_node_edit_error(node)
|
|
if node.status not in _RETRYABLE_NODE_STATUSES and not (
|
|
node.status in LOCKED_NODE_STATUSES and is_repeatable_single_image_node(node)
|
|
):
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"node cannot be retried from its current status",
|
|
{
|
|
"node_id": node.node_id,
|
|
"status": node.status,
|
|
"allowed_statuses": sorted(_RETRYABLE_NODE_STATUSES),
|
|
},
|
|
)
|
|
metadata = node.metadata if isinstance(node.metadata, dict) else {}
|
|
last_request = metadata.get("last_generate_request")
|
|
if not isinstance(last_request, dict) or not last_request:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"node has no previous generation request to retry",
|
|
{
|
|
"node_id": node.node_id,
|
|
"status": node.status,
|
|
"field": "metadata.last_generate_request",
|
|
},
|
|
)
|
|
if resolved_generation_service is None:
|
|
raise ApiError(
|
|
ErrorCode.UNKNOWN_ERROR,
|
|
"generation service is unavailable for node retry",
|
|
{"node_id": node.node_id},
|
|
)
|
|
retry_request = _build_retry_generation_request(node.node_id, last_request, request_overrides)
|
|
return resolved_generation_service.generate_node(node.node_id, retry_request, ctx)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def select_node_image(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any],
|
|
image_service: ImageService | None = None,
|
|
workflow_service: WorkflowService | None = None,
|
|
) -> dict:
|
|
selected_image_service, selected_workflow_service = _resolve_services(image_service, workflow_service)
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
selected_workflow_service.get_node(node_id)
|
|
image_id = str(payload.get("image_id") or "").strip()
|
|
if not image_id:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "image_id is required", {"field": "image_id"})
|
|
image = selected_image_service.get_image(image_id)
|
|
if image.node_id != node_id:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"image does not belong to this node",
|
|
{"image_id": image_id, "node_id": node_id},
|
|
)
|
|
return selected_image_service.select_image(image_id, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def mark_node_completed(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
node = workflow_service.get_node(node_id)
|
|
if (
|
|
node.node_type in {"generation", "single_image"}
|
|
and canonical_gradual_node_key(node.node_key) != "profile_card"
|
|
):
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"generation nodes must be completed by confirming an image candidate",
|
|
{
|
|
"reason": "generation_node_requires_candidate_adoption",
|
|
"node_id": node.node_id,
|
|
"node_key": node.node_key,
|
|
"required_action": "adopt_image",
|
|
},
|
|
)
|
|
return workflow_service.update_node(node_id, {"status": "completed"}, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def _resolve_services(
|
|
image_service: ImageService | None,
|
|
workflow_service: WorkflowService | None,
|
|
) -> tuple[ImageService, WorkflowService]:
|
|
if image_service and workflow_service:
|
|
return image_service, workflow_service
|
|
database = Database(load_database_settings())
|
|
audit_service = AuditService(database)
|
|
event_bus = get_default_event_bus()
|
|
resolved_workflow_service = workflow_service or WorkflowService(
|
|
workflow_repository=WorkflowRepository(database),
|
|
profile_repository=ProfileRepository(database),
|
|
audit_service=audit_service,
|
|
event_bus=event_bus,
|
|
)
|
|
resolved_image_service = image_service or ImageService(
|
|
image_repository=ImageRepository(database),
|
|
workflow_repository=WorkflowRepository(database),
|
|
audit_service=audit_service,
|
|
)
|
|
return resolved_image_service, resolved_workflow_service
|
|
|
|
|
|
def _create_workflow_service() -> WorkflowService:
|
|
database = Database(load_database_settings())
|
|
return WorkflowService(
|
|
workflow_repository=WorkflowRepository(database),
|
|
profile_repository=ProfileRepository(database),
|
|
audit_service=AuditService(database),
|
|
event_bus=get_default_event_bus(),
|
|
)
|
|
|
|
|
|
def _create_generation_service() -> GenerationService:
|
|
database = Database(load_database_settings())
|
|
audit_service = AuditService(database)
|
|
workflow_repository = WorkflowRepository(database)
|
|
material_repository = MaterialRepository(database)
|
|
event_bus = get_default_event_bus()
|
|
model_provider_service = ModelProviderService(ModelProviderRepository(database))
|
|
model_provider_runtime = ModelProviderRuntime(model_provider_service)
|
|
config_payload = load_config_payload()
|
|
sync_generation_provider_from_config(model_provider_service, config_payload)
|
|
generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {}
|
|
model_assignments = config_payload.get("model_assignments") if isinstance(config_payload.get("model_assignments"), dict) else {}
|
|
governance_config = config_payload.get("prompt_governance") if isinstance(config_payload.get("prompt_governance"), dict) else {}
|
|
translation_config = governance_config.get("translation") if isinstance(governance_config.get("translation"), dict) else {}
|
|
moderation_config = governance_config.get("moderation") if isinstance(governance_config.get("moderation"), dict) else {}
|
|
routing_config = governance_config.get("routing") if isinstance(governance_config.get("routing"), dict) else {}
|
|
image_moderation_config = governance_config.get("image_moderation") if isinstance(governance_config.get("image_moderation"), dict) else {}
|
|
translation_route = str(translation_config.get("model_route") or model_assignments.get("prompt_planning") or "").strip()
|
|
moderation_route = str(moderation_config.get("model_route") or model_assignments.get("cross_review_primary") or "").strip()
|
|
translation_callable = (model_provider_runtime.structured_text_callable(translation_route) or astrbot_structured_text_callable(translation_route)) if translation_route else None
|
|
moderation_callable = (model_provider_runtime.structured_text_callable(moderation_route) or astrbot_structured_text_callable(moderation_route)) if moderation_route else None
|
|
single_flow_engine = SingleFlowEngine(
|
|
image_provider_factory=model_provider_runtime.image_provider_for_route,
|
|
allow_mock_fallback=False,
|
|
)
|
|
image_moderation_route = str(image_moderation_config.get("model_route") or "").strip()
|
|
image_moderation_callable = model_provider_runtime.structured_vision_callable(
|
|
image_moderation_route,
|
|
storage=single_flow_engine.storage,
|
|
) if image_moderation_route else None
|
|
if translation_callable:
|
|
raw_translation_callable = translation_callable
|
|
translation_callable = lambda request: raw_translation_callable({**request, "purpose": "Chinese-to-English image prompt translation and structured visual decomposition"})
|
|
if moderation_callable:
|
|
raw_moderation_callable = moderation_callable
|
|
moderation_callable = lambda request: raw_moderation_callable({**request, "purpose": "image prompt content risk classification"})
|
|
return GenerationService(
|
|
workflow_service=WorkflowService(
|
|
workflow_repository=workflow_repository,
|
|
profile_repository=ProfileRepository(database),
|
|
audit_service=audit_service,
|
|
event_bus=event_bus,
|
|
),
|
|
queue_service=QueueService(
|
|
repository=JobRepository(database),
|
|
audit_service=audit_service,
|
|
event_bus=event_bus,
|
|
),
|
|
image_service=ImageService(
|
|
image_repository=ImageRepository(database),
|
|
workflow_repository=workflow_repository,
|
|
audit_service=audit_service,
|
|
),
|
|
single_flow_engine=single_flow_engine,
|
|
model_provider_service=model_provider_service,
|
|
cost_guard_service=CostGuardService(CostService(database)),
|
|
prompt_expansion_service=PromptExpansionService(),
|
|
event_bus=event_bus,
|
|
default_model_route=str(generation_config.get("default_model") or "").strip() or None,
|
|
require_resolved_model_route=True,
|
|
material_resolver=material_repository,
|
|
material_snapshot_service=WorkflowMaterialSnapshotService(
|
|
workflow_repository,
|
|
material_repository,
|
|
),
|
|
model_assignments=model_assignments,
|
|
prompt_translation_service=PromptTranslationService(translation_config, translation_callable),
|
|
prompt_semantic_normalizer=PromptSemanticNormalizer(),
|
|
prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable),
|
|
generation_route_service=GenerationRouteService(routing_config),
|
|
image_moderation_service=ImageModerationService(image_moderation_config, image_moderation_callable),
|
|
)
|
|
|
|
|
|
def create_generation_service() -> GenerationService:
|
|
"""Public runtime factory shared by HTTP routes and background workers."""
|
|
|
|
return _create_generation_service()
|
|
|
|
|
|
def _bool(value: Any) -> bool:
|
|
if isinstance(value, str):
|
|
return value.strip().lower() in {"1", "true", "yes", "on"}
|
|
return bool(value)
|
|
|
|
|
|
_RETRYABLE_NODE_STATUSES = frozenset({"failed", "cancelled", "skipped"})
|
|
_RETRY_DERIVED_REQUEST_FIELDS = frozenset(
|
|
{
|
|
"cost_guard",
|
|
"expanded_negative_prompt",
|
|
"expanded_prompt",
|
|
"prompt_expansion",
|
|
"reference_persistence",
|
|
"resolved_model_route",
|
|
}
|
|
)
|
|
|
|
|
|
def _build_retry_generation_request(
|
|
node_id: str,
|
|
last_request: dict[str, Any],
|
|
overrides: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
omitted_references = _ephemeral_reference_count(last_request)
|
|
if omitted_references and not _has_reference_override(overrides):
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"the previous generation used inline reference images; provide replacement references before retrying",
|
|
{
|
|
"node_id": node_id,
|
|
"ephemeral_data_urls_omitted": omitted_references,
|
|
"required_fields": ["input_images", "image", "selected_draft_image_ids", "stage_inputs"],
|
|
},
|
|
)
|
|
request = {
|
|
key: value
|
|
for key, value in last_request.items()
|
|
if key not in _RETRY_DERIVED_REQUEST_FIELDS and key != "idempotency_key"
|
|
}
|
|
for key, value in overrides.items():
|
|
if key not in _RETRY_DERIVED_REQUEST_FIELDS and key != "idempotency_key":
|
|
request[key] = value
|
|
|
|
previous_metadata = last_request.get("metadata")
|
|
override_metadata = overrides.get("metadata")
|
|
if isinstance(previous_metadata, dict) or isinstance(override_metadata, dict):
|
|
request["metadata"] = {
|
|
**(previous_metadata if isinstance(previous_metadata, dict) else {}),
|
|
**(override_metadata if isinstance(override_metadata, dict) else {}),
|
|
}
|
|
request["idempotency_key"] = f"node-retry-{node_id}-{uuid4().hex}"
|
|
return request
|
|
|
|
|
|
def _ephemeral_reference_count(request: dict[str, Any]) -> int:
|
|
persistence = request.get("reference_persistence")
|
|
if not isinstance(persistence, dict):
|
|
return 0
|
|
try:
|
|
return max(int(persistence.get("ephemeral_data_urls_omitted") or 0), 0)
|
|
except (TypeError, ValueError):
|
|
return 0
|
|
|
|
|
|
def _has_reference_override(payload: dict[str, Any]) -> bool:
|
|
for key in ("input_images", "image", "selected_draft_image_ids", "stage_inputs"):
|
|
if _has_nonempty_value(payload.get(key)):
|
|
return True
|
|
metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
|
|
dependency = payload.get("dependency_context") if isinstance(payload.get("dependency_context"), dict) else {}
|
|
return any(
|
|
_has_nonempty_value(value)
|
|
for value in (
|
|
metadata.get("selected_draft_image_ids"),
|
|
metadata.get("stage_inputs"),
|
|
dependency.get("selected_image_ids"),
|
|
dependency.get("selected_draft_image_ids"),
|
|
dependency.get("stage_inputs"),
|
|
dependency.get("material_bindings"),
|
|
)
|
|
)
|
|
|
|
|
|
def _has_nonempty_value(value: Any) -> bool:
|
|
if value is None:
|
|
return False
|
|
if isinstance(value, str):
|
|
return bool(value.strip())
|
|
if isinstance(value, (list, tuple, dict, set)):
|
|
return bool(value)
|
|
return True
|