"""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 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.queue_service import QueueService from backend.services.workflow_service import ( LOCKED_NODE_STATUSES, WorkflowService, is_repeatable_single_image_node, locked_node_edit_error, ) from core.audit_service import AuditService from core.identity import RequestContext 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) 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) 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) 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 {} 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=SingleFlowEngine( image_provider_factory=model_provider_runtime.image_provider_for_route, allow_mock_fallback=False, ), 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=MaterialRepository(database), ) 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