From 37948ca3bcfbcf55c6cce5cfd1b344e137ac4f28 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 02:47:37 +0800 Subject: [PATCH] =?UTF-8?q?S88=20=E6=8F=90=E7=A4=BA=E8=AF=8D=E6=89=A9?= =?UTF-8?q?=E5=B1=95=E5=90=8E=E7=AB=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/route_registry.py | 1 + backend/routes/prompt_routes.py | 25 ++++++ backend/services/generation_service.py | 27 +++++++ backend/services/prompt_expansion_service.py | 85 ++++++++++++++++++++ engines/single_flow.py | 30 ++++++- tests/test_prompt_expansion_service.py | 84 +++++++++++++++++++ tests/test_route_registry.py | 1 + tests/test_single_flow_generation.py | 50 ++++++++++++ 8 files changed, 300 insertions(+), 3 deletions(-) create mode 100644 backend/routes/prompt_routes.py create mode 100644 backend/services/prompt_expansion_service.py create mode 100644 tests/test_prompt_expansion_service.py diff --git a/backend/route_registry.py b/backend/route_registry.py index 99c9d1a..294ca11 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -57,6 +57,7 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("GET", "review/policy", "backend.routes.review_routes.get_review_policy", "read"), RouteSpec("POST", "review/policy/validate", "backend.routes.review_routes.validate_review_policy", "config"), RouteSpec("POST", "review/policy/save", "backend.routes.review_routes.save_review_policy", "config"), + RouteSpec("POST", "prompts/expand", "backend.routes.prompt_routes.expand_prompt", "read"), RouteSpec("GET", "nodes/{node_id}/review", "backend.routes.review_routes.review_node", "read"), RouteSpec("GET", "nodes/{node_id}/images", "backend.routes.image_routes.list_node_images", "read"), RouteSpec("GET", "workflows/{workflow_id}/review", "backend.routes.review_routes.review_workflow", "read"), diff --git a/backend/routes/prompt_routes.py b/backend/routes/prompt_routes.py new file mode 100644 index 0000000..7a6049b --- /dev/null +++ b/backend/routes/prompt_routes.py @@ -0,0 +1,25 @@ +"""Prompt expansion route handlers.""" + +from __future__ import annotations + +from typing import Any + +from backend.routes.common import handle_request +from backend.services.prompt_expansion_service import PromptExpansionService +from core.identity import RequestContext +from core.security import require_authenticated + + +def expand_prompt( + ctx: RequestContext, + payload: dict[str, Any] | None = None, + service: PromptExpansionService | None = None, +) -> dict: + prompt_service = service or PromptExpansionService() + request_payload = payload or {} + + def action() -> dict[str, Any]: + require_authenticated(ctx) + return prompt_service.expand_payload(request_payload) + + return handle_request(ctx, action) diff --git a/backend/services/generation_service.py b/backend/services/generation_service.py index 661d703..96ab207 100644 --- a/backend/services/generation_service.py +++ b/backend/services/generation_service.py @@ -9,6 +9,7 @@ from backend.dto.job_dto import GenerationTask from backend.services.cost_guard_service import CostGuardService from backend.services.image_service import ImageService from backend.services.model_provider_service import ModelProviderService +from backend.services.prompt_expansion_service import PromptExpansionService from backend.services.queue_service import QueueService from backend.services.workflow_service import WorkflowService from core.event_bus import EventBus @@ -25,6 +26,7 @@ class GenerationService: 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, ): self.workflow_service = workflow_service @@ -33,6 +35,7 @@ class GenerationService: self.single_flow_engine = single_flow_engine or SingleFlowEngine() 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 def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: @@ -41,11 +44,21 @@ class GenerationService: model_route = str(payload.get("model_route") or node.model_route or "image_low") route_resolution = self._resolve_model_route(model_route) cost_guard = self._check_cost_budget(payload, model_route, route_resolution) + prompt_expansion = self._expand_prompt(workflow.profile_id, node, payload) generation_request = { **payload, "model_route": model_route, "resolved_model_route": route_resolution, **({"cost_guard": cost_guard} if cost_guard else {}), + **( + { + "prompt_expansion": prompt_expansion, + "expanded_prompt": prompt_expansion["prompt"], + "expanded_negative_prompt": prompt_expansion["negative_prompt"], + } + if prompt_expansion + else {} + ), } idempotency_key = _optional_text(payload.get("idempotency_key")) if idempotency_key: @@ -112,6 +125,7 @@ class GenerationService: "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, @@ -216,6 +230,19 @@ class GenerationService: raise ApiError(ErrorCode.VALIDATION_FAILED, "generation budget exceeded", guard) return guard + 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 _publish(self, event_type: str, payload: dict[str, Any]) -> None: if self.event_bus: self.event_bus.publish(event_type, payload) diff --git a/backend/services/prompt_expansion_service.py b/backend/services/prompt_expansion_service.py new file mode 100644 index 0000000..1ff7731 --- /dev/null +++ b/backend/services/prompt_expansion_service.py @@ -0,0 +1,85 @@ +"""Prompt expansion service for generation requests.""" + +from __future__ import annotations + +from typing import Any + +from backend.dto.profile_dto import CharacterProfile +from backend.dto.workflow_dto import WorkflowNode +from core.prompt_pipeline import merge_prompt_sections + + +class PromptExpansionService: + def expand_payload(self, payload: dict[str, Any]) -> dict[str, Any]: + sections = payload.get("sections") + if not isinstance(sections, list): + sections = [payload] + result = merge_prompt_sections(*[section for section in sections if isinstance(section, dict)]) + return { + **result.to_dict(), + "source": "payload", + } + + def expand_for_node( + self, + profile: CharacterProfile, + node: WorkflowNode, + payload: dict[str, Any], + ) -> dict[str, Any]: + variables = { + "profile_name": profile.name, + "node_title": node.title, + **(profile.metadata.get("prompt_variables") if isinstance(profile.metadata.get("prompt_variables"), dict) else {}), + **(payload.get("variables") if isinstance(payload.get("variables"), dict) else {}), + } + result = merge_prompt_sections( + { + "parts": [profile.base_prompt, profile.appearance_prompt, profile.style_prompt], + "negative_parts": [profile.negative_prompt], + "variables": variables, + }, + { + "parts": [node.prompt], + "negative_parts": [node.negative_prompt], + "variables": variables, + }, + { + "parts": _payload_parts(payload), + "negative_parts": _payload_negative_parts(payload), + "variables": variables, + }, + ) + return { + **result.to_dict(), + "source": "profile_node", + "profile_id": profile.profile_id, + "node_id": node.node_id, + } + + +def _payload_parts(payload: dict[str, Any]) -> list[Any]: + parts: list[Any] = [] + parts.extend(_as_list(payload.get("prompt_parts"))) + for key in ("prompt_patch", "extra_prompt", "style_prompt"): + value = payload.get(key) + if value: + parts.append(value) + return parts + + +def _payload_negative_parts(payload: dict[str, Any]) -> list[Any]: + parts: list[Any] = [] + parts.extend(_as_list(payload.get("negative_parts"))) + for key in ("negative_prompt", "negative_prompt_patch"): + value = payload.get(key) + if value: + parts.append(value) + return parts + + +def _as_list(value: Any) -> list[Any]: + if value is None: + return [] + if isinstance(value, list): + return value + return [value] diff --git a/engines/single_flow.py b/engines/single_flow.py index 7239e99..7061244 100644 --- a/engines/single_flow.py +++ b/engines/single_flow.py @@ -26,6 +26,7 @@ class MockGeneratedAsset: image_uri: str thumbnail_uri: str positive_prompt: str + negative_prompt: str | None model_route: str | None width: int height: int @@ -44,32 +45,45 @@ class SingleFlowEngine: def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]: count = _bounded_count(request.get("count", 1)) - prompt = _compose_prompt(node.prompt, request.get("prompt_patch")) + prompt = _optional_text(request.get("expanded_prompt")) or _compose_prompt(node.prompt, request.get("prompt_patch")) + negative_prompt = _optional_text(request.get("expanded_negative_prompt")) or _optional_text(node.negative_prompt) model_route = str(request.get("model_route") or node.model_route or "image_low") width, height = _dimensions(str(request.get("aspect_ratio") or "1:1")) provider = self._image_provider(request) if provider is not None: try: - return self._generate_with_provider(provider, task, request, prompt, model_route, width, height, count) + return self._generate_with_provider( + provider, + task, + request, + prompt, + negative_prompt, + model_route, + width, + height, + count, + ) except ImageProviderError as exc: route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {} return self._generate_mock( task, request, prompt, + negative_prompt, model_route, width, height, count, provider_error=provider_failure_attribution(exc, route_context=route, fallback_used=True), ) - return self._generate_mock(task, request, prompt, model_route, width, height, count) + return self._generate_mock(task, request, prompt, negative_prompt, model_route, width, height, count) def _generate_mock( self, task: GenerationTask, request: dict[str, Any], prompt: str, + negative_prompt: str | None, model_route: str, width: int, height: int, @@ -90,6 +104,7 @@ class SingleFlowEngine: image_uri=image_uri, thumbnail_uri=thumbnail_uri, positive_prompt=prompt, + negative_prompt=negative_prompt, model_route=model_route, width=width, height=height, @@ -110,6 +125,7 @@ class SingleFlowEngine: task: GenerationTask, request: dict[str, Any], prompt: str, + negative_prompt: str | None, model_route: str, width: int, height: int, @@ -141,6 +157,7 @@ class SingleFlowEngine: image_uri=image_uri, thumbnail_uri=thumbnail_uri, positive_prompt=image.revised_prompt or prompt, + negative_prompt=negative_prompt, model_route=model_route, width=width, height=height, @@ -190,6 +207,13 @@ def _compose_prompt(base_prompt: str | None, prompt_patch: Any) -> str: return ", ".join(parts) if parts else "single image mock generation" +def _optional_text(value: Any) -> str | None: + if value is None: + return None + text = str(value).strip() + return text or None + + def _dimensions(aspect_ratio: str) -> tuple[int, int]: if aspect_ratio == "3:4": return 768, 1024 diff --git a/tests/test_prompt_expansion_service.py b/tests/test_prompt_expansion_service.py new file mode 100644 index 0000000..d0ef1c0 --- /dev/null +++ b/tests/test_prompt_expansion_service.py @@ -0,0 +1,84 @@ +from __future__ import annotations + +import unittest + +from backend.dto.profile_dto import CharacterProfile +from backend.dto.workflow_dto import WorkflowNode +from backend.routes.prompt_routes import expand_prompt +from backend.services.prompt_expansion_service import PromptExpansionService +from core.identity import RequestContext + + +class PromptExpansionServiceTests(unittest.TestCase): + def test_expand_for_node_combines_profile_node_and_payload(self): + profile = CharacterProfile( + profile_id="profile_001", + name="Nova", + description=None, + base_prompt="portrait of {profile_name}", + appearance_prompt="silver hair", + style_prompt="soft watercolor", + negative_prompt="low quality", + default_model_route="image_low", + owner_platform="webui", + owner_context_id=None, + owner_user_id="user_001", + owner_session_key=None, + avatar_image_uri=None, + status="active", + metadata={"prompt_variables": {"mood": "calm"}}, + created_at="2026-01-01T00:00:00Z", + updated_at="2026-01-01T00:00:00Z", + ) + node = WorkflowNode( + node_id="node_001", + workflow_id="workflow_001", + node_key="single", + title="Single", + description=None, + step_name=None, + node_type="single_image", + status="draft", + branch_name="main", + prompt="{mood} expression", + negative_prompt="bad hands", + model_route="image_low", + selected_image_id=None, + sort_order=1, + metadata={}, + created_at="2026-01-01T00:00:00Z", + updated_at="2026-01-01T00:00:00Z", + ) + + result = PromptExpansionService().expand_for_node( + profile, + node, + {"prompt_patch": "white blouse", "negative_prompt_patch": "watermark"}, + ) + + self.assertEqual( + result["prompt"], + "portrait of Nova, silver hair, soft watercolor, calm expression, white blouse", + ) + self.assertEqual(result["negative_prompt"], "low quality, bad hands, watermark") + self.assertEqual(result["source"], "profile_node") + + def test_expand_prompt_route_requires_authentication(self): + ctx = RequestContext.from_astrbot(username="admin", user_id="user_001") + + response = expand_prompt( + ctx, + {"sections": [{"prompt": "portrait"}, {"prompt": "portrait", "negative_prompt": "blur"}]}, + PromptExpansionService(), + ) + anonymous = expand_prompt(RequestContext(), {"prompt": "portrait"}, PromptExpansionService()) + + self.assertTrue(response["ok"]) + self.assertEqual(response["data"]["prompt"], "portrait") + self.assertEqual(response["data"]["negative_prompt"], "blur") + self.assertFalse(anonymous["ok"]) + self.assertEqual(anonymous["error_code"], "UNAUTHORIZED") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_route_registry.py b/tests/test_route_registry.py index 39040d0..eb9000a 100644 --- a/tests/test_route_registry.py +++ b/tests/test_route_registry.py @@ -41,6 +41,7 @@ class RouteRegistryTests(unittest.TestCase): self.assertIn(("GET", "review/policy"), keys) self.assertIn(("POST", "review/policy/validate"), keys) self.assertIn(("POST", "review/policy/save"), keys) + self.assertIn(("POST", "prompts/expand"), keys) self.assertIn(("POST", "nodes/{node_id}/retry"), keys) self.assertIn(("POST", "nodes/{node_id}/complete"), keys) self.assertIn(("POST", "nodes/{node_id}/mark-completed"), keys) diff --git a/tests/test_single_flow_generation.py b/tests/test_single_flow_generation.py index ddc91a7..efb7b5d 100644 --- a/tests/test_single_flow_generation.py +++ b/tests/test_single_flow_generation.py @@ -13,6 +13,7 @@ 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_service import ModelProviderService +from backend.services.prompt_expansion_service import PromptExpansionService from backend.services.profile_service import ProfileService from backend.services.queue_service import QueueService from backend.services.workflow_service import WorkflowService @@ -461,6 +462,55 @@ storage: self.assertIn("cost_budget_exceeded", response["details"]["violations"]) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) + def test_generate_node_uses_prompt_expansion_when_service_is_configured(self): + profile = self.profile_service.create_profile( + { + "name": "Nova", + "base_prompt": "portrait of {profile_name}", + "appearance_prompt": "silver hair", + "style_prompt": "watercolor", + "negative_prompt": "low quality", + }, + self.ctx, + ) + workflow = self.workflow_service.create_workflow( + profile.profile_id, + {"workflow_type": "single_image", "display_name": "Single"}, + self.ctx, + ) + node_id = workflow.nodes[0].node_id + self.workflow_service.update_node( + node_id, + {"prompt": "calm expression", "negative_prompt": "bad hands"}, + self.ctx, + ) + generation_service = GenerationService( + workflow_service=self.workflow_service, + queue_service=self.queue_service, + image_service=self.image_service, + single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service)), + model_provider_service=self.model_provider_service, + prompt_expansion_service=PromptExpansionService(), + event_bus=self.event_bus, + ) + + response = generate_node( + self.ctx, + node_id, + {"prompt_patch": "white blouse", "negative_prompt_patch": "watermark"}, + generation_service=generation_service, + ) + + self.assertTrue(response["ok"]) + image = response["data"]["images"][0] + self.assertEqual( + image["positive_prompt"], + "portrait of Nova, silver hair, watercolor, calm expression, white blouse", + ) + self.assertEqual(image["negative_prompt"], "low quality, bad hands, watermark") + task = self.queue_service.get_job(response["data"]["task_id"]) + self.assertEqual(task.request["prompt_expansion"]["source"], "profile_node") + def test_queue_service_rejects_invalid_task_transition(self): task = self.queue_service.create_task({"status": "succeeded"}, self.ctx)