1262 行
56 KiB
Python
1262 行
56 KiB
Python
"""Generation orchestration service."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
from typing import Any
|
|
|
|
from backend.dto.common import ApiError, ErrorCode
|
|
from backend.dto.job_dto import GenerationTask
|
|
from backend.services.cost_guard_service import CostGuardService
|
|
from backend.services.composition_builder import CompositionBuilder
|
|
from backend.services.generation_reference_service import GenerationReferenceService, MaterialResolver
|
|
from backend.services.image_service import ImageService
|
|
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 (
|
|
GenerationFailureClassifier,
|
|
GenerationRouteService,
|
|
ImageModerationService,
|
|
PromptModerationService,
|
|
PromptSemanticNormalizer,
|
|
PromptTranslationService,
|
|
)
|
|
from backend.services.queue_service import QueueService
|
|
from backend.services.reference_binding_mapper import ReferenceBindingMapper
|
|
from backend.services.workflow_service import (
|
|
LOCKED_NODE_STATUSES,
|
|
WorkflowService,
|
|
is_repeatable_single_image_node,
|
|
locked_node_edit_error,
|
|
)
|
|
from core.event_bus import EventBus
|
|
from core.generation_errors import provider_failure_attribution
|
|
from core.identity import RequestContext
|
|
from engines.image_provider import ImageProviderError
|
|
from engines.single_flow import SingleFlowEngine
|
|
|
|
|
|
_NODE_GENERATION_LOCKS_GUARD = threading.Lock()
|
|
_NODE_GENERATION_LOCKS: dict[str, "_NodeGenerationLock"] = {}
|
|
|
|
|
|
class _NodeGenerationLock:
|
|
def __init__(self):
|
|
self.lock = threading.RLock()
|
|
self.users = 0
|
|
|
|
|
|
class GenerationService:
|
|
def __init__(
|
|
self,
|
|
workflow_service: WorkflowService,
|
|
queue_service: QueueService,
|
|
image_service: ImageService,
|
|
single_flow_engine: SingleFlowEngine | None = None,
|
|
model_provider_service: ModelProviderService | None = None,
|
|
cost_guard_service: CostGuardService | None = None,
|
|
prompt_expansion_service: PromptExpansionService | None = None,
|
|
event_bus: EventBus | None = None,
|
|
default_model_route: str | None = None,
|
|
require_resolved_model_route: bool = False,
|
|
material_resolver: MaterialResolver | None = None,
|
|
model_assignments: dict[str, Any] | None = None,
|
|
prompt_translation_service: PromptTranslationService | None = None,
|
|
prompt_semantic_normalizer: PromptSemanticNormalizer | None = None,
|
|
prompt_moderation_service: PromptModerationService | None = None,
|
|
generation_route_service: GenerationRouteService | None = None,
|
|
generation_failure_classifier: GenerationFailureClassifier | None = None,
|
|
image_moderation_service: ImageModerationService | None = None,
|
|
reference_binding_mapper: ReferenceBindingMapper | None = None,
|
|
composition_builder: CompositionBuilder | None = None,
|
|
):
|
|
self.workflow_service = workflow_service
|
|
self.queue_service = queue_service
|
|
self.image_service = image_service
|
|
self.single_flow_engine = single_flow_engine or SingleFlowEngine()
|
|
self.reference_service = GenerationReferenceService(
|
|
image_service,
|
|
self.single_flow_engine.storage,
|
|
material_resolver,
|
|
)
|
|
self.model_provider_service = model_provider_service
|
|
self.cost_guard_service = cost_guard_service
|
|
self.prompt_expansion_service = prompt_expansion_service
|
|
self.event_bus = event_bus
|
|
self.default_model_route = _optional_text(default_model_route)
|
|
self.model_assignments = dict(model_assignments or {})
|
|
self.require_resolved_model_route = require_resolved_model_route
|
|
self.prompt_translation_service = prompt_translation_service
|
|
self.prompt_semantic_normalizer = prompt_semantic_normalizer
|
|
self.prompt_moderation_service = prompt_moderation_service
|
|
self.generation_route_service = generation_route_service
|
|
self.generation_failure_classifier = generation_failure_classifier or GenerationFailureClassifier()
|
|
self.image_moderation_service = image_moderation_service
|
|
self.reference_binding_mapper = reference_binding_mapper or ReferenceBindingMapper()
|
|
self.composition_builder = composition_builder or CompositionBuilder()
|
|
self.material_resolver = material_resolver
|
|
|
|
def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
|
|
lock_entry = _retain_node_generation_lock(node_id)
|
|
lock_entry.lock.acquire()
|
|
try:
|
|
return self._generate_node_locked(node_id, payload, ctx)
|
|
finally:
|
|
lock_entry.lock.release()
|
|
_release_node_generation_lock(node_id, lock_entry)
|
|
|
|
def _generate_node_locked(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
|
|
node = self.workflow_service.get_node(node_id)
|
|
idempotency_key = _optional_text(payload.get("idempotency_key"))
|
|
if idempotency_key:
|
|
existing_task = self.queue_service.get_job_by_idempotency_key(idempotency_key)
|
|
if existing_task is not None:
|
|
if existing_task.node_id != node_id:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"idempotency_key belongs to another node",
|
|
{
|
|
"idempotency_key": idempotency_key,
|
|
"node_id": node_id,
|
|
"existing_node_id": existing_task.node_id,
|
|
},
|
|
)
|
|
return self._existing_generation_response(existing_task, node_id)
|
|
active_task = self._active_generation_task(node)
|
|
if node.status in {"queued", "running"} and active_task is not None:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"generation is already in progress for this node",
|
|
{
|
|
"node_id": node_id,
|
|
"status": node.status,
|
|
"last_task_id": active_task.task_id,
|
|
"task_status": active_task.status,
|
|
},
|
|
)
|
|
if node.status in LOCKED_NODE_STATUSES and not is_repeatable_single_image_node(node):
|
|
raise locked_node_edit_error(node)
|
|
workflow = self.workflow_service.get_workflow(node.workflow_id).workflow
|
|
if workflow.status == "cancelled":
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"generation cannot start for a cancelled workflow",
|
|
{"workflow_id": workflow.workflow_id, "status": workflow.status},
|
|
)
|
|
profile = self.workflow_service.profile_repository.get(workflow.profile_id)
|
|
profile_model_route = _optional_text(getattr(profile, "default_model_route", None))
|
|
assigned_route = _optional_text(self.model_assignments.get(_assignment_key(node)))
|
|
requested_model_route = str(
|
|
payload.get("model_route")
|
|
or node.model_route
|
|
or assigned_route
|
|
or profile_model_route
|
|
or self.default_model_route
|
|
or "image_low"
|
|
)
|
|
enriched_payload = self._enrich_generation_payload(node.node_id, payload)
|
|
prompt_expansion = self._expand_prompt(workflow.profile_id, node, enriched_payload)
|
|
governance = self._govern_prompt(
|
|
node=node,
|
|
payload=enriched_payload,
|
|
prompt_expansion=prompt_expansion,
|
|
requested_route=requested_model_route,
|
|
ctx=ctx,
|
|
)
|
|
model_route = governance["route_decision"]["selected_route"] if governance else requested_model_route
|
|
if governance and governance.get("prompt"):
|
|
prompt_expansion = {
|
|
**(prompt_expansion or {}),
|
|
"prompt": governance["prompt"],
|
|
"negative_prompt": governance.get("negative_prompt") or (prompt_expansion or {}).get("negative_prompt", ""),
|
|
"governance": governance,
|
|
}
|
|
route_resolution = self._resolve_model_route(model_route)
|
|
if governance:
|
|
excluded_fallback = _optional_text(governance.get("route_decision", {}).get("fallback_route"))
|
|
if excluded_fallback and excluded_fallback != model_route:
|
|
route_resolution["excluded_fallback_routes"] = [excluded_fallback]
|
|
if self.require_resolved_model_route and route_resolution.get("status") != "resolved":
|
|
raise ApiError(
|
|
ErrorCode.MODEL_CAPABILITY_UNCONFIRMED,
|
|
"未找到可用的生图模型路由,请先在模型配置中完成提供商与路由设置",
|
|
{"model_route": model_route, "resolution": route_resolution},
|
|
)
|
|
reference_mapping = self.reference_binding_mapper.map(_reference_binding_summary(enriched_payload), route_resolution)
|
|
if reference_mapping["text_constraints"]:
|
|
base_prompt = _optional_text((prompt_expansion or {}).get("prompt")) or _optional_text(getattr(node, "prompt", None)) or ""
|
|
prompt_expansion = {
|
|
**(prompt_expansion or {}),
|
|
"prompt": ", ".join([base_prompt, *reference_mapping["text_constraints"]]),
|
|
"negative_prompt": _optional_text((prompt_expansion or {}).get("negative_prompt")) or "",
|
|
"reference_binding_mapping": reference_mapping,
|
|
}
|
|
cost_guard = self._check_cost_budget(payload, model_route, route_resolution)
|
|
reference_images = self.reference_service.resolve(workflow.workflow_id, enriched_payload)
|
|
runtime_generation_request = {
|
|
**payload,
|
|
"model_route": model_route,
|
|
"resolved_model_route": route_resolution,
|
|
**({"cost_guard": cost_guard} if cost_guard else {}),
|
|
**({"prompt_governance": governance} if governance else {}),
|
|
"reference_binding_mapping": reference_mapping,
|
|
**(
|
|
{
|
|
"prompt_expansion": prompt_expansion,
|
|
"expanded_prompt": prompt_expansion["prompt"],
|
|
"expanded_negative_prompt": prompt_expansion["negative_prompt"],
|
|
}
|
|
if prompt_expansion
|
|
else {}
|
|
),
|
|
}
|
|
generation_request, ephemeral_reference_count = _strip_ephemeral_image_data_urls(runtime_generation_request)
|
|
if ephemeral_reference_count:
|
|
generation_request["reference_persistence"] = {
|
|
"ephemeral_data_urls_omitted": ephemeral_reference_count,
|
|
}
|
|
task = self.queue_service.create_task(
|
|
{
|
|
"profile_id": workflow.profile_id,
|
|
"workflow_id": workflow.workflow_id,
|
|
"node_id": node_id,
|
|
"status": "queued",
|
|
"model_route": model_route,
|
|
"idempotency_key": idempotency_key,
|
|
"request": generation_request,
|
|
"metadata": {
|
|
"source": "nodes.generate",
|
|
"model_route_resolution": route_resolution,
|
|
**({"prompt_governance": _governance_audit_summary(governance)} if governance else {}),
|
|
},
|
|
},
|
|
ctx,
|
|
)
|
|
self._publish(
|
|
"generation.node_queued",
|
|
{"workflow_id": workflow.workflow_id, "node_id": node_id, "task_id": task.task_id},
|
|
)
|
|
queued_metadata = {
|
|
**node.metadata,
|
|
"last_task_id": task.task_id,
|
|
"last_generate_request": generation_request,
|
|
}
|
|
execution_metadata = queued_metadata.get("execution")
|
|
if isinstance(execution_metadata, dict) and execution_metadata.get("prepared_only") is True:
|
|
queued_metadata["execution"] = {
|
|
**execution_metadata,
|
|
"prepared_only": False,
|
|
"task_id": task.task_id,
|
|
}
|
|
queued_node_payload = {
|
|
"status": "queued",
|
|
"model_route": model_route,
|
|
"metadata": queued_metadata,
|
|
}
|
|
try:
|
|
self._queue_generation_node(node, queued_node_payload, ctx)
|
|
except Exception:
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=[],
|
|
images=[],
|
|
ctx=ctx,
|
|
)
|
|
try:
|
|
self.queue_service.update_task_if_status(
|
|
task.task_id,
|
|
{"queued"},
|
|
{
|
|
"status": "failed",
|
|
"progress": 100,
|
|
"error_message": "node could not enter the generation queue",
|
|
},
|
|
ctx,
|
|
)
|
|
except Exception:
|
|
pass
|
|
raise
|
|
running_task = self.queue_service.update_task_if_status(
|
|
task.task_id,
|
|
{"queued"},
|
|
{"status": "running", "progress": 20},
|
|
ctx,
|
|
require_workflow_not_cancelled=True,
|
|
)
|
|
if running_task is None:
|
|
current_task = self.queue_service.get_job(task.task_id)
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=[],
|
|
images=[],
|
|
ctx=ctx,
|
|
)
|
|
raise ApiError(
|
|
ErrorCode.GENERATION_FAILED,
|
|
"generation task changed before provider execution",
|
|
{"task_id": task.task_id, "status": current_task.status},
|
|
)
|
|
task = running_task
|
|
running_node = self.workflow_service.update_node(node_id, {"status": "running"}, ctx)
|
|
self._publish(
|
|
"generation.node_running",
|
|
{"workflow_id": workflow.workflow_id, "node_id": node_id, "task_id": task.task_id},
|
|
)
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=[],
|
|
images=[],
|
|
ctx=ctx,
|
|
)
|
|
assets: list[Any] = []
|
|
images: list[Any] = []
|
|
restricted_images: list[Any] = []
|
|
try:
|
|
runtime_generation_request = {
|
|
**runtime_generation_request,
|
|
"input_images": reference_images,
|
|
}
|
|
runtime_generation_request.pop("image", None)
|
|
try:
|
|
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
|
|
except ImageProviderError as exc:
|
|
fallback = self._content_safety_fallback(
|
|
exc=exc,
|
|
runtime_request=runtime_generation_request,
|
|
governance=governance,
|
|
requested_route=requested_model_route,
|
|
ctx=ctx,
|
|
)
|
|
if fallback is None:
|
|
raise
|
|
runtime_generation_request = fallback["request"]
|
|
route_resolution = fallback["route_resolution"]
|
|
model_route = fallback["model_route"]
|
|
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=assets,
|
|
images=images,
|
|
ctx=ctx,
|
|
)
|
|
precomputed_moderation: dict[str, dict[str, Any]] = {}
|
|
if self.image_moderation_service:
|
|
for asset in assets:
|
|
preview_payload = {
|
|
"image_uri": asset.image_uri,
|
|
"thumbnail_uri": asset.thumbnail_uri,
|
|
"positive_prompt": asset.positive_prompt,
|
|
"negative_prompt": asset.negative_prompt,
|
|
"model_route": asset.model_route,
|
|
}
|
|
precomputed_moderation[asset.image_uri] = self._moderate_generated_image(preview_payload, governance, model_route)
|
|
if any(item.get("action") == "regenerate" for item in precomputed_moderation.values()) and not runtime_generation_request.get("post_moderation_regeneration"):
|
|
self._cleanup_generation_outputs(assets=assets, images=[])
|
|
retry_seed = int(runtime_generation_request.get("seed") or 1000) + 1
|
|
runtime_generation_request = {**runtime_generation_request, "seed": retry_seed, "post_moderation_regeneration": {"attempted": True, "reason": "image_moderation"}}
|
|
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
|
|
precomputed_moderation = {}
|
|
for asset in assets:
|
|
image_payload = {
|
|
"profile_id": workflow.profile_id,
|
|
"workflow_id": workflow.workflow_id,
|
|
"node_id": node_id,
|
|
"task_id": task.task_id,
|
|
"image_uri": asset.image_uri,
|
|
"thumbnail_uri": asset.thumbnail_uri,
|
|
"positive_prompt": asset.positive_prompt,
|
|
"negative_prompt": asset.negative_prompt,
|
|
"model_route": asset.model_route,
|
|
"seed": asset.seed,
|
|
"width": asset.width,
|
|
"height": asset.height,
|
|
# Keep records unselected until the task completion CAS
|
|
# wins. A concurrent cancellation can then roll them
|
|
# back without disturbing an older selected image.
|
|
"is_selected": False,
|
|
"metadata": {
|
|
**asset.metadata,
|
|
**({"prompt_governance": _governance_audit_summary(governance)} if governance else {}),
|
|
"reference_binding_mapping": runtime_generation_request.get("reference_binding_mapping") or {},
|
|
},
|
|
}
|
|
moderation = precomputed_moderation.get(asset.image_uri) or self._moderate_generated_image(image_payload, governance, model_route)
|
|
self._apply_restoration_feedback(moderation)
|
|
image_payload["metadata"] = {**image_payload["metadata"], "image_moderation": moderation}
|
|
if moderation.get("action") in {"quarantine", "reject", "regenerate"}:
|
|
image_payload["metadata"]["quarantined"] = True
|
|
image_payload["metadata"]["gallery_visibility"] = "restricted"
|
|
created_image = self.image_service.create_image(image_payload, ctx)
|
|
if moderation.get("action") in {"quarantine", "reject", "regenerate"}:
|
|
restricted_images.append(created_image)
|
|
else:
|
|
images.append(created_image)
|
|
except Exception as exc:
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=assets,
|
|
images=images,
|
|
ctx=ctx,
|
|
)
|
|
self._cleanup_generation_outputs(assets=assets, images=[*images, *restricted_images])
|
|
failure = self._record_generation_failure(
|
|
task=task,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
route_resolution=route_resolution,
|
|
exc=exc,
|
|
ctx=ctx,
|
|
)
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=assets,
|
|
images=images,
|
|
ctx=ctx,
|
|
)
|
|
if isinstance(exc, ApiError):
|
|
raise
|
|
raise ApiError(
|
|
ErrorCode.GENERATION_FAILED,
|
|
"图像生成失败",
|
|
failure,
|
|
) from exc
|
|
provider_failure = _provider_failure_from_assets([asset.metadata for asset in assets])
|
|
result: dict[str, Any] = {"image_ids": [image.image_id for image in images]}
|
|
if restricted_images:
|
|
result["restricted_image_ids"] = [image.image_id for image in restricted_images]
|
|
result["image_moderation"] = "restricted"
|
|
update_payload: dict[str, Any] = {
|
|
"status": "succeeded",
|
|
"progress": 100,
|
|
"result": result,
|
|
}
|
|
if provider_failure:
|
|
result["provider_failure"] = provider_failure
|
|
update_payload["metadata"] = {**task.metadata, "provider_failure": provider_failure}
|
|
completed_task = self.queue_service.update_task_if_status(
|
|
task.task_id,
|
|
{"running"},
|
|
update_payload,
|
|
ctx,
|
|
require_workflow_not_cancelled=True,
|
|
)
|
|
if completed_task is None:
|
|
current_task = self.queue_service.get_job(task.task_id)
|
|
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
|
|
return self._finalize_cancelled_generation(
|
|
task_id=task.task_id,
|
|
node_id=node_id,
|
|
workflow_id=workflow.workflow_id,
|
|
assets=assets,
|
|
images=images,
|
|
ctx=ctx,
|
|
)
|
|
self._cleanup_generation_outputs(assets=assets, images=[*images, *restricted_images])
|
|
raise ApiError(
|
|
ErrorCode.GENERATION_FAILED,
|
|
"generation task changed before completion",
|
|
{"task_id": task.task_id, "status": current_task.status},
|
|
)
|
|
if images:
|
|
images[0] = self.image_service.select_image(images[0].image_id, ctx)
|
|
completed_node = self.workflow_service.update_node(node_id, {"status": "completed"}, ctx)
|
|
self._publish(
|
|
"generation.node_completed",
|
|
{
|
|
"workflow_id": workflow.workflow_id,
|
|
"node_id": node_id,
|
|
"task_id": completed_task.task_id,
|
|
"image_ids": [image.image_id for image in images],
|
|
},
|
|
)
|
|
return {
|
|
"task_id": completed_task.task_id,
|
|
"task_status": completed_task.status,
|
|
"node_status": completed_node.status,
|
|
"images": [image.to_dict() for image in images],
|
|
**({"restricted_count": len(restricted_images), "image_moderation": "restricted"} if restricted_images else {}),
|
|
}
|
|
|
|
def _existing_generation_response(self, task: GenerationTask, node_id: str) -> dict[str, Any]:
|
|
node = self.workflow_service.get_node(node_id)
|
|
images = []
|
|
for image_id in task.result.get("image_ids", []):
|
|
try:
|
|
images.append(self.image_service.get_image(str(image_id)).to_dict())
|
|
except ApiError as exc:
|
|
if exc.error_code != ErrorCode.RESOURCE_NOT_FOUND:
|
|
raise
|
|
return {
|
|
"task_id": task.task_id,
|
|
"task_status": task.status,
|
|
"node_status": node.status,
|
|
"images": images,
|
|
"idempotent_replay": True,
|
|
}
|
|
|
|
def _active_generation_task(self, node: Any) -> GenerationTask | None:
|
|
metadata = node.metadata if isinstance(node.metadata, dict) else {}
|
|
task_id = _optional_text(metadata.get("last_task_id"))
|
|
if not task_id:
|
|
return None
|
|
try:
|
|
task = self.queue_service.get_job(task_id)
|
|
except ApiError as exc:
|
|
if exc.error_code == ErrorCode.RESOURCE_NOT_FOUND:
|
|
return None
|
|
raise
|
|
if task.node_id == node.node_id and task.status in {"queued", "running"}:
|
|
return task
|
|
return None
|
|
|
|
def _resolve_model_route(self, route_name: str) -> dict[str, Any]:
|
|
if not self.model_provider_service:
|
|
return {"route_name": route_name, "status": "unresolved"}
|
|
resolved = self.model_provider_service.resolve_route(route_name, modality="image_generation")
|
|
if not resolved:
|
|
return {"route_name": route_name, "status": "unresolved"}
|
|
provider = resolved.get("provider") or {}
|
|
return {
|
|
"route_name": resolved["route_name"],
|
|
"route_id": resolved["route_id"],
|
|
"status": "resolved",
|
|
"provider_id": resolved["provider_id"],
|
|
"provider_type": provider.get("provider_type"),
|
|
"model_id": resolved["model_id"],
|
|
"modality": resolved["modality"],
|
|
"priority": resolved["priority"],
|
|
"settings": dict(resolved.get("settings") or {}),
|
|
"capabilities": dict(provider.get("capabilities") or {}),
|
|
}
|
|
|
|
def _check_cost_budget(
|
|
self,
|
|
payload: dict[str, Any],
|
|
model_route: str,
|
|
route_resolution: dict[str, Any],
|
|
) -> dict[str, Any] | None:
|
|
budget = payload.get("cost_budget") if isinstance(payload.get("cost_budget"), dict) else None
|
|
if not budget or not self.cost_guard_service:
|
|
return None
|
|
guard = self.cost_guard_service.check_generation_budget(
|
|
provider_id=route_resolution.get("provider_id"),
|
|
provider_model=route_resolution.get("model_id") or model_route,
|
|
model_route=model_route,
|
|
planned_task_count=1,
|
|
planned_image_count=_planned_image_count(payload.get("count")),
|
|
planned_total_tokens=int(budget.get("planned_total_tokens") or 0),
|
|
max_task_count=budget.get("max_task_count"),
|
|
max_image_count=budget.get("max_image_count"),
|
|
max_estimated_cost=budget.get("max_estimated_cost"),
|
|
days=budget.get("days"),
|
|
unit_prices=budget.get("unit_prices") if isinstance(budget.get("unit_prices"), dict) else None,
|
|
)
|
|
if not guard["allowed"]:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "generation budget exceeded", guard)
|
|
return guard
|
|
|
|
def _queue_generation_node(
|
|
self,
|
|
original_node: Any,
|
|
payload: dict[str, Any],
|
|
ctx: RequestContext,
|
|
) -> Any:
|
|
current = self.workflow_service.get_node(original_node.node_id)
|
|
if current.status not in LOCKED_NODE_STATUSES:
|
|
return self.workflow_service.update_node(current.node_id, payload, ctx)
|
|
if not is_repeatable_single_image_node(current):
|
|
raise locked_node_edit_error(current)
|
|
|
|
repeat_payload = dict(payload)
|
|
repeat_metadata = repeat_payload.get("metadata") if isinstance(repeat_payload.get("metadata"), dict) else {}
|
|
repeat_payload["metadata"] = {
|
|
**repeat_metadata,
|
|
"repeat_generation": {
|
|
"previous_status": current.status,
|
|
"previous_selected_image_id": current.selected_image_id,
|
|
"task_id": repeat_metadata.get("last_task_id"),
|
|
},
|
|
}
|
|
after = self.workflow_service.workflow_repository.update_node(current.node_id, repeat_payload)
|
|
if after is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "node not found", {"node_id": current.node_id})
|
|
self.workflow_service.audit_service.record(
|
|
ctx=ctx,
|
|
action="update_node",
|
|
target_type="workflow_node",
|
|
target_id=current.node_id,
|
|
before_snapshot=current.to_dict(),
|
|
after_snapshot=after.to_dict(),
|
|
metadata={"source": "generation.repeatable_single_image"},
|
|
)
|
|
if self.workflow_service.event_bus:
|
|
self.workflow_service.event_bus.publish(
|
|
"workflow.node_status_changed",
|
|
{
|
|
"workflow_id": after.workflow_id,
|
|
"node_id": after.node_id,
|
|
"before_status": current.status,
|
|
"after_status": after.status,
|
|
},
|
|
)
|
|
self.workflow_service.event_bus.publish(
|
|
"workflow.node_updated",
|
|
{"workflow_id": after.workflow_id, "node_id": after.node_id},
|
|
)
|
|
return after
|
|
|
|
def _expand_prompt(
|
|
self,
|
|
profile_id: str,
|
|
node,
|
|
payload: dict[str, Any],
|
|
) -> dict[str, Any] | None:
|
|
if not self.prompt_expansion_service:
|
|
return None
|
|
profile = self.workflow_service.profile_repository.get(profile_id)
|
|
if profile is None:
|
|
return None
|
|
return self.prompt_expansion_service.expand_for_node(profile, node, payload)
|
|
|
|
def _govern_prompt(
|
|
self,
|
|
*,
|
|
node: Any,
|
|
payload: dict[str, Any],
|
|
prompt_expansion: dict[str, Any] | None,
|
|
requested_route: str,
|
|
ctx: RequestContext,
|
|
) -> dict[str, Any] | None:
|
|
if not any((self.prompt_translation_service, self.prompt_semantic_normalizer, self.prompt_moderation_service, self.generation_route_service)):
|
|
return None
|
|
original = _optional_text(payload.get("user_prompt") or payload.get("prompt") or payload.get("prompt_patch")) or _optional_text(getattr(node, "prompt", None)) or ""
|
|
expanded = _optional_text((prompt_expansion or {}).get("prompt")) or original
|
|
negative = _optional_text((prompt_expansion or {}).get("negative_prompt")) or _optional_text(getattr(node, "negative_prompt", None)) or ""
|
|
entrypoint = _entrypoint(payload)
|
|
locked_terms = _string_list(payload.get("locked_terms"))
|
|
translation = None
|
|
translated = expanded
|
|
if self.prompt_translation_service:
|
|
translation_result = self.prompt_translation_service.translate(
|
|
expanded,
|
|
entrypoint=entrypoint,
|
|
user_allowed=bool(payload.get("translation_consent", False)),
|
|
model_family=str(payload.get("prompt_model_family") or "natural_language"),
|
|
locked_terms=locked_terms,
|
|
budget=_positive_int(payload.get("prompt_budget")),
|
|
)
|
|
translation = translation_result.to_dict()
|
|
translated = translation_result.translated_text
|
|
normalization = None
|
|
final_prompt = translated
|
|
if self.prompt_semantic_normalizer:
|
|
normalization = self.prompt_semantic_normalizer.normalize(translated, locked_terms=locked_terms)
|
|
final_prompt = normalization["normalized_text"]
|
|
moderation = (
|
|
self.prompt_moderation_service.moderate(
|
|
original_prompt=original,
|
|
translated_prompt=translated,
|
|
final_prompt=final_prompt,
|
|
negative_prompt=negative,
|
|
reference_bindings=_reference_binding_summary(payload),
|
|
)
|
|
if self.prompt_moderation_service
|
|
else None
|
|
)
|
|
if moderation is None:
|
|
from backend.services.prompt_governance_service import PromptModerationDecision
|
|
|
|
moderation = PromptModerationDecision("safe", 1.0, [], ["moderation_not_configured"], "allow", None, "none", None, "")
|
|
if self.generation_route_service:
|
|
route = self.generation_route_service.decide(
|
|
requested_route,
|
|
moderation,
|
|
entrypoint=entrypoint,
|
|
user_id=ctx.actor_id,
|
|
group_id=_optional_text(payload.get("group_id") or payload.get("chat_group_id")),
|
|
permission_context=_permission_context(payload),
|
|
)
|
|
else:
|
|
from backend.services.prompt_governance_service import GenerationRouteDecision
|
|
|
|
route = GenerationRouteDecision(requested_route, moderation.level, requested_route if moderation.allowed else None, "static_route", None, moderation.allowed, moderation.level == "uncertain", "")
|
|
if not route.allowed:
|
|
if moderation.level in {"terror_prohibited", "violence_prohibited", "prohibited"}:
|
|
try:
|
|
self.workflow_service.audit_service.record(
|
|
ctx=ctx,
|
|
action="generation_content_safety_blocked",
|
|
target_type="workflow_node",
|
|
target_id=str(getattr(node, "node_id", "")),
|
|
metadata={
|
|
"priority": "high" if moderation.level in {"terror_prohibited", "violence_prohibited"} else "normal",
|
|
"entrypoint": entrypoint,
|
|
"moderation_level": moderation.level,
|
|
"reason_codes": moderation.reason_codes,
|
|
"rules_version": moderation.rules_version,
|
|
"group_id": _optional_text(payload.get("group_id") or payload.get("chat_group_id")),
|
|
},
|
|
)
|
|
except Exception:
|
|
pass
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
moderation.warning or ("内容需要确认后才能生成" if route.requires_confirmation else "内容审核未通过,未创建生成任务"),
|
|
{
|
|
"moderation_level": moderation.level,
|
|
"reason_codes": moderation.reason_codes,
|
|
"route_reason": route.reason,
|
|
"requires_confirmation": route.requires_confirmation,
|
|
"warning": moderation.warning,
|
|
},
|
|
)
|
|
return {
|
|
"prompt": final_prompt,
|
|
"negative_prompt": negative,
|
|
"translation": translation,
|
|
"normalization": normalization,
|
|
"moderation": moderation.to_dict(),
|
|
"route_decision": route.to_dict(),
|
|
"entrypoint": entrypoint,
|
|
}
|
|
|
|
def _content_safety_fallback(
|
|
self,
|
|
*,
|
|
exc: ImageProviderError,
|
|
runtime_request: dict[str, Any],
|
|
governance: dict[str, Any] | None,
|
|
requested_route: str,
|
|
ctx: RequestContext,
|
|
) -> dict[str, Any] | None:
|
|
failure = self.generation_failure_classifier.classify(exc)
|
|
if failure["failure_class"] != "content_safety_rejection" or not self.prompt_moderation_service or not self.generation_route_service:
|
|
return None
|
|
if (runtime_request.get("route_fallback") or {}).get("attempted"):
|
|
return None
|
|
prompt = _optional_text(runtime_request.get("expanded_prompt")) or ""
|
|
negative = _optional_text(runtime_request.get("expanded_negative_prompt")) or ""
|
|
translation = (governance or {}).get("translation")
|
|
translation = translation if isinstance(translation, dict) else {}
|
|
moderation = self.prompt_moderation_service.moderate(
|
|
original_prompt=_optional_text(translation.get("original_text")) or prompt,
|
|
translated_prompt=_optional_text(translation.get("translated_text")) or prompt,
|
|
final_prompt=prompt,
|
|
negative_prompt=negative,
|
|
reference_bindings=[],
|
|
)
|
|
payload = runtime_request
|
|
route = self.generation_route_service.decide(
|
|
requested_route,
|
|
moderation,
|
|
entrypoint=_entrypoint(payload),
|
|
user_id=ctx.actor_id,
|
|
group_id=_optional_text(payload.get("group_id") or payload.get("chat_group_id")),
|
|
permission_context=_permission_context(payload),
|
|
)
|
|
if not route.allowed or moderation.level != "adult_allowed" or not route.selected_route or route.selected_route == runtime_request.get("model_route"):
|
|
return None
|
|
resolution = self._resolve_model_route(route.selected_route)
|
|
if self.require_resolved_model_route and resolution.get("status") != "resolved":
|
|
return None
|
|
fallback_cost_guard = self._check_cost_budget(runtime_request, route.selected_route, resolution)
|
|
fallback_record = {
|
|
"attempted": True,
|
|
"initial_route": runtime_request.get("model_route"),
|
|
"failure_class": failure,
|
|
"moderation_recheck": moderation.to_dict(),
|
|
"fallback_route": route.selected_route,
|
|
"fallback_reason": route.reason,
|
|
}
|
|
return {
|
|
"model_route": route.selected_route,
|
|
"route_resolution": resolution,
|
|
"request": {
|
|
**runtime_request,
|
|
"model_route": route.selected_route,
|
|
"resolved_model_route": resolution,
|
|
"route_fallback": fallback_record,
|
|
"allow_provider_fallback": False,
|
|
**({"cost_guard": fallback_cost_guard} if fallback_cost_guard else {}),
|
|
},
|
|
}
|
|
|
|
def _moderate_generated_image(self, image_payload: dict[str, Any], governance: dict[str, Any] | None, model_route: str) -> dict[str, Any]:
|
|
if not self.image_moderation_service:
|
|
return {"status": "not_configured", "action": "allow", "version": "none"}
|
|
level = _optional_text((governance or {}).get("moderation", {}).get("level")) or "safe"
|
|
route_kind = "nsfw" if level == "adult_allowed" else "safe"
|
|
return self.image_moderation_service.moderate(image_payload, requested_level=level, route_kind=route_kind)
|
|
|
|
def _apply_restoration_feedback(self, moderation: dict[str, Any]) -> None:
|
|
if self.material_resolver is None or not hasattr(self.material_resolver, "update_material"):
|
|
return
|
|
scores = moderation.get("material_restoration_scores")
|
|
if not isinstance(scores, dict):
|
|
return
|
|
for material_id, raw_score in scores.items():
|
|
try:
|
|
score = min(max(float(raw_score), 0.0), 1.0)
|
|
material = self.material_resolver.get_material(str(material_id))
|
|
if material is None:
|
|
continue
|
|
old = material.metadata.get("restoration_feedback") if isinstance(material.metadata.get("restoration_feedback"), dict) else {}
|
|
count = int(old.get("count") or 0)
|
|
average = ((float(old.get("score") or 0.0) * count) + score) / (count + 1)
|
|
self.material_resolver.update_material(str(material_id), {"metadata": {**material.metadata, "restoration_feedback": {"score": round(average, 4), "count": count + 1}}})
|
|
except Exception:
|
|
continue
|
|
|
|
def _enrich_generation_payload(self, node_id: str, payload: dict[str, Any]) -> dict[str, Any]:
|
|
enriched_payload = dict(payload)
|
|
if not isinstance(enriched_payload.get("dependency_context"), dict):
|
|
enriched_payload["dependency_context"] = NodeDependencyContextService(
|
|
self.workflow_service,
|
|
self.image_service,
|
|
).get_context(node_id)
|
|
self._compile_material_bindings(enriched_payload)
|
|
return enriched_payload
|
|
|
|
def _compile_material_bindings(self, payload: dict[str, Any]) -> None:
|
|
if self.material_resolver is None:
|
|
return
|
|
dependency = payload.get("dependency_context") if isinstance(payload.get("dependency_context"), dict) else {}
|
|
bindings = dependency.get("material_bindings") if isinstance(dependency.get("material_bindings"), dict) else {}
|
|
active = bindings.get("active_bindings") if isinstance(bindings.get("active_bindings"), list) else []
|
|
materials: list[dict[str, Any]] = []
|
|
for binding in active:
|
|
if not isinstance(binding, dict):
|
|
continue
|
|
material_ref = binding.get("material") if isinstance(binding.get("material"), dict) else {}
|
|
material_id = _optional_text(material_ref.get("material_id") or binding.get("material_id"))
|
|
material = self.material_resolver.get_material(material_id) if material_id else None
|
|
if material is None or str(getattr(material, "recognition_status", "")) != "confirmed":
|
|
continue
|
|
strength = binding.get("reference_strength") if isinstance(binding.get("reference_strength"), dict) else {}
|
|
materials.append({
|
|
"material_id": material.material_id,
|
|
"category": binding.get("category"),
|
|
"prompt": material.prompt or material_ref.get("prompt"),
|
|
"negative_prompt": material.negative_prompt,
|
|
"image_uri": material.image_uri,
|
|
"metadata": material.metadata,
|
|
"user_adjustment": 20.0 if binding.get("required") else 0.0,
|
|
"visibility_bonus": 10.0 if binding.get("required") else 0.0,
|
|
"reference_strength": strength.get("key"),
|
|
"restoration_score": (
|
|
material.metadata.get("restoration_feedback", {}).get("score")
|
|
if isinstance(material.metadata.get("restoration_feedback"), dict)
|
|
else None
|
|
),
|
|
})
|
|
if not materials:
|
|
return
|
|
composition = self.composition_builder.build({
|
|
"materials": materials,
|
|
"prompt_budget": payload.get("prompt_budget") or 4000,
|
|
"max_reference_images": payload.get("max_reference_images") or 8,
|
|
"visible_slots": payload.get("visible_slots") or [],
|
|
"season": payload.get("season") or "",
|
|
"scene": payload.get("scene") or "",
|
|
}).to_dict()
|
|
dependency["material_bindings"] = {
|
|
**bindings,
|
|
"composition": composition,
|
|
"material_prompts": [composition["prompt"]] if composition.get("prompt") else [],
|
|
"prompt_context": composition.get("prompt") or "",
|
|
"reference_bindings": composition.get("reference_bindings") or [],
|
|
"generation_params": {
|
|
**(bindings.get("generation_params") if isinstance(bindings.get("generation_params"), dict) else {}),
|
|
"reference_material_ids": [item["material_id"] for item in composition.get("selected_materials") or []],
|
|
},
|
|
}
|
|
payload["dependency_context"] = dependency
|
|
|
|
def _publish(self, event_type: str, payload: dict[str, Any]) -> None:
|
|
if self.event_bus:
|
|
self.event_bus.publish(event_type, payload)
|
|
|
|
def _cancel_generation_if_requested(
|
|
self,
|
|
task_id: str,
|
|
workflow_id: str,
|
|
ctx: RequestContext,
|
|
) -> bool:
|
|
task = self.queue_service.get_job(task_id)
|
|
if task.status == "cancelled":
|
|
return True
|
|
workflow = self.workflow_service.get_workflow(workflow_id).workflow
|
|
if workflow.status != "cancelled" or task.status not in {"queued", "running"}:
|
|
return False
|
|
try:
|
|
task = self.queue_service.cancel_job(
|
|
task_id,
|
|
ctx,
|
|
reason="owning workflow was cancelled",
|
|
)
|
|
except ApiError:
|
|
task = self.queue_service.get_job(task_id)
|
|
return task.status == "cancelled"
|
|
|
|
def _finalize_cancelled_generation(
|
|
self,
|
|
*,
|
|
task_id: str,
|
|
node_id: str,
|
|
workflow_id: str,
|
|
assets: list[Any],
|
|
images: list[Any],
|
|
ctx: RequestContext,
|
|
) -> dict[str, Any]:
|
|
cleanup = self._cleanup_generation_outputs(assets=assets, images=images)
|
|
task = self.queue_service.get_job(task_id)
|
|
node = self.workflow_service.get_node(node_id)
|
|
node_metadata = node.metadata if isinstance(node.metadata, dict) else {}
|
|
node_task_id = _optional_text(node_metadata.get("last_task_id"))
|
|
if node_task_id == task_id and node.status in {"queued", "running", "cancelled"}:
|
|
cancellation = task.metadata.get("cancellation") if isinstance(task.metadata, dict) else None
|
|
cancellation_reason = (
|
|
_optional_text(cancellation.get("reason"))
|
|
if isinstance(cancellation, dict)
|
|
else None
|
|
)
|
|
node_update: dict[str, Any] = {
|
|
"metadata": {
|
|
**node_metadata,
|
|
"generation_cancellation": {
|
|
"task_id": task_id,
|
|
"reason": cancellation_reason or "cancelled",
|
|
"cleanup": cleanup,
|
|
},
|
|
},
|
|
}
|
|
if node.status in {"queued", "running"}:
|
|
node_update["status"] = "cancelled"
|
|
node = self.workflow_service.update_node(
|
|
node_id,
|
|
node_update,
|
|
ctx,
|
|
)
|
|
self._publish(
|
|
"generation.node_cancelled",
|
|
{
|
|
"workflow_id": workflow_id,
|
|
"node_id": node_id,
|
|
"task_id": task_id,
|
|
"node_status": node.status,
|
|
"cleanup": cleanup,
|
|
},
|
|
)
|
|
return {
|
|
"task_id": task.task_id,
|
|
"task_status": task.status,
|
|
"node_status": node.status,
|
|
"images": [],
|
|
"cancelled": True,
|
|
}
|
|
|
|
def _cleanup_generation_outputs(self, *, assets: list[Any], images: list[Any]) -> dict[str, Any]:
|
|
removed_image_ids: list[str] = []
|
|
removed_uris: list[str] = []
|
|
errors: list[dict[str, str]] = []
|
|
for image in reversed(images):
|
|
image_id = _optional_text(getattr(image, "image_id", None))
|
|
if not image_id:
|
|
continue
|
|
try:
|
|
removed = self.image_service.image_repository.delete_metadata(image_id)
|
|
if removed is not None:
|
|
removed_image_ids.append(image_id)
|
|
except Exception as exc:
|
|
errors.append(
|
|
{
|
|
"target": image_id,
|
|
"error_type": exc.__class__.__name__,
|
|
"message": str(exc),
|
|
}
|
|
)
|
|
|
|
seen_uris: set[str] = set()
|
|
for asset in assets:
|
|
for field in ("image_uri", "thumbnail_uri"):
|
|
uri = _optional_text(getattr(asset, field, None))
|
|
if not uri or uri in seen_uris:
|
|
continue
|
|
seen_uris.add(uri)
|
|
try:
|
|
path = self.single_flow_engine.storage.resolve_uri(uri)
|
|
if path.exists() and path.is_file():
|
|
path.unlink()
|
|
removed_uris.append(uri)
|
|
except Exception as exc:
|
|
errors.append(
|
|
{
|
|
"target": uri,
|
|
"error_type": exc.__class__.__name__,
|
|
"message": str(exc),
|
|
}
|
|
)
|
|
return {
|
|
"image_records_removed": removed_image_ids,
|
|
"files_removed": removed_uris,
|
|
"errors": errors,
|
|
}
|
|
|
|
def _record_generation_failure(
|
|
self,
|
|
*,
|
|
task: GenerationTask,
|
|
node_id: str,
|
|
workflow_id: str,
|
|
route_resolution: dict[str, Any],
|
|
exc: Exception,
|
|
ctx: RequestContext,
|
|
) -> dict[str, Any]:
|
|
if isinstance(exc, ImageProviderError):
|
|
failure = provider_failure_attribution(exc, route_context=route_resolution, fallback_used=False)
|
|
else:
|
|
failure = {
|
|
"source": "generation_pipeline",
|
|
"category": "internal_error",
|
|
"error_type": exc.__class__.__name__,
|
|
"message": "generation pipeline failed",
|
|
"retryable": False,
|
|
"fallback_used": False,
|
|
}
|
|
failed_task = None
|
|
try:
|
|
failed_task = self.queue_service.update_task_if_status(
|
|
task.task_id,
|
|
{"queued", "running"},
|
|
{
|
|
"status": "failed",
|
|
"progress": 100,
|
|
"error_message": str(failure.get("message") or "generation failed"),
|
|
"metadata": {**task.metadata, "generation_failure": failure},
|
|
},
|
|
ctx,
|
|
)
|
|
except Exception:
|
|
pass
|
|
if failed_task is not None:
|
|
try:
|
|
node = self.workflow_service.get_node(node_id)
|
|
node_metadata = node.metadata if isinstance(node.metadata, dict) else {}
|
|
if (
|
|
_optional_text(node_metadata.get("last_task_id")) == task.task_id
|
|
and node.status in {"queued", "running"}
|
|
):
|
|
self.workflow_service.update_node(
|
|
node_id,
|
|
{
|
|
"status": "failed",
|
|
"metadata": {
|
|
**node_metadata,
|
|
"generation_failure": failure,
|
|
"last_task_id": task.task_id,
|
|
},
|
|
},
|
|
ctx,
|
|
)
|
|
except Exception:
|
|
pass
|
|
self._publish(
|
|
"generation.node_failed",
|
|
{"workflow_id": workflow_id, "node_id": node_id, "task_id": task.task_id, "failure": failure},
|
|
)
|
|
return failure
|
|
|
|
|
|
def _retain_node_generation_lock(node_id: str) -> _NodeGenerationLock:
|
|
key = str(node_id)
|
|
with _NODE_GENERATION_LOCKS_GUARD:
|
|
entry = _NODE_GENERATION_LOCKS.get(key)
|
|
if entry is None:
|
|
entry = _NodeGenerationLock()
|
|
_NODE_GENERATION_LOCKS[key] = entry
|
|
entry.users += 1
|
|
return entry
|
|
|
|
|
|
def _release_node_generation_lock(node_id: str, entry: _NodeGenerationLock) -> None:
|
|
key = str(node_id)
|
|
with _NODE_GENERATION_LOCKS_GUARD:
|
|
entry.users -= 1
|
|
if entry.users == 0 and _NODE_GENERATION_LOCKS.get(key) is entry:
|
|
_NODE_GENERATION_LOCKS.pop(key, None)
|
|
|
|
|
|
def _assignment_key(node: Any) -> str:
|
|
node_key = str(getattr(node, "node_key", "") or "").strip()
|
|
node_type = str(getattr(node, "node_type", "") or "").strip()
|
|
mapping = {
|
|
"headshot": "portrait_generation",
|
|
"half_body": "halfbody_generation",
|
|
"full_body": "fullbody_generation",
|
|
"expression_sheet": "sheet_generation",
|
|
"pose_sheet": "sheet_generation",
|
|
"style_lock": "hires_fix",
|
|
"questionnaire": "quick_generation",
|
|
"preview": "quick_generation",
|
|
}
|
|
if node_key in mapping:
|
|
return mapping[node_key]
|
|
if node_type == "virtual_single_image":
|
|
return "quick_generation"
|
|
return "quick_generation" if node_type in {"profile_draft", "profile_preview"} else node_key
|
|
|
|
|
|
def _optional_text(value: Any) -> str | None:
|
|
if value is None:
|
|
return None
|
|
text = str(value).strip()
|
|
return text or None
|
|
|
|
|
|
_OMITTED_EPHEMERAL_REFERENCE = object()
|
|
|
|
|
|
def _strip_ephemeral_image_data_urls(value: Any) -> tuple[Any, int]:
|
|
"""Remove inline image payloads before writing a generation request to storage."""
|
|
|
|
if isinstance(value, str):
|
|
if value.lstrip().lower().startswith("data:image/"):
|
|
return _OMITTED_EPHEMERAL_REFERENCE, 1
|
|
return value, 0
|
|
if isinstance(value, dict):
|
|
cleaned: dict[Any, Any] = {}
|
|
omitted = 0
|
|
for key, item in value.items():
|
|
prepared, item_omitted = _strip_ephemeral_image_data_urls(item)
|
|
omitted += item_omitted
|
|
if prepared is not _OMITTED_EPHEMERAL_REFERENCE:
|
|
cleaned[key] = prepared
|
|
return cleaned, omitted
|
|
if isinstance(value, (list, tuple)):
|
|
cleaned_items: list[Any] = []
|
|
omitted = 0
|
|
for item in value:
|
|
prepared, item_omitted = _strip_ephemeral_image_data_urls(item)
|
|
omitted += item_omitted
|
|
if prepared is not _OMITTED_EPHEMERAL_REFERENCE:
|
|
cleaned_items.append(prepared)
|
|
return cleaned_items, omitted
|
|
return value, 0
|
|
|
|
|
|
def _provider_failure_from_assets(metadata_items: list[dict[str, Any]]) -> dict[str, Any] | None:
|
|
for metadata in metadata_items:
|
|
failure = metadata.get("provider_error")
|
|
if isinstance(failure, dict):
|
|
return failure
|
|
return None
|
|
|
|
|
|
def _planned_image_count(value: Any) -> int:
|
|
try:
|
|
count = int(value)
|
|
except (TypeError, ValueError):
|
|
count = 1
|
|
return min(max(count, 1), 8)
|
|
|
|
|
|
def _entrypoint(payload: dict[str, Any]) -> str:
|
|
value = _optional_text(payload.get("entrypoint") or payload.get("platform") or payload.get("source")) or "web"
|
|
lowered = value.lower()
|
|
if "qq" in lowered or "onebot" in lowered:
|
|
return "qq"
|
|
if "telegram" in lowered:
|
|
return "telegram"
|
|
if "discord" in lowered:
|
|
return "discord"
|
|
if lowered in {"web", "api"}:
|
|
return lowered
|
|
return "unknown"
|
|
|
|
|
|
def _permission_context(payload: dict[str, Any]) -> dict[str, Any]:
|
|
configured = payload.get("content_permissions") if isinstance(payload.get("content_permissions"), dict) else {}
|
|
result = {
|
|
**configured,
|
|
"adult_user_allowed": bool(configured.get("adult_user_allowed", payload.get("adult_user_allowed", False))),
|
|
"quota_allowed": bool(configured.get("quota_allowed", payload.get("quota_allowed", True))),
|
|
}
|
|
if "adult_group_allowed" in configured or "adult_group_allowed" in payload:
|
|
result["adult_group_allowed"] = bool(configured.get("adult_group_allowed", payload.get("adult_group_allowed")))
|
|
return result
|
|
|
|
|
|
def _reference_binding_summary(payload: dict[str, Any]) -> list[dict[str, Any]]:
|
|
composition = payload.get("composition") if isinstance(payload.get("composition"), dict) else {}
|
|
bindings = composition.get("reference_bindings")
|
|
if not isinstance(bindings, list):
|
|
dependency = payload.get("dependency_context") if isinstance(payload.get("dependency_context"), dict) else {}
|
|
material_bindings = dependency.get("material_bindings") if isinstance(dependency.get("material_bindings"), dict) else {}
|
|
bindings = material_bindings.get("reference_bindings")
|
|
return [dict(item) for item in bindings or [] if isinstance(item, dict)]
|
|
|
|
|
|
def _governance_audit_summary(governance: dict[str, Any]) -> dict[str, Any]:
|
|
translation = governance.get("translation") if isinstance(governance.get("translation"), dict) else {}
|
|
moderation = governance.get("moderation") if isinstance(governance.get("moderation"), dict) else {}
|
|
route = governance.get("route_decision") if isinstance(governance.get("route_decision"), dict) else {}
|
|
normalization = governance.get("normalization") if isinstance(governance.get("normalization"), dict) else {}
|
|
return {
|
|
"translation": {
|
|
"status": translation.get("status"),
|
|
"model_route": translation.get("model_route"),
|
|
"template_version": translation.get("template_version"),
|
|
"accepted": translation.get("accepted"),
|
|
},
|
|
"normalization": {
|
|
"changed_terms": normalization.get("changed_terms") or [],
|
|
"meaning_preserved": normalization.get("meaning_preserved", True),
|
|
"version": normalization.get("version"),
|
|
},
|
|
"moderation": {
|
|
"level": moderation.get("level"),
|
|
"confidence": moderation.get("confidence"),
|
|
"categories": moderation.get("categories") or [],
|
|
"reason_codes": moderation.get("reason_codes") or [],
|
|
"rules_version": moderation.get("rules_version"),
|
|
},
|
|
"route_decision": route,
|
|
"entrypoint": governance.get("entrypoint"),
|
|
}
|
|
|
|
|
|
def _string_list(value: Any) -> list[str]:
|
|
if isinstance(value, str):
|
|
values = value.split(",")
|
|
elif isinstance(value, (list, tuple, set)):
|
|
values = value
|
|
else:
|
|
return []
|
|
return [str(item).strip() for item in values if str(item).strip()]
|
|
|
|
|
|
def _positive_int(value: Any) -> int | None:
|
|
try:
|
|
number = int(value)
|
|
except (TypeError, ValueError):
|
|
return None
|
|
return number if number > 0 else None
|