astrbot_plugin_imagestudio/backend/services/workflow_round_feedback_service.py

265 行
9.8 KiB
Python

"""Conversational feedback planning for the existing workflow round pool.
The service is intentionally persistence-free. It gives Web and AstrBot one
shared interpretation contract while the owning ``WorkflowRoundService``
keeps authorization, transactions and next-round creation server-side.
"""
from __future__ import annotations
from collections.abc import Callable, Mapping
from dataclasses import replace
import json
import re
from typing import Any
from backend.dto.workflow_feedback_dto import WorkflowFeedbackInterpretation
from backend.services.workflow_feedback_interpreter import (
WorkflowFeedbackInterpretationError,
WorkflowFeedbackInterpreter,
)
StructuredFeedbackCallable = Callable[[dict[str, Any]], dict[str, Any] | str]
MAX_FEEDBACK_TEXT_LENGTH = 12_000
MAX_PATCH_LENGTH = 4_000
MAX_MATERIAL_INTENT_LENGTH = 2_000
class WorkflowRoundFeedbackService:
"""Use the configured text model when available, with a safe local fallback."""
def __init__(
self,
*,
interpreter: WorkflowFeedbackInterpreter | None = None,
structured_text_callable: StructuredFeedbackCallable | None = None,
model_route: str | None = None,
) -> None:
self.interpreter = interpreter or WorkflowFeedbackInterpreter()
self.structured_text_callable = structured_text_callable
self.model_route = str(model_route or "").strip() or None
def interpret(
self,
text: str,
*,
candidate_whitelist: Mapping[str, str],
candidate_context: Mapping[str, Mapping[str, Any]] | None = None,
) -> WorkflowFeedbackInterpretation:
source_text = _bounded_text(text, field="feedback_text", maximum=MAX_FEEDBACK_TEXT_LENGTH)
if not source_text:
raise WorkflowFeedbackInterpretationError(
"feedback_text_required",
"feedback_text is required",
{"field": "feedback_text"},
)
fallback_reason: str | None = None
if self.structured_text_callable is not None:
try:
raw = self.structured_text_callable(
_model_request(
source_text,
candidate_whitelist,
self.model_route,
candidate_context=candidate_context,
)
)
payload = _normalize_model_payload(raw)
interpretation = self.interpreter.validate_llm_result(
payload,
candidate_whitelist=candidate_whitelist,
source_text=source_text,
)
return _bounded_interpretation(
replace(
interpretation,
metadata={
"model_attempted": True,
"model_route": self.model_route,
"fallback_used": False,
},
)
)
except Exception as exc:
# Never expose provider messages here: they can contain URLs,
# headers or vendor-specific request fragments. The caller
# receives only a stable error class and then the deterministic
# parser evaluates the original user text from scratch.
fallback_reason = _safe_failure_code(exc)
elif self.model_route:
fallback_reason = "model_callable_unavailable"
interpretation = self.interpreter.interpret(
source_text,
candidate_whitelist=candidate_whitelist,
)
return _bounded_interpretation(
replace(
interpretation,
positive_patch=interpretation.positive_patch
or interpretation.next_round_prompt_patch,
source="deterministic_fallback" if fallback_reason else "deterministic",
metadata={
"model_attempted": self.structured_text_callable is not None,
"model_route": self.model_route,
"fallback_used": bool(fallback_reason),
**({"fallback_reason": fallback_reason} if fallback_reason else {}),
},
)
)
def _model_request(
source_text: str,
candidate_whitelist: Mapping[str, str],
model_route: str | None,
*,
candidate_context: Mapping[str, Mapping[str, Any]] | None,
) -> dict[str, Any]:
# Opaque candidate IDs deliberately never cross the model boundary.
display_codes = [str(code).strip() for code in candidate_whitelist if str(code).strip()]
context = candidate_context if isinstance(candidate_context, Mapping) else {}
return {
"purpose": "workflow candidate feedback interpretation and next-round prompt patch planning",
"user_text": source_text,
"candidate_whitelist": [
{
"display_code": code,
"ordinal": index,
"positive_prompt": _bounded_context_text(
(context.get(code) or {}).get("positive_prompt"),
maximum=4_000,
),
"negative_prompt": _bounded_context_text(
(context.get(code) or {}).get("negative_prompt"),
maximum=2_000,
),
"model_label": _bounded_context_text(
(context.get(code) or {}).get("model_label"),
maximum=200,
),
}
for index, code in enumerate(display_codes, start=1)
],
"response_schema": {
"feedback": {
"liked": ["display_code"],
"rejected": ["display_code"],
"strict_rejected": ["display_code"],
"final": "display_code|null",
},
"positive_patch": "string|null",
"negative_patch": "string|null",
"material_intent": "string|null",
},
"rules": [
"Use only display_code values from candidate_whitelist.",
"Never return opaque server identifiers.",
"Keep strict rejections in negative_patch.",
"Do not invent visual details absent from user_text.",
],
**({"model_route": model_route} if model_route else {}),
}
def _normalize_model_payload(value: dict[str, Any] | str) -> dict[str, Any]:
if isinstance(value, str):
cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", value.strip(), flags=re.IGNORECASE)
parsed = json.loads(cleaned)
else:
parsed = value
if not isinstance(parsed, Mapping):
raise WorkflowFeedbackInterpretationError(
"invalid_llm_result",
"LLM feedback result must be an object",
)
_reject_opaque_identifier_keys(parsed)
feedback = parsed.get("feedback")
feedback = dict(feedback) if isinstance(feedback, Mapping) else {}
merged = {
**feedback,
"positive_patch": parsed.get(
"positive_patch",
feedback.get("positive_patch", parsed.get("next_round_prompt_patch")),
),
"negative_patch": parsed.get("negative_patch", feedback.get("negative_patch")),
"material_intent": parsed.get("material_intent", feedback.get("material_intent")),
}
return merged
def _bounded_interpretation(
interpretation: WorkflowFeedbackInterpretation,
) -> WorkflowFeedbackInterpretation:
positive = _bounded_optional(
interpretation.positive_patch or interpretation.next_round_prompt_patch,
field="positive_patch",
maximum=MAX_PATCH_LENGTH,
)
negative = _bounded_optional(
interpretation.negative_patch,
field="negative_patch",
maximum=MAX_PATCH_LENGTH,
)
material = _bounded_optional(
interpretation.material_intent,
field="material_intent",
maximum=MAX_MATERIAL_INTENT_LENGTH,
)
return replace(
interpretation,
next_round_prompt_patch=positive,
positive_patch=positive,
negative_patch=negative,
material_intent=material,
)
def _bounded_optional(value: Any, *, field: str, maximum: int) -> str | None:
if value is None:
return None
return _bounded_text(value, field=field, maximum=maximum) or None
def _bounded_text(value: Any, *, field: str, maximum: int) -> str:
if not isinstance(value, str):
raise WorkflowFeedbackInterpretationError(
"invalid_feedback_text",
f"{field} must be text",
{"field": field},
)
normalized = value.strip()
if len(normalized) > maximum:
raise WorkflowFeedbackInterpretationError(
"feedback_text_too_long",
f"{field} is too long",
{"field": field, "maximum": maximum},
)
return normalized
def _safe_failure_code(exc: Exception) -> str:
if isinstance(exc, WorkflowFeedbackInterpretationError):
return exc.reason
return type(exc).__name__[:80]
def _bounded_context_text(value: Any, *, maximum: int) -> str | None:
text = " ".join(str(value or "").split())
return text[:maximum] or None
def _reject_opaque_identifier_keys(value: Any, *, path: str = "$") -> None:
if isinstance(value, Mapping):
for key, item in value.items():
if str(key).strip().lower() in {"candidate_id", "candidate_ids"}:
raise WorkflowFeedbackInterpretationError(
"invalid_llm_result",
"LLM feedback must reference candidates by display_code only",
{"field": f"{path}.{key}", "reason": "llm_candidate_id_forbidden"},
)
_reject_opaque_identifier_keys(item, path=f"{path}.{key}")
elif isinstance(value, (list, tuple)):
for index, item in enumerate(value):
_reject_opaque_identifier_keys(item, path=f"{path}[{index}]")