diff --git a/.gitignore b/.gitignore index d1b136e..056ad96 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ __pycache__/ *.py[cod] .pytest_cache/ .pytest_tmp*/ +.tmp_pytest*/ .ruff_cache/ .mypy_cache/ .venv/ diff --git a/CHANGELOG.md b/CHANGELOG.md index 8d62db9..a31e278 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,9 +4,104 @@ ## [Unreleased] +## [1.0.32] - 2026-07-18 + +- 画风验证审核升级为固定维度协议;服务端按头像、全身、跨场景分别加权脸部、眼睛、线稿、色彩、阴影、比例与背景,不再直接采用视觉模型的自由总分,并记录维度覆盖率与缺失项。 +- 复验共识自动聚合上一轮三张验证图,将至少两个场景重复出现的问题归类为公共画风缺陷,将单场景问题保留为尺度胶囊修正,避免头像问题污染全身或场景提示词。 +- 共识协议新增全局色彩与局部色差分离、结构化差异、提示词补丁、语义风险审计和尺度胶囊;可能被字面化为物体、光效或构图的比喻必须改写为表面、几何与位置关系。 +- detailed 画风胶囊改由服务端编译:按核心、结构、渲染优先级合并 `must_preserve`,近义去重并限制为 14 条公共核心特征,再叠加最多 5 条场景尺度特征,减少长提示词的注意力稀释。 +- 每轮三图完成后自动与上一轮计算总分和分场景差值,标记采用候选、保留上一版或需要人工判断;视觉审核失败仍不影响生成图片保留。 + +## [1.0.31] - 2026-07-18 + +- 画风逐图识别与交叉共识新增脸型、眼睛/虹膜、鼻口简化、头身比、发束组织、线条拓扑、阴影色相、高光形状和色彩关系等结构画风维度,不再只输出通用动漫渲染标签。 +- 归一化层保留视觉模型返回的 `normalized_asset_profile.attributes`,并为画风自动生成 `must_preserve`;修复结构化属性退化成单一 `legacy_description` 的问题。 +- 内容污染清单仅用于审计,不再原样注入生图负向提示词;改为只排除具体源角色身份、具体服装设计、姿势与场景,避免误伤 Moe 比例、动物耳等风格耦合特征。 +- 修复 detailed 胶囊含逗号语义短语被拆碎、短共识与详细胶囊重复拼接、正负提示词多次重复的问题,并对缺少结构维度的模型自报置信度进行服务端降权。 +- 每张验证图生成后自动使用代表源图进行视觉还原度审核,持久化维度评分、主要匹配/偏差及下一轮修正提示;审核失败不会丢弃已经生成的图片。 +- 进阶画风验证卡片显示自动还原度和主要偏差;视觉模型格式错误新增脱敏后的具体响应问题和解析原因。 + +## [1.0.30] - 2026-07-18 + +- 进阶画风复验会同时提交代表源图、上一轮三张失败验证图、全部源图识别报告、上一版提示词与用户修正,视觉模型可直接进行前后对照。 +- 将“太强、降低、太弱、加强、移除、保持”等反馈解析为 increase/decrease/remove/preserve 结构化方向,并持久化对照清单与实际调整计划。 +- 增加服务端语义防反转;例如“颜色对比太过强烈”不会再被转换为 intense/extreme/high contrast,而会落实为适中克制的对比并排除过强色差。 +- 三张验证生图统一使用 detailed 画风胶囊及其负向约束,不再只使用短共识提示词;仍保持纯文本迁移验证,不向生图模型传递源图。 + - 已完成全仓角色工作流二次审计;确认在现有 `character_gradual` 主线上增量修复,不创建平行工作流。 - 修复队列已按 1.0.9–1.0.20 小版本写入 `docs/workflow-secondary-audit-development-queue.md`。 +## [1.0.29] - 2026-07-17 + +- 进阶素材的画风样本、三张当前验证图、单图源图/验证图以及历史轮次缩略图全部接入统一大图预览卡片。 +- 点击或使用键盘 Enter/空格可打开原图优先的大图预览,支持滚轮缩放、按钮缩放、双击缩放、拖动画布、重置和 Esc 关闭。 +- 大图遮罩继续使用安全单击关闭逻辑,文本拖选、图片拖动或指针移出卡片不会误触关闭。 +- 缩略图增加放大光标、键盘焦点和明确的“点击查看大图”提示。 + +## [1.0.28] - 2026-07-17 + +- 修复进阶画风导入后端使用 `advanced_style_set`、前端只识别 `style_set`,导致三图验证被误判为单图流程且主界面只显示一张验证图的问题。 +- 多图画风当前轮次恢复为头像、全身、跨场景三张验证卡片;三张图分别显示状态、提示词、文字调整和随机种子。 +- 验证轮次列表与详情接口为每一轮附带完整 `validation_cases`,历史轮次也可同时查看三张缩略图,不再只展示聚合轮次的第一张投影图。 +- 兼容旧 `style_set`、正式 `advanced_style_set` 以及服务端 `metadata.style_set` 标记,避免升级前后的记录再次走错前端分支。 + +## [1.0.27] - 2026-07-17 + +- 进阶画风复验拆分为“画风修正”和“下一轮验证内容”两条独立输入:前者只重建画风共识与胶囊,后者直接写入三个验证生图提示词。 +- 修复第二轮强制复用第一轮老年男性、机器人和宇航员场景的问题;用户指定角色、服装、构图或场景后会重建验证案例,且最终 `expanded_prompt` 必定包含用户原文。 +- 只修改画风时继续沿用相同验证场景与种子,便于 A/B 比较;修改验证内容时使用新种子,避免旧构图被随机种子持续锁定。 +- 默认验证改为同一新角色的近域头像、全身和跨场景三级对照,减少角色年龄、物种与写实先验对画风判断的干扰。 +- 验证卡片显示已应用的文字调整和实际种子;历史轮次持久化画风修正、验证内容及其作用范围。 +- 旧客户端继续支持单一 `adjustment_text`,服务端会同时应用到画风与验证内容链路,避免反馈静默丢失。 + +## [1.0.26] - 2026-07-17 + +- 修复任务较多时队列卡片被滚动区域压缩的问题;任务卡改为纵向自然高度排列,状态、标题、进度条与耗时不再相互覆盖。 +- 进阶素材验证轮询改为只更新当前活动导入或导入摘要,不再每 4.5 秒全量刷新导入库与素材库。 +- 增加轮询互斥,防止慢请求发生重叠;轮询失败保持当前页面,不再触发错误态或视觉重置。 +- 图片展示优先使用稳定的 `storage://` URI 缓存,忽略同一媒体每轮变化的临时签名 URL,避免验证生成期间图片反复重载和页面闪烁。 + +## [1.0.25] - 2026-07-17 + +- 修复进阶素材队列记录被手动删除后,导入或样本仍保持 queued/running 并永久卡住的问题;详情读取、列表刷新和重试前会将缺失任务对账为可重试失败。 +- 新增未封存进阶导入删除接口与前端双击确认按钮;删除会先取消残留任务,再级联清理样本、交叉共识、验证轮次和进阶素材独立文件。 +- 已封存为高优先级素材的导入禁止删除,仍需通过素材归档流程处理,避免破坏素材库、衣橱和工作流引用。 +- 缺失队列任务会显示明确提示,可选择单独重试、排除样本或删除整个导入,不再只显示模糊的“待处理样本”。 + +## [1.0.24] - 2026-07-17 + +- 模型分工统一为双源路由:每个文本/视觉节点分别选择 ImageStudio 插件适配器与 AstrBot 模型提供商,执行顺序固定为插件优先、AstrBot 备用。 +- 素材识别、进阶素材识别、多图画风共识、结构化文本调用和生成后视觉审核加入故障转移;前置提供商失败时自动尝试备用,并保留失败摘要。 +- 生图节点明确只选择 ImageStudio 生图适配器;AstrBot 4.25 没有公开生图桥接接口,因此界面禁用不可执行的宿主生图选择,避免保存后运行失败。 +- 进阶画风失败样本重试时重新读取当前双源配置,并同步刷新父导入路由,修复旧 `material_vlm` 被任务永久冻结的问题。 +- 提示词转译、生成前内容审核与生成后图片审核同步使用双选择栏;旧单路由配置保持兼容,双路由继续存为单个 AstrBot 配置字符串。 +- 修正运行时版本常量与发布元数据不同步的问题,状态页和插件元数据统一显示 1.0.24。 + +## [1.0.23] - 2026-07-17 + +- 将内置素材分类的英文名称统一显示为中文,并覆盖进阶素材导入、素材操作和识别提示词设置下拉框。 +- 保留后端分类 ID 与原始名称,兼容现有素材、衣橱和工作流数据。 + +## [1.0.22] - 2026-07-17 + +- 进阶素材的“风格”分类新增 2~8 张样本组导入(推荐 3~6 张);每张图拥有独立任务、计时、错误与重试,并由 8 Worker 同时处理,不再串行共享超时。 +- 新增逐图识别屏障和多图交叉归纳:模型同时读取全部有效原图与逐图报告,区分核心共同画风、可变项、源内容污染、疑似离群样本和 1~3 张代表样本,并生成 compact / standard / detailed 三档画风胶囊。 +- 新增三路纯提示词迁移验证,使用完全不同的角色、场景和构图且不传源图;三项任务独立并发,单项失败可单独重试,调整后创建新共识版本并复用相同验证场景。 +- 新增 `advanced_style_sources`、`advanced_style_consensus_runs`、`advanced_style_validation_cases` 三表;父导入与 2~8 张源记录原子写入,验证图片继续隔离在 `storage://advanced_materials/style-validations`。 +- 前端仅在“风格”分类启用多图上传,支持粘贴、拖入、追加、移除、排序/主参考、失败重试、样本排除与恢复,并展示交叉归纳、代表/离群样本和三场景状态。 +- 封存后仍只产生一个高优先级 `advmat_`;快速角色使用统一文字胶囊,详细工作流冻结主参考与最多两张可信代表图,普通素材伪造 metadata 无法注入额外引用。 +- 备份脱敏、恢复、孤儿媒体、逐场景成本、素材统计、Worker 重启恢复、路由契约和深色主题同步覆盖新链路;付费验证任务重启后不会自动重复提交。 + +## [1.0.21] - 2026-07-16 + +- 新增独立“进阶素材”入库线:源图经 Vision 识别后,只用提取出的文字提示词生成验证图;用户可并排判断还原度,不满意时追加描述进入下一轮,满意后才封存。 +- 新增 `advanced_material_imports`、`advanced_material_validation_attempts`、`advanced_materials` 三表与 `storage://advanced_materials` 独立文件根;验证图不进入普通图库、单图池或工作流候选池。 +- 进阶素材以服务端可信标记进入统一素材目录,快速角色和详细工作流优先使用;普通素材伪造 metadata 不会获得进阶优先级。 +- 验证生图接入恐暴/极端暴力前置禁止、成人内容白名单与 NSFW 路由、普通模型明确 NSFW 拒绝后的一次性回退,以及可保存的独立预算守卫。 +- 修复运行中取消后的迟到结果复活、快速重启任务永久卡住、失败/取消但已计费轮次漏算、脱敏备份写入 NOT NULL 失败和空 MIME 图片误报 PNG。 +- 新增进阶导入、三库切换、任务轮询、原图/验证图并排审核、调整重试、显式封存、深色主题和高优先级标记;模型分工新增进阶识别与验证生图两张卡。 +- 专项覆盖迁移幂等、仓储事务、普通/进阶隔离、无图生图输入、取消 CAS、安全路由、预算、重启恢复、备份、成本与前端上传契约。 + ## [1.0.20] - 2026-07-15 - 发布总验收补齐两处跨版本接线:工作台唯一挂载生成式交叉审查对话框并真实调用 decide/regenerate/approve;档案卡入库移除客户端三段式写入,统一调用后端 `finalize-card` 幂等事务。 diff --git a/_conf_schema.json b/_conf_schema.json index 8527fec..f5f8a78 100644 --- a/_conf_schema.json +++ b/_conf_schema.json @@ -80,6 +80,17 @@ "default": true }, "model_material_recognition": {"description":"素材导入解析使用的 Vision 路由。","type":"string","default":"material_vlm"}, + "model_advanced_material_recognition": {"description":"进阶素材导入与高保真特征提取使用的 Vision 路由。","type":"string","default":"material_vlm"}, + "model_advanced_material_validation_generation": {"description":"进阶素材还原度验证图使用的生图路由。留空时回退到默认生图路由。","type":"string","default":""}, + "advanced_material_budget_enabled": {"description":"启用进阶素材验证图预算守卫。","type":"bool","default":false}, + "advanced_material_budget_days": {"description":"进阶素材预算统计窗口天数。","type":"int","default":30}, + "advanced_material_budget_max_task_count": {"description":"窗口内最大验证任务数;留空表示不限。","type":"string","default":""}, + "advanced_material_budget_max_image_count": {"description":"窗口内最大验证图片数;留空表示不限。","type":"string","default":""}, + "advanced_material_budget_max_estimated_cost": {"description":"窗口内最大估算费用;留空表示不限。","type":"string","default":""}, + "advanced_material_budget_price_key": {"description":"成本计价键,可填写 Provider ID 或模型 ID。","type":"string","default":""}, + "advanced_material_budget_per_request": {"description":"每次验证请求的估算单价。","type":"string","default":"0"}, + "advanced_material_budget_per_image": {"description":"每张验证图片的估算单价。","type":"string","default":"0"}, + "advanced_material_budget_per_1k_tokens": {"description":"每千 Token 的估算单价。","type":"string","default":"0"}, "model_profile_parse": {"description":"外部角色导入解析使用的文本模型路由。","type":"string","default":""}, "model_persona_split": {"description":"角色设定拆解使用的文本模型路由。","type":"string","default":""}, "model_prompt_planning": {"description":"提示词规划与扩写使用的文本模型路由。","type":"string","default":""}, @@ -119,6 +130,11 @@ "type": "string", "default": "data/db/imagestudio.db" }, + "advanced_materials_path": { + "description": "进阶素材原图、验证图与封存文件的独立逻辑目录。", + "type": "string", + "default": "data/advanced_materials" + }, "postgresql_enabled": { "description": "启用 PostgreSQL。填写 DSN 或主机/库名/用户后也会自动按 PG 配置运行。", "type": "bool", diff --git a/backend/dto/advanced_material_dto.py b/backend/dto/advanced_material_dto.py new file mode 100644 index 0000000..15f9c6a --- /dev/null +++ b/backend/dto/advanced_material_dto.py @@ -0,0 +1,316 @@ +"""DTOs for the isolated advanced-material verification library.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any + + +@dataclass(frozen=True) +class AdvancedMaterialImport: + import_id: str + category_id: str | None + display_name: str + source_image_uri: str + source_thumbnail_uri: str | None + status: str + recognition_prompt: str | None + recognition_negative_prompt: str | None + recognition_tags: list[str] + recognition_result: dict[str, Any] + recognition_model_route: str | None + prompt_revision: int + current_attempt_id: str | None + accepted_material_id: str | None + idempotency_key: str | None + created_by: str | None + error: dict[str, Any] + metadata: dict[str, Any] + created_at: str + updated_at: str + + def to_dict(self) -> dict[str, Any]: + return { + "import_id": self.import_id, + "category_id": self.category_id, + "display_name": self.display_name, + "source_image_uri": self.source_image_uri, + "source_thumbnail_uri": self.source_thumbnail_uri, + "status": self.status, + "recognition_prompt": self.recognition_prompt, + "recognition_negative_prompt": self.recognition_negative_prompt, + "recognition_tags": list(self.recognition_tags), + "recognition_result": dict(self.recognition_result), + "recognition_model_route": self.recognition_model_route, + "prompt_revision": self.prompt_revision, + "current_attempt_id": self.current_attempt_id, + "accepted_material_id": self.accepted_material_id, + "idempotency_key": self.idempotency_key, + "created_by": self.created_by, + "error": dict(self.error), + "metadata": dict(self.metadata), + "created_at": self.created_at, + "updated_at": self.updated_at, + } + + +@dataclass(frozen=True) +class AdvancedMaterialValidationAttempt: + attempt_id: str + import_id: str + attempt_number: int + status: str + adjustment_text: str | None + prompt: str + negative_prompt: str | None + model_route: str | None + provider_id: str | None + provider_model: str | None + task_id: str | None + validation_image_uri: str | None + validation_thumbnail_uri: str | None + seed: int | None + width: int | None + height: int | None + usage: dict[str, Any] + fidelity_score: float | None + decision: str | None + decision_notes: str | None + error: dict[str, Any] + metadata: dict[str, Any] + created_at: str + updated_at: str + completed_at: str | None + decided_at: str | None + + def to_dict(self) -> dict[str, Any]: + return { + "attempt_id": self.attempt_id, + "import_id": self.import_id, + "attempt_number": self.attempt_number, + "status": self.status, + "adjustment_text": self.adjustment_text, + "prompt": self.prompt, + "negative_prompt": self.negative_prompt, + "model_route": self.model_route, + "provider_id": self.provider_id, + "provider_model": self.provider_model, + "task_id": self.task_id, + "validation_image_uri": self.validation_image_uri, + "validation_thumbnail_uri": self.validation_thumbnail_uri, + "seed": self.seed, + "width": self.width, + "height": self.height, + "usage": dict(self.usage), + "fidelity_score": self.fidelity_score, + "decision": self.decision, + "decision_notes": self.decision_notes, + "error": dict(self.error), + "metadata": dict(self.metadata), + "created_at": self.created_at, + "updated_at": self.updated_at, + "completed_at": self.completed_at, + "decided_at": self.decided_at, + } + + +@dataclass(frozen=True) +class AdvancedStyleSource: + source_id: str + import_id: str + sort_order: int + is_primary: bool + source_image_uri: str + source_thumbnail_uri: str | None + status: str + recognition_model_route: str | None + provider_id: str | None + provider_model: str | None + task_id: str | None + recognition_prompt: str | None + recognition_negative_prompt: str | None + recognition_tags: list[str] + recognition_result: dict[str, Any] + error: dict[str, Any] + metadata: dict[str, Any] + created_at: str + updated_at: str + completed_at: str | None + excluded_at: str | None + + def to_dict(self) -> dict[str, Any]: + return { + "source_id": self.source_id, + "import_id": self.import_id, + "sort_order": self.sort_order, + "is_primary": self.is_primary, + "source_image_uri": self.source_image_uri, + "source_thumbnail_uri": self.source_thumbnail_uri, + "status": self.status, + "recognition_model_route": self.recognition_model_route, + "provider_id": self.provider_id, + "provider_model": self.provider_model, + "task_id": self.task_id, + "recognition_prompt": self.recognition_prompt, + "recognition_negative_prompt": self.recognition_negative_prompt, + "recognition_tags": list(self.recognition_tags), + "recognition_result": dict(self.recognition_result), + "error": dict(self.error), + "metadata": dict(self.metadata), + "created_at": self.created_at, + "updated_at": self.updated_at, + "completed_at": self.completed_at, + "excluded_at": self.excluded_at, + } + + +@dataclass(frozen=True) +class AdvancedStyleConsensusRun: + consensus_id: str + import_id: str + revision: int + status: str + task_id: str | None + model_route: str | None + provider_id: str | None + provider_model: str | None + source_ids: list[str] + prompt: str | None + negative_prompt: str | None + tags: list[str] + result: dict[str, Any] + error: dict[str, Any] + metadata: dict[str, Any] + created_at: str + updated_at: str + completed_at: str | None + + def to_dict(self) -> dict[str, Any]: + return { + "consensus_id": self.consensus_id, + "import_id": self.import_id, + "revision": self.revision, + "status": self.status, + "task_id": self.task_id, + "model_route": self.model_route, + "provider_id": self.provider_id, + "provider_model": self.provider_model, + "source_ids": list(self.source_ids), + "prompt": self.prompt, + "negative_prompt": self.negative_prompt, + "tags": list(self.tags), + "result": dict(self.result), + "error": dict(self.error), + "metadata": dict(self.metadata), + "created_at": self.created_at, + "updated_at": self.updated_at, + "completed_at": self.completed_at, + } + + +@dataclass(frozen=True) +class AdvancedStyleValidationCase: + case_id: str + attempt_id: str + import_id: str + case_key: str + sort_order: int + status: str + task_id: str | None + content_prompt: str + final_prompt: str + negative_prompt: str | None + model_route: str | None + provider_id: str | None + provider_model: str | None + seed: int | None + width: int | None + height: int | None + validation_image_uri: str | None + validation_thumbnail_uri: str | None + usage: dict[str, Any] + style_review: dict[str, Any] + fidelity_score: float | None + error: dict[str, Any] + metadata: dict[str, Any] + created_at: str + updated_at: str + completed_at: str | None + + def to_dict(self) -> dict[str, Any]: + return { + "case_id": self.case_id, + "attempt_id": self.attempt_id, + "import_id": self.import_id, + "case_key": self.case_key, + "sort_order": self.sort_order, + "status": self.status, + "task_id": self.task_id, + "content_prompt": self.content_prompt, + "final_prompt": self.final_prompt, + "negative_prompt": self.negative_prompt, + "model_route": self.model_route, + "provider_id": self.provider_id, + "provider_model": self.provider_model, + "seed": self.seed, + "width": self.width, + "height": self.height, + "validation_image_uri": self.validation_image_uri, + "validation_thumbnail_uri": self.validation_thumbnail_uri, + "usage": dict(self.usage), + "style_review": dict(self.style_review), + "fidelity_score": self.fidelity_score, + "error": dict(self.error), + "metadata": dict(self.metadata), + "created_at": self.created_at, + "updated_at": self.updated_at, + "completed_at": self.completed_at, + } + + +@dataclass(frozen=True) +class AdvancedMaterial: + material_id: str + import_id: str + accepted_attempt_id: str + category_id: str | None + display_name: str + source_image_uri: str + source_thumbnail_uri: str | None + validation_image_uri: str + validation_thumbnail_uri: str | None + prompt: str + negative_prompt: str | None + tags: list[str] + priority: int + status: str + capsule: dict[str, Any] + metadata: dict[str, Any] + accepted_at: str + archived_at: str | None + created_at: str + updated_at: str + + def to_dict(self) -> dict[str, Any]: + return { + "material_id": self.material_id, + "import_id": self.import_id, + "accepted_attempt_id": self.accepted_attempt_id, + "category_id": self.category_id, + "display_name": self.display_name, + "source_image_uri": self.source_image_uri, + "source_thumbnail_uri": self.source_thumbnail_uri, + "validation_image_uri": self.validation_image_uri, + "validation_thumbnail_uri": self.validation_thumbnail_uri, + "prompt": self.prompt, + "negative_prompt": self.negative_prompt, + "tags": list(self.tags), + "priority": self.priority, + "status": self.status, + "capsule": dict(self.capsule), + "metadata": dict(self.metadata), + "accepted_at": self.accepted_at, + "archived_at": self.archived_at, + "created_at": self.created_at, + "updated_at": self.updated_at, + } diff --git a/backend/dto/wardrobe_dto.py b/backend/dto/wardrobe_dto.py index 088f6c2..6738f61 100644 --- a/backend/dto/wardrobe_dto.py +++ b/backend/dto/wardrobe_dto.py @@ -20,6 +20,7 @@ class WardrobeItem: last_used_at: str | None created_at: str updated_at: str + library_kind: str = "standard" def to_dict(self) -> dict[str, Any]: return { @@ -35,4 +36,5 @@ class WardrobeItem: "last_used_at": self.last_used_at, "created_at": self.created_at, "updated_at": self.updated_at, + "library_kind": self.library_kind, } diff --git a/backend/route_registry.py b/backend/route_registry.py index f597aa4..c4d2a92 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -168,6 +168,110 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("GET", "media/orphans", "backend.routes.media_routes.scan_orphan_media", "read"), RouteSpec("GET", "media/payload", "backend.routes.media_routes.fetch_media_payload", "read"), RouteSpec("GET", "media/fetch", "backend.routes.media_routes.fetch_media", "public_token"), + RouteSpec( + "GET", + "advanced-material-imports", + "backend.routes.advanced_material_routes.list_advanced_material_imports", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/upload", + "backend.routes.advanced_material_routes.upload_advanced_material", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/style-set/upload", + "backend.routes.advanced_material_routes.upload_advanced_style_set", + "materials", + ), + RouteSpec( + "GET", + "advanced-material-imports/{import_id}", + "backend.routes.advanced_material_routes.get_advanced_material_import", + "materials", + ), + RouteSpec( + "DELETE", + "advanced-material-imports/{import_id}", + "backend.routes.advanced_material_routes.delete_advanced_material_import", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/retry", + "backend.routes.advanced_material_routes.retry_advanced_material_import", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/style-sources/{source_id}/retry", + "backend.routes.advanced_material_routes.retry_advanced_style_source", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/style-sources/{source_id}/exclude", + "backend.routes.advanced_material_routes.exclude_advanced_style_source", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/style-consensus", + "backend.routes.advanced_material_routes.create_advanced_style_consensus", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/style-validation-cases/{case_id}/retry", + "backend.routes.advanced_material_routes.retry_advanced_style_validation_case", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/cancel", + "backend.routes.advanced_material_routes.cancel_advanced_material_import", + "materials", + ), + RouteSpec( + "GET", + "advanced-material-imports/{import_id}/validation-attempts", + "backend.routes.advanced_material_routes.list_advanced_material_attempts", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/validation-attempts", + "backend.routes.advanced_material_routes.create_advanced_material_attempt", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/attempts/{attempt_id}/reject", + "backend.routes.advanced_material_routes.reject_advanced_material_attempt", + "materials", + ), + RouteSpec( + "POST", + "advanced-material-imports/{import_id}/attempts/{attempt_id}/accept", + "backend.routes.advanced_material_routes.accept_advanced_material_attempt", + "materials", + ), + RouteSpec("GET", "advanced-materials", "backend.routes.advanced_material_routes.list_advanced_materials", "read"), + RouteSpec( + "GET", + "advanced-materials/{material_id}", + "backend.routes.advanced_material_routes.get_advanced_material", + "read", + ), + RouteSpec( + "DELETE", + "advanced-materials/{material_id}", + "backend.routes.advanced_material_routes.archive_advanced_material", + "materials", + ), + RouteSpec("GET", "material-catalog", "backend.routes.advanced_material_routes.list_material_catalog", "read"), RouteSpec("GET", "material-categories", "backend.routes.material_routes.list_material_categories", "read"), RouteSpec("POST", "material-categories", "backend.routes.material_routes.create_material_category", "materials"), RouteSpec( diff --git a/backend/routes/advanced_material_routes.py b/backend/routes/advanced_material_routes.py new file mode 100644 index 0000000..d8ede71 --- /dev/null +++ b/backend/routes/advanced_material_routes.py @@ -0,0 +1,435 @@ +"""HTTP handlers for the isolated advanced-material workflow.""" + +from __future__ import annotations + +from typing import Any + +from backend.routes.common import handle_request +from backend.routes.params import int_or_default, optional_str +from backend.services.advanced_material_service import ( + AdvancedMaterialService, + create_advanced_material_service, +) +from backend.services.media_service import MediaService +from core.identity import RequestContext +from core.security import require_authenticated, require_permission + + +def list_advanced_material_imports( + ctx: RequestContext, + query: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + params = query or {} + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + payload = resolved.list_imports( + status=optional_str(params.get("status")), + page=int_or_default(params.get("page"), 1), + page_size=int_or_default(params.get("page_size"), 30), + ) + return _serialize_import_list(payload) + + return handle_request(ctx, action) + + +def upload_advanced_material( + ctx: RequestContext, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.upload(payload or {}, ctx)) + + return handle_request(ctx, action) + + +def upload_advanced_style_set( + ctx: RequestContext, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + """Create one style-only multi-image import and enqueue every source.""" + + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.upload_style_set(payload or {}, ctx)) + + return handle_request(ctx, action) + + +def get_advanced_material_import( + ctx: RequestContext, + import_id: str, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.get_import(import_id)) + + return handle_request(ctx, action) + + +def delete_advanced_material_import( + ctx: RequestContext, + import_id: str, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return resolved.delete_import(import_id, ctx) + + return handle_request(ctx, action) + + +def retry_advanced_material_import( + ctx: RequestContext, + import_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + del payload + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.retry_import(import_id, ctx)) + + return handle_request(ctx, action) + + +def retry_advanced_style_source( + ctx: RequestContext, + import_id: str, + source_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + del payload + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.retry_style_source(import_id, source_id, ctx)) + + return handle_request(ctx, action) + + +def exclude_advanced_style_source( + ctx: RequestContext, + import_id: str, + source_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + excluded = bool((payload or {}).get("excluded", True)) + return _serialize_payload(resolved.exclude_style_source(import_id, source_id, excluded, ctx)) + + return handle_request(ctx, action) + + +def create_advanced_style_consensus( + ctx: RequestContext, + import_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.create_style_consensus(import_id, payload or {}, ctx)) + + return handle_request(ctx, action) + + +def retry_advanced_style_validation_case( + ctx: RequestContext, + import_id: str, + case_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + del payload + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.retry_style_validation_case(import_id, case_id, ctx)) + + return handle_request(ctx, action) + + +def cancel_advanced_material_import( + ctx: RequestContext, + import_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + del payload + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.cancel_import(import_id, ctx)) + + return handle_request(ctx, action) + + +def list_advanced_material_attempts( + ctx: RequestContext, + import_id: str, + query: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + del query + resolved = service or create_advanced_material_service() + + def action() -> list[dict[str, Any]]: + require_permission(ctx, "can_manage_materials") + return [_serialize_attempt(item) for item in resolved.list_attempts(import_id)] + + return handle_request(ctx, action) + + +def create_advanced_material_attempt( + ctx: RequestContext, + import_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.create_validation_attempt(import_id, payload or {}, ctx)) + + return handle_request(ctx, action) + + +def reject_advanced_material_attempt( + ctx: RequestContext, + import_id: str, + attempt_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.reject_attempt(import_id, attempt_id, payload or {}, ctx)) + + return handle_request(ctx, action) + + +def accept_advanced_material_attempt( + ctx: RequestContext, + import_id: str, + attempt_id: str, + payload: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_payload(resolved.accept_attempt(import_id, attempt_id, payload or {}, ctx)) + + return handle_request(ctx, action) + + +def list_advanced_materials( + ctx: RequestContext, + query: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + params = query or {} + + def action() -> dict[str, Any]: + require_authenticated(ctx) + payload = resolved.list_materials( + page=int_or_default(params.get("page"), 1), + page_size=int_or_default(params.get("page_size"), 30), + ) + return _serialize_material_list(payload) + + return handle_request(ctx, action) + + +def get_advanced_material( + ctx: RequestContext, + material_id: str, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_authenticated(ctx) + return _serialize_material(resolved.get_material(material_id).to_dict()) + + return handle_request(ctx, action) + + +def archive_advanced_material( + ctx: RequestContext, + material_id: str, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + + def action() -> dict[str, Any]: + require_permission(ctx, "can_manage_materials") + return _serialize_material(resolved.archive_material(material_id, ctx).to_dict()) + + return handle_request(ctx, action) + + +def list_material_catalog( + ctx: RequestContext, + query: dict[str, Any] | None = None, + service: AdvancedMaterialService | None = None, +) -> dict: + resolved = service or create_advanced_material_service() + params = query or {} + + def action() -> dict[str, Any]: + require_authenticated(ctx) + payload = resolved.list_catalog( + page=int_or_default(params.get("page"), 1), + page_size=int_or_default(params.get("page_size"), 100), + ) + payload["items"] = [ + _serialize_material(item) if item.get("library_kind") == "advanced" else _serialize_standard_material(item) + for item in payload.get("items", []) + ] + return payload + + return handle_request(ctx, action) + + +def _serialize_import_list(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "items": [_serialize_import(item) for item in payload.get("items", [])], + } + + +def _serialize_material_list(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "items": [_serialize_material(item) for item in payload.get("items", [])], + } + + +def _serialize_payload(payload: Any) -> Any: + if isinstance(payload, list): + return [_serialize_payload(item) for item in payload] + if not isinstance(payload, dict): + return payload + result = {key: _serialize_payload(value) for key, value in payload.items()} + if "source_id" in result and "source_image_uri" in result: + return _serialize_style_source(result) + if "case_id" in result and "validation_image_uri" in result: + return _serialize_style_validation_case(result) + if "import_id" in result and "source_image_uri" in result: + return _serialize_import(result) + if "attempt_id" in result and "validation_image_uri" in result: + return _serialize_attempt(result) + if str(result.get("material_id") or "").startswith("advmat_"): + return _serialize_material(result) + return result + + +def _serialize_import(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "source_image_url": _signed_url(payload.get("source_image_uri")), + "source_thumbnail_url": _signed_url(payload.get("source_thumbnail_uri")), + } + + +def _serialize_attempt(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + **( + { + "validation_cases": [ + _serialize_style_validation_case(item) + for item in payload.get("validation_cases", []) + if isinstance(item, dict) + ] + } + if isinstance(payload.get("validation_cases"), list) + else {} + ), + "validation_image_url": _signed_url(payload.get("validation_image_uri")), + "validation_thumbnail_url": _signed_url(payload.get("validation_thumbnail_uri")), + } + + +def _serialize_style_source(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "source_image_url": _signed_url(payload.get("source_image_uri")), + "source_thumbnail_url": _signed_url(payload.get("source_thumbnail_uri")), + } + + +def _serialize_style_validation_case(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "validation_image_url": _signed_url(payload.get("validation_image_uri")), + "validation_thumbnail_url": _signed_url(payload.get("validation_thumbnail_uri")), + } + + +def _serialize_material(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "library_kind": "advanced", + "source_image_url": _signed_url(payload.get("source_image_uri")), + "source_thumbnail_url": _signed_url(payload.get("source_thumbnail_uri")), + "validation_image_url": _signed_url(payload.get("validation_image_uri")), + "validation_thumbnail_url": _signed_url(payload.get("validation_thumbnail_uri")), + "image_uri": payload.get("source_image_uri"), + "thumbnail_uri": payload.get("source_thumbnail_uri"), + "image_url": _signed_url(payload.get("source_image_uri")), + "thumbnail_url": _signed_url(payload.get("source_thumbnail_uri")), + "recognition_status": "confirmed", + } + + +def _serialize_standard_material(payload: dict[str, Any]) -> dict[str, Any]: + return { + **payload, + "library_kind": "standard", + "image_url": _signed_url(payload.get("image_uri")), + "thumbnail_url": _signed_url(payload.get("thumbnail_uri")), + } + + +def _signed_url(uri: Any) -> str | None: + text = str(uri or "").strip() + if not text: + return None + try: + return MediaService().sign_media(text)["url"] + except Exception: + return None diff --git a/backend/routes/integration_routes.py b/backend/routes/integration_routes.py index 4cb57a4..06a742f 100644 --- a/backend/routes/integration_routes.py +++ b/backend/routes/integration_routes.py @@ -7,16 +7,18 @@ from typing import Any from backend.routes.common import handle_request from backend.services.integration_service import IntegrationService from backend.services.integration_token_service import IntegrationTokenService +from backend.services.material_catalog_resolver import MaterialCatalogResolver from backend.services.wardrobe_service import WardrobeService from core.audit_service import AuditService from core.config_service import ConfigService from core.identity import RequestContext from core.security import require_authenticated, require_config_manager from database.db_helper import Database, load_database_settings +from database.repositories.advanced_material_repository import AdvancedMaterialRepository from database.repositories.integration_repository import IntegrationRepository from database.repositories.material_repository import MaterialRepository from database.repositories.profile_repository import ProfileRepository -from database.repositories.wardrobe_repository import WardrobeRepository +from database.repositories.wardrobe_repository import AdvancedWardrobeRepository, WardrobeRepository def private_companion_daily_outfit( @@ -82,11 +84,15 @@ def _create_integration_service() -> IntegrationService: database = Database(load_database_settings()) audit_service = AuditService(database) config_service = ConfigService() + materials = MaterialRepository(database) + advanced_materials = AdvancedMaterialRepository(database) wardrobe_service = WardrobeService( wardrobe_repository=WardrobeRepository(database), profile_repository=ProfileRepository(database), - material_repository=MaterialRepository(database), + material_repository=materials, audit_service=audit_service, + advanced_wardrobe_repository=AdvancedWardrobeRepository(database), + material_catalog=MaterialCatalogResolver(materials, advanced_materials), ) return IntegrationService( wardrobe_service=wardrobe_service, diff --git a/backend/routes/job_routes.py b/backend/routes/job_routes.py index 3111d78..7b7d9c3 100644 --- a/backend/routes/job_routes.py +++ b/backend/routes/job_routes.py @@ -11,7 +11,7 @@ from backend.services.generation_job_retry_service import GenerationJobRetryServ from backend.services.queue_service import QueueService from core.audit_service import AuditService from core.identity import RequestContext -from core.security import require_authenticated, require_task_retry, require_write +from core.security import require_authenticated, require_permission, require_task_retry, require_write from database.db_helper import Database, load_database_settings from database.repositories.job_repository import JobRepository @@ -26,13 +26,17 @@ def list_jobs( def action() -> dict[str, Any]: require_authenticated(ctx) - return queue_service.list_jobs( + result = queue_service.list_jobs( status=optional_str(params.get("status")), workflow_id=optional_str(params.get("workflow_id")), profile_id=optional_str(params.get("profile_id")), page=int_or_default(params.get("page"), 1), page_size=int_or_default(params.get("page_size"), 30), ).to_dict() + if not ctx.has_permission("can_manage_materials"): + visible = [item for item in result["items"] if item.get("metadata", {}).get("source") != "advanced_material"] + result = {**result, "items": visible, "total": max(int(result.get("total") or 0) - (len(result["items"]) - len(visible)), 0)} + return result return handle_request(ctx, action) @@ -46,7 +50,10 @@ def get_job( def action() -> dict[str, Any]: require_authenticated(ctx) - return queue_service.get_job(task_id).to_dict() + task = queue_service.get_job(task_id) + if task.metadata.get("source") == "advanced_material": + require_permission(ctx, "can_manage_materials") + return task.to_dict() return handle_request(ctx, action) @@ -74,6 +81,13 @@ def cancel_job( def action() -> dict[str, Any]: require_write(ctx) + task = queue_service.get_job(task_id) + if task.metadata.get("source") == "advanced_material": + require_permission(ctx, "can_manage_materials") + from backend.services.advanced_material_service import create_advanced_material_service + + import_id = str(task.metadata.get("advanced_material_import_id") or "").strip() + return create_advanced_material_service().cancel_import(import_id, ctx) return queue_service.cancel_job(task_id, ctx).to_dict() return handle_request(ctx, action) @@ -85,11 +99,20 @@ def retry_job( payload: dict[str, Any] | None = None, service: GenerationJobRetryService | None = None, ) -> dict: - retry_service = service or _create_generation_job_retry_service() + retry_service = service def action() -> dict[str, Any]: require_task_retry(ctx) - return retry_service.retry_job(task_id, ctx, overrides=payload or {}).to_dict() + queue_service = _create_queue_service() + task = queue_service.get_job(task_id) + if task.metadata.get("source") == "advanced_material": + require_permission(ctx, "can_manage_materials") + from backend.services.advanced_material_service import create_advanced_material_service + + import_id = str(task.metadata.get("advanced_material_import_id") or "").strip() + return create_advanced_material_service().retry_import(import_id, ctx) + resolved_retry_service = retry_service or _create_generation_job_retry_service() + return resolved_retry_service.retry_job(task_id, ctx, overrides=payload or {}).to_dict() return handle_request(ctx, action) diff --git a/backend/routes/model_runtime_routes.py b/backend/routes/model_runtime_routes.py index 65f29d3..2b6d16b 100644 --- a/backend/routes/model_runtime_routes.py +++ b/backend/routes/model_runtime_routes.py @@ -3,14 +3,34 @@ from __future__ import annotations from backend.routes.common import handle_request +from backend.services.model_provider_service import ModelProviderService from core.astrbot_provider_bridge import list_astrbot_text_models from core.identity import RequestContext from core.security import require_authenticated +from database.db_helper import Database, load_database_settings +from database.repositories.model_provider_repository import ModelProviderRepository -def list_runtime_models(ctx: RequestContext) -> dict: +def list_runtime_models(ctx: RequestContext, service: ModelProviderService | None = None) -> dict: + model_service = service or ModelProviderService(ModelProviderRepository(Database(load_database_settings()))) + def action() -> dict: require_authenticated(ctx) - return {"items": list_astrbot_text_models()} + plugin_items: list[dict[str, str]] = [] + providers = {item["provider_id"]: item for item in model_service.list_providers(enabled=True)} + for route in model_service.list_routes(enabled=True): + provider_id = str(route.get("provider_id") or "") + provider = providers.get(provider_id) or {} + plugin_items.append( + { + "route": str(route.get("route_name") or ""), + "provider_id": provider_id, + "name": str(provider.get("display_name") or provider_id), + "model": str(route.get("model_id") or ""), + "modality": str(route.get("modality") or ""), + "source": "plugin", + } + ) + return {"items": [*plugin_items, *list_astrbot_text_models()]} return handle_request(ctx, action) diff --git a/backend/routes/node_material_routes.py b/backend/routes/node_material_routes.py index 6e73fdf..d479c54 100644 --- a/backend/routes/node_material_routes.py +++ b/backend/routes/node_material_routes.py @@ -6,6 +6,7 @@ from typing import Any from backend.routes.common import handle_request from backend.services.resource_access_service import ResourceAccessService +from backend.services.material_catalog_resolver import MaterialCatalogResolver from backend.services.workflow_node_material_service import WorkflowNodeMaterialService from backend.services.workflow_service import WorkflowService from core.audit_service import AuditService @@ -13,6 +14,7 @@ from core.identity import RequestContext from core.security import require_authenticated, require_write from database.db_helper import Database, load_database_settings from database.repositories.image_repository import ImageRepository +from database.repositories.advanced_material_repository import AdvancedMaterialRepository from database.repositories.job_repository import JobRepository from database.repositories.material_repository import MaterialRepository from database.repositories.profile_repository import ProfileRepository @@ -71,7 +73,10 @@ def _create_service() -> WorkflowNodeMaterialService: ) return WorkflowNodeMaterialService( workflow_service, - MaterialRepository(database), + MaterialCatalogResolver( + MaterialRepository(database), + AdvancedMaterialRepository(database), + ), round_repository=WorkflowRoundRepository(database), access_service=ResourceAccessService( profiles, diff --git a/backend/routes/node_routes.py b/backend/routes/node_routes.py index 9ec7ff2..6cd4bf3 100644 --- a/backend/routes/node_routes.py +++ b/backend/routes/node_routes.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_runtime import ModelProviderRuntime +from backend.services.material_catalog_resolver import MaterialCatalogResolver 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 @@ -39,6 +40,7 @@ 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.advanced_material_repository import AdvancedMaterialRepository from database.repositories.job_repository import JobRepository from database.repositories.material_repository import MaterialRepository from database.repositories.model_provider_repository import ModelProviderRepository @@ -315,6 +317,10 @@ def _create_generation_service() -> GenerationService: audit_service = AuditService(database) workflow_repository = WorkflowRepository(database) material_repository = MaterialRepository(database) + material_catalog = MaterialCatalogResolver( + material_repository, + AdvancedMaterialRepository(database), + ) event_bus = get_default_event_bus() model_provider_service = ModelProviderService(ModelProviderRepository(database)) model_provider_runtime = ModelProviderRuntime(model_provider_service) @@ -370,10 +376,10 @@ def _create_generation_service() -> GenerationService: 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_resolver=material_catalog, material_snapshot_service=WorkflowMaterialSnapshotService( workflow_repository, - material_repository, + material_catalog, ), model_assignments=model_assignments, prompt_translation_service=PromptTranslationService(translation_config, translation_callable), diff --git a/backend/routes/wardrobe_routes.py b/backend/routes/wardrobe_routes.py index e324f02..8d2531c 100644 --- a/backend/routes/wardrobe_routes.py +++ b/backend/routes/wardrobe_routes.py @@ -7,13 +7,15 @@ from typing import Any from backend.routes.common import handle_request from backend.routes.params import optional_str from backend.services.wardrobe_service import WardrobeService +from backend.services.material_catalog_resolver import MaterialCatalogResolver from core.audit_service import AuditService from core.identity import RequestContext from core.security import require_authenticated, require_permission from database.db_helper import Database, load_database_settings +from database.repositories.advanced_material_repository import AdvancedMaterialRepository from database.repositories.material_repository import MaterialRepository from database.repositories.profile_repository import ProfileRepository -from database.repositories.wardrobe_repository import WardrobeRepository +from database.repositories.wardrobe_repository import AdvancedWardrobeRepository, WardrobeRepository def list_wardrobe_items( @@ -106,9 +108,13 @@ def apply_wardrobe_template(ctx: RequestContext, profile_id: str, template_id: s def _create_wardrobe_service() -> WardrobeService: database = Database(load_database_settings()) + materials = MaterialRepository(database) + advanced_materials = AdvancedMaterialRepository(database) return WardrobeService( wardrobe_repository=WardrobeRepository(database), profile_repository=ProfileRepository(database), - material_repository=MaterialRepository(database), + material_repository=materials, audit_service=AuditService(database), + advanced_wardrobe_repository=AdvancedWardrobeRepository(database), + material_catalog=MaterialCatalogResolver(materials, advanced_materials), ) diff --git a/backend/services/advanced_material_service.py b/backend/services/advanced_material_service.py new file mode 100644 index 0000000..42d860f --- /dev/null +++ b/backend/services/advanced_material_service.py @@ -0,0 +1,1832 @@ +"""Verified advanced-material import and validation workflow. + +Advanced materials intentionally use their own tables and VFS root. The +source image is recognized first, then the recognized text (and only that +text) is rendered once so a human can judge whether the description is +faithful enough to seal into the high-priority material catalog. +""" + +from __future__ import annotations + +from dataclasses import replace +from pathlib import Path, PurePosixPath +from typing import Any +from uuid import uuid4 + +from backend.dto.common import ApiError, ErrorCode +from backend.dto.job_dto import GenerationTask +from backend.dto.material_dto import Material +from backend.dto.workflow_dto import WorkflowNode +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.material_normalization_service import ( + MaterialNormalizationError, + MaterialNormalizationService, +) +from backend.services.material_service import ( + MAX_UPLOAD_BYTES, + _decode_upload_data_url, + _display_name_from_filename, + _normalize_upload_content_type, + _normalize_upload_filename, + _normalize_upload_metadata, + _normalize_upload_size, + _recognition_metadata, + _storage_image_data_url, + _suffix, + _vision_provider_error, +) +from backend.services.model_provider_bootstrap import ( + sync_generation_provider_from_config, + sync_vision_provider_from_config, +) +from backend.services.model_provider_runtime import ModelProviderRuntime +from backend.services.model_provider_service import ModelProviderService +from backend.services.queue_service import QueueService +from backend.services.prompt_governance_service import ( + GenerationFailureClassifier, + GenerationRouteService, + PromptModerationDecision, + PromptModerationService, +) +from backend.services.worker_service import WorkerTaskUpdate +from backend.services.advanced_style_set_service import AdvancedStyleSetService +from core.audit_service import AuditService +from core.astrbot_provider_bridge import astrbot_structured_text_callable +from core.identity import RequestContext +from core.image_formats import detect_image_format +from core.storage import VfsStorage +from database.db_helper import Database, load_config_payload, load_database_settings +from database.repositories.advanced_material_repository import AdvancedMaterialRepository +from database.repositories.job_repository import JobRepository +from database.repositories.material_repository import MaterialRepository +from database.repositories.model_provider_repository import ModelProviderRepository +from engines.image_provider import ImageProviderError +from engines.single_flow import SingleFlowEngine +from engines.vision_provider import VisionProviderError, VisionRecognitionRequest + + +IMPORT_ACTIVE_STATUSES = {"recognition_queued", "recognizing", "validation_queued", "validating"} +IMPORT_REVIEW_STATUSES = {"awaiting_review", "adjustment_required"} +ATTEMPT_ACTIVE_STATUSES = {"queued", "running"} +ADVANCED_MATERIAL_PRIORITY = 100 +DEFAULT_VALIDATION_SEED = 240719 + + +class AdvancedMaterialTaskCancelled(RuntimeError): + """Raised when a late provider result no longer owns its import.""" + + +class AdvancedMaterialService: + def __init__( + self, + repository: AdvancedMaterialRepository, + material_repository: MaterialRepository, + queue_service: QueueService, + audit_service: AuditService, + model_provider_service: ModelProviderService, + model_provider_runtime: ModelProviderRuntime, + *, + config: dict[str, Any] | None = None, + storage: VfsStorage | None = None, + normalization_service: MaterialNormalizationService | None = None, + single_flow_engine: SingleFlowEngine | None = None, + prompt_moderation_service: PromptModerationService | None = None, + generation_route_service: GenerationRouteService | None = None, + cost_guard_service: CostGuardService | None = None, + failure_classifier: GenerationFailureClassifier | None = None, + ): + self.repository = repository + self.material_repository = material_repository + self.queue_service = queue_service + self.audit_service = audit_service + self.model_provider_service = model_provider_service + self.model_provider_runtime = model_provider_runtime + self.config = config or {} + self.storage = storage or VfsStorage() + self.normalization_service = normalization_service or MaterialNormalizationService() + self.prompt_moderation_service = prompt_moderation_service + self.generation_route_service = generation_route_service + self.cost_guard_service = cost_guard_service + self.failure_classifier = failure_classifier or GenerationFailureClassifier() + self.single_flow_engine = single_flow_engine or SingleFlowEngine( + storage=self.storage, + image_provider_factory=self.model_provider_runtime.image_provider_for_route, + allow_mock_fallback=False, + ) + self.style_sets = AdvancedStyleSetService(self) + + def upload(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: + import_id = f"advimp_{uuid4().hex}" + filename = _normalize_upload_filename(payload.get("filename")) + content_type = _normalize_upload_content_type(payload.get("content_type")) + declared_size = _normalize_upload_size(payload) + upload_metadata = _normalize_upload_metadata(payload.get("metadata")) + source_uri, detected_type, size_bytes, original_filename = self._persist_source( + import_id=import_id, + image_data_url=str(payload.get("image_data_url") or "").strip(), + image_uri=str(payload.get("image_uri") or "").strip(), + filename=filename, + declared_content_type=content_type, + declared_size=declared_size, + ) + display_name = str( + payload.get("display_name") + or _display_name_from_filename(original_filename) + or "进阶素材" + ).strip() + category_id = _optional_text(payload.get("category_id")) + if category_id and self.material_repository.get_category(category_id) is None: + self._remove_uri(source_uri) + raise ApiError( + ErrorCode.RESOURCE_NOT_FOUND, + "material category not found", + {"category_id": category_id}, + ) + recognition_route = _optional_text(payload.get("recognition_model_route")) or self._recognition_route() + generation_route = _optional_text(payload.get("generation_model_route")) or self._generation_route() + try: + record = self.repository.create_import( + { + "import_id": import_id, + "category_id": category_id, + "display_name": display_name, + "source_image_uri": source_uri, + "source_thumbnail_uri": source_uri, + "status": "recognition_queued", + "recognition_model_route": recognition_route, + "prompt_revision": 0, + "created_by": ctx.actor_id, + "metadata": { + "upload": { + **upload_metadata, + "filename": original_filename, + "content_type": detected_type, + "size_bytes": size_bytes, + "source": str(payload.get("upload_source") or "file"), + "storage_root": "advanced_materials", + }, + "generation_model_route": generation_route, + "governance_context": _governance_context(self.config, ctx), + "material_tier": "advanced_pending", + }, + } + ) + except Exception: + self._remove_uri(source_uri) + raise + try: + task = self._queue_recognition(record, ctx) + except Exception as exc: + self.repository.update_import( + record.import_id, + {"status": "recognition_failed", "error": _safe_failure(exc)}, + ) + raise + self.audit_service.record( + ctx=ctx, + action="upload_advanced_material", + target_type="advanced_material_import", + target_id=record.import_id, + after_snapshot=record.to_dict(), + metadata={"task_id": task.task_id}, + ) + return {"import": self.repository.get_import(record.import_id).to_dict(), "task": task.to_dict()} + + def upload_style_set(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: + return self.style_sets.upload(payload, ctx) + + def list_imports( + self, + *, + status: str | None = None, + page: int = 1, + page_size: int = 30, + ) -> dict[str, Any]: + items, total = self.repository.list_imports( + status=status, + page=max(int(page or 1), 1), + page_size=min(max(int(page_size or 30), 1), 100), + ) + reconciled = [self._reconcile_import_task(item) for item in items] + return { + "items": [item.to_dict() for item in reconciled], + "total": total, + "page": max(int(page or 1), 1), + "page_size": min(max(int(page_size or 30), 1), 100), + } + + def get_import(self, import_id: str) -> dict[str, Any]: + record = self._reconcile_import_task(self._require_import(import_id)) + attempts = self.repository.list_attempts(import_id) + is_style_set = self.style_sets.is_style_set(record) + style_detail = self.style_sets.detail(record) if is_style_set else {} + attempt_payloads = [ + { + **attempt.to_dict(), + **( + { + "validation_cases": [ + case.to_dict() + for case in self.repository.list_style_validation_cases(attempt.attempt_id) + ] + } + if is_style_set + else {} + ), + } + for attempt in attempts + ] + import_payload = { + **record.to_dict(), + **( + { + "style_set": True, + "sources": style_detail.get("sources", []), + "consensus": style_detail.get("consensus"), + "consensus_history": style_detail.get("consensus_history", []), + "validation_cases": style_detail.get("validation_cases", []), + } + if style_detail + else {} + ), + } + return { + **style_detail, + "import": import_payload, + "attempts": attempt_payloads, + "accepted_material": ( + self.repository.get_material(record.accepted_material_id).to_dict() + if record.accepted_material_id and self.repository.get_material(record.accepted_material_id) + else None + ), + } + + def retry_style_source(self, import_id: str, source_id: str, ctx: RequestContext) -> dict[str, Any]: + return self.style_sets.retry_source(import_id, source_id, ctx) + + def exclude_style_source( + self, + import_id: str, + source_id: str, + excluded: bool, + ctx: RequestContext, + ) -> dict[str, Any]: + return self.style_sets.exclude_source(import_id, source_id, excluded, ctx) + + def create_style_consensus( + self, + import_id: str, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + return self.style_sets.create_consensus(import_id, payload, ctx) + + def retry_style_validation_case(self, import_id: str, case_id: str, ctx: RequestContext) -> dict[str, Any]: + return self.style_sets.retry_validation_case(import_id, case_id, ctx) + + def list_attempts(self, import_id: str) -> list[dict[str, Any]]: + record = self._require_import(import_id) + is_style_set = self.style_sets.is_style_set(record) + return [ + { + **attempt.to_dict(), + **( + { + "validation_cases": [ + case.to_dict() + for case in self.repository.list_style_validation_cases(attempt.attempt_id) + ] + } + if is_style_set + else {} + ), + } + for attempt in self.repository.list_attempts(import_id) + ] + + def create_validation_attempt( + self, + import_id: str, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + record = self._require_import(import_id) + if self.style_sets.is_style_set(record): + return self.style_sets.ensure_validation(record, payload, ctx) + record = self.repository.update_import( + import_id, + {"metadata": {**record.metadata, "governance_context": _governance_context(self.config, ctx)}}, + ) or record + adjustment = _optional_text(payload.get("adjustment_text")) + if adjustment: + record = self._apply_adjustment(record, adjustment, ctx) + attempt, task = self._queue_validation(record, ctx) + return {"import": self._require_import(import_id).to_dict(), "attempt": attempt.to_dict(), "task": task.to_dict()} + + def reject_attempt( + self, + import_id: str, + attempt_id: str, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + record = self._require_import(import_id) + attempt = self._require_attempt(import_id, attempt_id) + if self.style_sets.is_style_set(record): + return self.style_sets.reject_and_rebuild(record, attempt, payload, ctx) + if record.current_attempt_id != attempt.attempt_id or record.status != "awaiting_review" or attempt.status != "awaiting_review": + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "only the current completed verification attempt can be rejected", + {"import_id": import_id, "attempt_id": attempt_id, "status": attempt.status}, + ) + adjustment = _optional_text(payload.get("adjustment_text")) + if not adjustment: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "adjustment_text is required when the verification image is not faithful", + {"field": "adjustment_text"}, + ) + before = attempt.to_dict() + updated_attempt = self.repository.update_attempt( + attempt_id, + { + "status": "rejected", + "decision": "rejected", + "decision_notes": _optional_text(payload.get("decision_notes")) or adjustment, + "fidelity_score": _optional_score(payload.get("fidelity_score")), + "metadata": {**attempt.metadata, "rejected_by": ctx.actor_id}, + }, + ) + self.repository.update_import(import_id, {"status": "adjustment_required"}) + adjusted = self._apply_adjustment(self._require_import(import_id), adjustment, ctx) + next_attempt, task = self._queue_validation(adjusted, ctx) + self.audit_service.record( + ctx=ctx, + action="reject_advanced_material_attempt", + target_type="advanced_material_validation_attempt", + target_id=attempt_id, + before_snapshot=before, + after_snapshot=updated_attempt.to_dict(), + metadata={"next_attempt_id": next_attempt.attempt_id, "task_id": task.task_id}, + ) + return { + "import": self._require_import(import_id).to_dict(), + "attempt": updated_attempt.to_dict(), + "next_attempt": next_attempt.to_dict(), + "task": task.to_dict(), + } + + def accept_attempt( + self, + import_id: str, + attempt_id: str, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + record = self._require_import(import_id) + attempt = self._require_attempt(import_id, attempt_id) + if self.style_sets.is_style_set(record): + return self.style_sets.accept(record, attempt, payload, ctx) + if record.accepted_material_id: + existing = self.repository.get_material(record.accepted_material_id) + if existing is not None: + return {"import": record.to_dict(), "attempt": attempt.to_dict(), "material": existing.to_dict()} + if record.current_attempt_id != attempt_id or record.status != "awaiting_review" or attempt.status != "awaiting_review": + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "only the current completed verification attempt can be sealed", + {"import_id": import_id, "attempt_id": attempt_id, "status": attempt.status}, + ) + if not attempt.validation_image_uri: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "verification image is missing", + {"attempt_id": attempt_id}, + ) + material_id = f"advmat_{uuid4().hex}" + recognition = record.recognition_result if isinstance(record.recognition_result, dict) else {} + profile = recognition.get("normalized_asset_profile") if isinstance(recognition.get("normalized_asset_profile"), dict) else {} + capsules = recognition.get("generation_capsules") if isinstance(recognition.get("generation_capsules"), dict) else {} + fidelity_score = _optional_score(payload.get("fidelity_score")) + decision_notes = _optional_text(payload.get("decision_notes")) + attempt = self.repository.update_attempt( + attempt_id, + {"fidelity_score": fidelity_score, "decision_notes": decision_notes}, + ) or attempt + metadata = { + "library_kind": "advanced", + "priority_class": "advanced_verified", + "material_priority": ADVANCED_MATERIAL_PRIORITY, + "verification": { + "import_id": import_id, + "attempt_id": attempt_id, + "attempt_number": attempt.attempt_number, + "fidelity_score": fidelity_score, + "decision_notes": decision_notes, + "validation_image_uri": attempt.validation_image_uri, + "prompt_revision": record.prompt_revision, + }, + "recognition": recognition.get("recognition") or {}, + "raw_analysis": recognition.get("raw_analysis") or {}, + "normalized_asset_profile": {**profile, "confirmed": True}, + "generation_capsules": capsules, + "confirmed": True, + } + material = self.repository.accept_attempt( + import_id, + attempt_id, + { + "material_id": material_id, + "category_id": record.category_id, + "display_name": record.display_name, + "source_image_uri": record.source_image_uri, + "source_thumbnail_uri": record.source_thumbnail_uri, + "validation_image_uri": attempt.validation_image_uri, + "validation_thumbnail_uri": attempt.validation_thumbnail_uri, + "prompt": attempt.prompt or record.recognition_prompt, + "negative_prompt": attempt.negative_prompt or record.recognition_negative_prompt, + "tags": record.recognition_tags, + "priority": ADVANCED_MATERIAL_PRIORITY, + "status": "active", + "capsule": capsules, + "fidelity_score": fidelity_score, + "created_by": ctx.actor_id, + "decision_notes": decision_notes, + "metadata": metadata, + }, + ) + self.audit_service.record( + ctx=ctx, + action="seal_advanced_material", + target_type="advanced_material", + target_id=material.material_id, + before_snapshot={"import": record.to_dict(), "attempt": attempt.to_dict()}, + after_snapshot=material.to_dict(), + ) + return { + "import": self._require_import(import_id).to_dict(), + "attempt": self._require_attempt(import_id, attempt_id).to_dict(), + "material": material.to_dict(), + } + + def retry_import(self, import_id: str, ctx: RequestContext) -> dict[str, Any]: + record = self._reconcile_import_task(self._require_import(import_id)) + record = self.repository.update_import( + import_id, + {"metadata": {**record.metadata, "governance_context": _governance_context(self.config, ctx)}}, + ) or record + if self.style_sets.is_style_set(record): + if record.status == "style_consensus_failed": + return self.style_sets.create_consensus(import_id, {}, ctx) + if record.status in {"ready_for_validation", "validation_failed"}: + return self.style_sets.ensure_validation(record, {}, ctx) + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "retry the failed style source or validation case directly", + {"import_id": import_id, "status": record.status}, + ) + if record.status == "recognition_failed": + task = self._queue_recognition(record, ctx) + return {"import": self._require_import(import_id).to_dict(), "task": task.to_dict()} + if record.status == "validation_failed": + attempt, task = self._queue_validation(record, ctx) + return {"import": self._require_import(import_id).to_dict(), "attempt": attempt.to_dict(), "task": task.to_dict()} + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced material import is not in a retryable state", + {"import_id": import_id, "status": record.status}, + ) + + def cancel_import(self, import_id: str, ctx: RequestContext) -> dict[str, Any]: + record = self._require_import(import_id) + if record.status in {"accepted", "archived", "cancelled"}: + return record.to_dict() + if self.style_sets.is_style_set(record): + self.style_sets.cancel(record, ctx) + active_task_id = _optional_text(record.metadata.get("active_task_id")) + if active_task_id: + try: + self.queue_service.cancel_job(active_task_id, ctx, reason="advanced material import cancelled") + except ApiError: + pass + attempt = self.repository.get_active_attempt(import_id) + if attempt is not None: + self.repository.update_attempt(attempt.attempt_id, {"status": "cancelled", "decision": "cancelled"}) + updated = self.repository.update_import( + import_id, + {"status": "cancelled", "metadata": {**record.metadata, "active_task_id": None}}, + ) + self.audit_service.record( + ctx=ctx, + action="cancel_advanced_material_import", + target_type="advanced_material_import", + target_id=import_id, + before_snapshot=record.to_dict(), + after_snapshot=updated.to_dict(), + ) + return updated.to_dict() + + def delete_import(self, import_id: str, ctx: RequestContext) -> dict[str, Any]: + record = self._require_import(import_id) + if record.accepted_material_id or self.repository.get_material_by_import(import_id) is not None: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "sealed advanced material imports cannot be deleted; archive the material instead", + {"import_id": import_id, "accepted_material_id": record.accepted_material_id}, + ) + media_uris = self._import_media_uris(record) + if record.status not in {"cancelled", "failed", "recognition_failed", "validation_failed"}: + self.cancel_import(import_id, ctx) + record = self._require_import(import_id) + before = record.to_dict() + try: + deleted = self.repository.delete_import(import_id) + except ValueError as exc: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + str(exc), + {"import_id": import_id}, + ) from None + if deleted is None: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced material import not found", {"import_id": import_id}) + for uri in media_uris: + self._remove_uri(uri) + result = { + "import_id": import_id, + "deleted": True, + "previous_status": before.get("status"), + "removed_media_count": len(media_uris), + } + self.audit_service.record( + ctx=ctx, + action="delete_advanced_material_import", + target_type="advanced_material_import", + target_id=import_id, + before_snapshot=before, + metadata=result, + ) + return result + + def list_materials(self, *, page: int = 1, page_size: int = 30) -> dict[str, Any]: + normalized_page = max(int(page or 1), 1) + normalized_size = min(max(int(page_size or 30), 1), 100) + items, total = self.repository.list_materials(page=normalized_page, page_size=normalized_size) + return { + "items": [item.to_dict() for item in items], + "total": total, + "page": normalized_page, + "page_size": normalized_size, + } + + def get_material(self, material_id: str): + material = self.repository.get_material(material_id) + if material is None or material.status == "archived": + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced material not found", {"material_id": material_id}) + return material + + def archive_material(self, material_id: str, ctx: RequestContext): + before = self.get_material(material_id) + after = self.repository.archive_material(material_id) + if after is None: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced material not found", {"material_id": material_id}) + self.audit_service.record( + ctx=ctx, + action="archive_advanced_material", + target_type="advanced_material", + target_id=material_id, + before_snapshot=before.to_dict(), + after_snapshot=after.to_dict(), + ) + return after + + def list_catalog(self, *, page: int = 1, page_size: int = 100) -> dict[str, Any]: + normalized_page = max(int(page or 1), 1) + normalized_size = min(max(int(page_size or 100), 1), 200) + advanced = self._all_advanced_materials() + advanced_total = len(advanced) + standard = self._all_standard_materials() + advanced_items = [ + {**item.to_dict(), "library_kind": "advanced", "priority": ADVANCED_MATERIAL_PRIORITY} + for item in advanced + if item.status == "active" + ] + standard_items = [ + { + **item.to_dict(), + "library_kind": "standard", + "priority": 0, + } + for item in standard + if item.recognition_status == "confirmed" + ] + merged = [*advanced_items, *standard_items] + offset = (normalized_page - 1) * normalized_size + return { + "items": merged[offset : offset + normalized_size], + "total": len(merged), + "page": normalized_page, + "page_size": normalized_size, + "advanced_total": advanced_total, + "standard_total": sum(1 for item in standard if item.recognition_status == "confirmed"), + } + + def _all_advanced_materials(self) -> list[Any]: + result: list[Any] = [] + page = 1 + while True: + items, total = self.repository.list_materials(page=page, page_size=200) + result.extend(items) + if len(result) >= total or not items: + return result + page += 1 + + def _all_standard_materials(self) -> list[Material]: + result: list[Material] = [] + page = 1 + while True: + items, total = self.material_repository.list_materials(page=page, page_size=100) + result.extend(items) + if len(result) >= total or not items: + return result + page += 1 + + def execute_task(self, task: GenerationTask, ctx: RequestContext) -> WorkerTaskUpdate: + if task.task_type in { + "advanced_style_source_recognition", + "advanced_style_consensus", + "advanced_style_validation_generation", + }: + return self.style_sets.execute_task(task, ctx) + if task.task_type == "advanced_material_recognition": + return self._execute_recognition(task, ctx) + if task.task_type == "advanced_material_validation_generation": + return self._execute_validation(task, ctx) + raise RuntimeError(f"unsupported advanced material task type: {task.task_type}") + + def handle_task_failure(self, task: GenerationTask, exc: Exception, ctx: RequestContext) -> None: + if task.task_type in { + "advanced_style_source_recognition", + "advanced_style_consensus", + "advanced_style_validation_generation", + }: + self.style_sets.handle_failure(task, exc, ctx) + return + import_id = _optional_text(task.metadata.get("advanced_material_import_id")) + if not import_id: + return + failure = _safe_failure(exc) + record = self.repository.get_import(import_id) + if record is None: + return + if record.status in {"cancelled", "accepted", "archived"}: + return + if task.task_type == "advanced_material_recognition": + self.repository.update_import( + import_id, + { + "status": "recognition_failed", + "error": failure, + "metadata": {**record.metadata, "active_task_id": None}, + }, + ) + elif task.task_type == "advanced_material_validation_generation": + attempt_id = _optional_text(task.metadata.get("advanced_material_attempt_id")) + if attempt_id: + attempt = self.repository.get_attempt(attempt_id) + if attempt is not None and attempt.status in ATTEMPT_ACTIVE_STATUSES: + self.repository.update_attempt(attempt_id, {"status": "failed", "error": failure}) + self.repository.update_import( + import_id, + { + "status": "validation_failed", + "error": failure, + "metadata": {**record.metadata, "active_task_id": None}, + }, + ) + self.audit_service.record( + ctx=ctx, + action="advanced_material_task_failed", + target_type="advanced_material_import", + target_id=import_id, + metadata={"task_id": task.task_id, "task_type": task.task_type, "failure": failure}, + ) + + def _execute_recognition(self, task: GenerationTask, ctx: RequestContext) -> WorkerTaskUpdate: + import_id = str(task.metadata.get("advanced_material_import_id") or "").strip() + record = self._require_import(import_id) + if record.status not in {"recognition_queued", "recognizing"}: + return WorkerTaskUpdate(result={"import_id": import_id, "status": record.status}) + self._ensure_task_active(task, record) + record = self.repository.update_import_if_status( + import_id, + {"recognition_queued", "recognizing"}, + {"status": "recognizing", "error": None}, + ) + if record is None: + raise AdvancedMaterialTaskCancelled("advanced material recognition no longer owns the import") + route_name = record.recognition_model_route or self._recognition_route() + provider = self.model_provider_runtime.vision_provider_for_route( + { + "route_name": route_name, + "modality": "vision_recognition", + "material_id": import_id, + "image_uri": record.source_image_uri, + } + ) + if provider is None: + raise ApiError( + ErrorCode.MODEL_CAPABILITY_UNCONFIRMED, + "advanced material vision route is not configured or unavailable", + {"route_name": route_name, "modality": "vision_recognition"}, + ) + material = Material( + material_id=import_id, + category_id=record.category_id, + display_name=record.display_name, + image_uri=record.source_image_uri, + thumbnail_uri=record.source_thumbnail_uri, + prompt=None, + negative_prompt=None, + tags=[], + recognition_status="pending_recognition", + metadata={"advanced_material": True}, + created_at=record.created_at, + updated_at=record.updated_at, + ) + image_data_url, content_type, size_bytes = _storage_image_data_url( + record.source_image_uri, + material.metadata, + self.storage, + ) + request = VisionRecognitionRequest( + display_name=record.display_name, + image_uri=image_data_url, + thumbnail_uri=None, + prompt=None, + negative_prompt=None, + tags=(), + metadata={ + "advanced_material": True, + "recognition_instruction": self._recognition_instruction(record), + "vision_input": { + "source_uri": record.source_image_uri, + "content_type": content_type, + "size_bytes": size_bytes, + }, + }, + ) + try: + recognition = provider.recognize_material(request) + except VisionProviderError as exc: + raise ApiError( + ErrorCode.GENERATION_FAILED, + "advanced material recognition failed", + {**_vision_provider_error(exc), "route_name": route_name}, + ) from None + category = self.material_repository.get_category(record.category_id) if record.category_id else None + try: + structures = self.normalization_service.normalize_recognition( + recognition.structured_data, + prompt=recognition.prompt, + negative_prompt=recognition.negative_prompt, + tags=recognition.tags, + confidence=recognition.confidence, + provider_id=recognition.provider_id, + model=recognition.model, + route_name=route_name, + category_hint=category.name if category else None, + ) + except MaterialNormalizationError as exc: + raise ApiError( + ErrorCode.GENERATION_FAILED, + "advanced material recognition returned an invalid structured result", + {"route_name": route_name, "error_type": "invalid_structured_analysis"}, + ) from exc + result = { + "recognition": _recognition_metadata(recognition, route_name=route_name), + **structures, + } + self._ensure_task_active(task, self._require_import(import_id)) + updated = self.repository.update_import_if_status( + import_id, + {"recognizing"}, + { + "status": "ready_for_validation", + "recognition_prompt": recognition.prompt, + "recognition_negative_prompt": recognition.negative_prompt, + "recognition_tags": recognition.tags, + "recognition_result": result, + "error": None, + "metadata": {**record.metadata, "active_task_id": None}, + }, + ) + if updated is None: + raise AdvancedMaterialTaskCancelled("advanced material recognition result arrived after cancellation") + try: + attempt, next_task = self._queue_validation(updated, ctx) + except Exception as exc: + self.repository.update_import( + import_id, + { + "status": "validation_failed", + "error": _safe_failure(exc), + "metadata": {**updated.metadata, "active_task_id": None}, + }, + ) + return WorkerTaskUpdate( + result={ + "import_id": import_id, + "recognition_status": "completed", + "validation_queue_status": "failed", + }, + metadata={"pipeline_stage": "validation_queue_failed"}, + ) + return WorkerTaskUpdate( + result={ + "import_id": import_id, + "recognition_status": "completed", + "attempt_id": attempt.attempt_id, + "next_task_id": next_task.task_id, + }, + metadata={"pipeline_stage": "recognition_completed"}, + ) + + def _execute_validation(self, task: GenerationTask, ctx: RequestContext) -> WorkerTaskUpdate: + import_id = str(task.metadata.get("advanced_material_import_id") or "").strip() + attempt_id = str(task.metadata.get("advanced_material_attempt_id") or "").strip() + record = self._require_import(import_id) + attempt = self._require_attempt(import_id, attempt_id) + if attempt.status == "awaiting_review" and attempt.validation_image_uri: + return WorkerTaskUpdate(result={"import_id": import_id, "attempt_id": attempt_id, "status": "awaiting_review"}) + if attempt.status not in {"queued", "running"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced material validation attempt is not executable", + {"attempt_id": attempt_id, "status": attempt.status}, + ) + self._ensure_task_active(task, record, attempt=attempt) + claimed = self.repository.mark_attempt_running(import_id, attempt_id) + if claimed is None: + raise AdvancedMaterialTaskCancelled("advanced material validation no longer owns the import") + record, attempt = claimed + requested_route = attempt.model_route or self._generation_route() + governance = self._govern_validation_prompt( + record=record, + attempt=attempt, + requested_route=requested_route, + ctx=ctx, + ) + route_name = str(governance["selected_route"]) + resolved_route = self._resolve_generation_route(route_name) + cost_guard = self._check_validation_budget(route_name, resolved_route) + attempt_metadata = { + **attempt.metadata, + "prompt_governance": governance["snapshot"], + **({"cost_guard": cost_guard} if cost_guard else {}), + } + self.repository.update_attempt(attempt_id, {"metadata": attempt_metadata}) + node = WorkflowNode( + node_id=f"advanced-material:{attempt_id}", + workflow_id=f"advanced-material:{import_id}", + node_key="advanced_material_validation", + title="进阶素材还原验证", + description=None, + step_name="validation", + node_type="generation", + status="running", + branch_name="main", + prompt=governance["prompt"], + negative_prompt=governance["negative_prompt"], + model_route=route_name, + selected_image_id=None, + sort_order=0, + metadata={"advanced_material": True}, + created_at=attempt.created_at, + updated_at=attempt.updated_at, + ) + request = { + "count": 1, + "aspect_ratio": "1:1", + "quality": "standard", + "seed": int(attempt.seed or DEFAULT_VALIDATION_SEED), + "model_route": route_name, + "resolved_model_route": resolved_route, + "allow_provider_fallback": False, + "expanded_prompt": governance["prompt"], + "expanded_negative_prompt": governance["negative_prompt"], + "prompt_governance": governance["snapshot"], + **({"cost_guard": cost_guard} if cost_guard else {}), + # Deliberately no input_images/image field: the validation render + # measures the text description rather than image-to-image copying. + "output_scope": { + "kind": "advanced_material_validation", + "import_id": import_id, + "attempt_id": attempt_id, + "attempt_number": attempt.attempt_number, + }, + } + assets: list[Any] = [] + try: + try: + assets = self.single_flow_engine.generate(node, task, request) + except ImageProviderError as exc: + fallback = self._content_safety_fallback( + exc=exc, + runtime_request=request, + governance=governance, + requested_route=requested_route, + record=record, + ctx=ctx, + ) + if fallback is None: + raise + route_name = fallback["model_route"] + resolved_route = fallback["resolved_model_route"] + request = fallback["request"] + attempt_metadata = { + **attempt_metadata, + "route_fallback": fallback["route_fallback"], + **({"fallback_cost_guard": fallback["cost_guard"]} if fallback.get("cost_guard") else {}), + } + self.repository.update_attempt(attempt_id, {"metadata": attempt_metadata}) + assets = self.single_flow_engine.generate(node, task, request) + except Exception: + for asset in assets: + self._remove_uri(str(getattr(asset, "image_uri", "") or "")) + self._remove_uri(str(getattr(asset, "thumbnail_uri", "") or "")) + raise + if len(assets) != 1: + raise ImageProviderError( + "advanced material validation must return exactly one image", + provider_id=str(resolved_route.get("provider_id") or "unknown"), + error_type="invalid_response", + ) + asset = assets[0] + route_provider = resolved_route.get("provider") if isinstance(resolved_route.get("provider"), dict) else {} + provider_id = asset.metadata.get("provider_id") or resolved_route.get("provider_id") + provider_model = asset.metadata.get("provider_model") or resolved_route.get("model_id") + usage = asset.metadata.get("usage") or {} + latest_attempt = self.repository.get_attempt(attempt_id) or attempt + billable_metadata = { + **latest_attempt.metadata, + **attempt_metadata, + "generation": asset.metadata, + "provider_base_url_present": bool(route_provider.get("base_url")), + "effective_model_route": route_name, + } + # Persist billable attribution before the publication CAS. If the + # user cancelled while the provider was running, the usage remains + # auditable even though the late image is deleted instead of revived. + self.repository.update_attempt( + attempt_id, + { + "model_route": route_name, + "provider_id": provider_id, + "provider_model": provider_model, + "width": asset.width, + "height": asset.height, + "usage": usage, + "metadata": billable_metadata, + }, + ) + completed = self.repository.complete_attempt_if_active( + import_id, + attempt_id, + attempt_payload={ + "model_route": route_name, + "validation_image_uri": asset.image_uri, + "validation_thumbnail_uri": asset.thumbnail_uri, + "provider_id": provider_id, + "provider_model": provider_model, + "width": asset.width, + "height": asset.height, + "usage": usage, + "metadata": billable_metadata, + }, + import_payload={ + "metadata": { + **record.metadata, + "active_task_id": None, + "last_validation_governance": governance["snapshot"], + }, + }, + ) + if completed is None: + self._remove_uri(asset.image_uri) + self._remove_uri(asset.thumbnail_uri) + raise AdvancedMaterialTaskCancelled("advanced material validation result arrived after cancellation") + updated_import, updated_attempt = completed + self.audit_service.record( + ctx=ctx, + action="complete_advanced_material_validation", + target_type="advanced_material_validation_attempt", + target_id=attempt_id, + after_snapshot=updated_attempt.to_dict(), + metadata={"import_id": import_id, "task_id": task.task_id}, + ) + return WorkerTaskUpdate( + result={ + "import_id": import_id, + "attempt_id": attempt_id, + "status": updated_import.status, + "validation_image_uri": asset.image_uri, + "validation_thumbnail_uri": asset.thumbnail_uri, + }, + metadata={"pipeline_stage": "awaiting_human_review"}, + ) + + def _govern_validation_prompt( + self, + *, + record: Any, + attempt: Any, + requested_route: str, + ctx: RequestContext, + ) -> dict[str, Any]: + prompt = str(attempt.prompt or record.recognition_prompt or "").strip() + negative_prompt = str(attempt.negative_prompt or record.recognition_negative_prompt or "").strip() + if not prompt: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced material validation prompt is empty", + {"import_id": record.import_id, "attempt_id": attempt.attempt_id}, + ) + routing_context = self._validation_routing_context(record, ctx) + if self.prompt_moderation_service: + moderation = self.prompt_moderation_service.moderate( + original_prompt=prompt, + translated_prompt=prompt, + final_prompt=prompt, + negative_prompt=negative_prompt, + reference_bindings=[], + ) + else: + 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=routing_context["entrypoint"], + user_id=routing_context["user_id"], + group_id=routing_context["group_id"], + permission_context=routing_context["content_permissions"], + ) + route_snapshot = route.to_dict() + selected_route = route.selected_route + allowed = route.allowed + requires_confirmation = route.requires_confirmation + route_reason = route.reason + # The dedicated advanced-material assignment is intentionally + # stronger than the global safe route. Only adult content may + # leave the requested validation route for the configured NSFW + # route. + if allowed and moderation.level in {"safe", "sensitive"}: + if selected_route != requested_route: + route_snapshot["global_safe_route_ignored"] = selected_route + selected_route = requested_route + route_snapshot["selected_route"] = requested_route + route_snapshot["reason"] = "advanced_material_requested_route" + route_reason = "advanced_material_requested_route" + else: + selected_route = requested_route if moderation.allowed else None + allowed = moderation.allowed + requires_confirmation = moderation.level == "uncertain" + route_reason = "static_route" + route_snapshot = { + "requested_route": requested_route, + "moderation_level": moderation.level, + "selected_route": selected_route, + "reason": route_reason, + "fallback_route": None, + "allowed": allowed, + "requires_confirmation": requires_confirmation, + } + snapshot = { + "moderation": moderation.to_dict(), + "route_decision": route_snapshot, + "entrypoint": routing_context["entrypoint"], + } + if not allowed or not selected_route: + if moderation.level in {"terror_prohibited", "violence_prohibited", "prohibited"}: + try: + self.audit_service.record( + ctx=ctx, + action="advanced_material_content_safety_blocked", + target_type="advanced_material_validation_attempt", + target_id=attempt.attempt_id, + metadata={ + "import_id": record.import_id, + "priority": "high" if moderation.level in {"terror_prohibited", "violence_prohibited"} else "normal", + "moderation_level": moderation.level, + "reason_codes": moderation.reason_codes, + "rules_version": moderation.rules_version, + "entrypoint": routing_context["entrypoint"], + }, + ) + except Exception: + pass + self.repository.update_attempt(attempt.attempt_id, {"metadata": {**attempt.metadata, "prompt_governance": snapshot}}) + raise ApiError( + ErrorCode.VALIDATION_FAILED, + moderation.warning or ("内容需要确认后才能生成" if requires_confirmation else "内容审核未通过,未创建验证图任务"), + { + "moderation_level": moderation.level, + "reason_codes": moderation.reason_codes, + "route_reason": route_reason, + "requires_confirmation": requires_confirmation, + "warning": moderation.warning, + }, + ) + return { + "prompt": prompt, + "negative_prompt": negative_prompt, + "selected_route": selected_route, + "moderation": moderation, + "snapshot": snapshot, + "routing_context": routing_context, + } + + def _content_safety_fallback( + self, + *, + exc: ImageProviderError, + runtime_request: dict[str, Any], + governance: dict[str, Any], + requested_route: str, + record: Any, + ctx: RequestContext, + ) -> dict[str, Any] | None: + failure = self.failure_classifier.classify(exc) + if failure.get("failure_class") != "content_safety_rejection": + return None + if not self.prompt_moderation_service or not self.generation_route_service: + return None + if isinstance(runtime_request.get("route_fallback"), dict) and runtime_request["route_fallback"].get("attempted"): + return None + prompt = str(runtime_request.get("expanded_prompt") or "").strip() + negative_prompt = str(runtime_request.get("expanded_negative_prompt") or "").strip() + moderation = self.prompt_moderation_service.moderate( + original_prompt=prompt, + translated_prompt=prompt, + final_prompt=prompt, + negative_prompt=negative_prompt, + reference_bindings=[], + ) + if moderation.level in {"terror_prohibited", "violence_prohibited", "prohibited", "uncertain"}: + return None + if moderation.level != "adult_allowed" and failure.get("safety_reason") != "adult": + return None + provider_signal_moderation = moderation + if moderation.level != "adult_allowed": + provider_signal_moderation = replace( + moderation, + level="adult_allowed", + categories=[*moderation.categories, "provider_content_safety_rejection"], + reason_codes=[*moderation.reason_codes, "provider_classified_prompt_as_adult"], + action="route_nsfw", + warning=None, + ) + routing_context = self._validation_routing_context(record, ctx) + route = self.generation_route_service.decide( + requested_route, + provider_signal_moderation, + entrypoint=routing_context["entrypoint"], + user_id=routing_context["user_id"], + group_id=routing_context["group_id"], + permission_context=routing_context["content_permissions"], + ) + current_route = str(runtime_request.get("model_route") or "").strip() + if not route.allowed or not route.selected_route or route.selected_route == current_route: + return None + resolved_route = self._resolve_generation_route(route.selected_route) + # The first provider may already have accepted and billed the request + # before returning a content-safety rejection. Reserve two requests + # for the fallback check so the budget cannot be bypassed by the + # automatic second call. + cost_guard = self._check_validation_budget( + route.selected_route, + resolved_route, + planned_task_count=2, + ) + fallback_record = { + "attempted": True, + "initial_route": current_route, + "failure_class": failure, + "moderation_recheck": moderation.to_dict(), + "provider_signal_moderation": provider_signal_moderation.to_dict(), + "fallback_route": route.selected_route, + "fallback_reason": route.reason, + } + return { + "model_route": route.selected_route, + "resolved_model_route": resolved_route, + "route_fallback": fallback_record, + "cost_guard": cost_guard, + "request": { + **runtime_request, + "model_route": route.selected_route, + "resolved_model_route": resolved_route, + "route_fallback": fallback_record, + "allow_provider_fallback": False, + **({"cost_guard": cost_guard} if cost_guard else {}), + }, + } + + def _resolve_generation_route(self, route_name: str) -> dict[str, Any]: + resolution = self.model_provider_service.resolve_route(route_name, modality="image_generation") + if not resolution: + raise ApiError( + ErrorCode.MODEL_CAPABILITY_UNCONFIRMED, + "advanced material validation image route is not configured", + {"route_name": route_name, "modality": "image_generation"}, + ) + return { + **resolution, + "status": "resolved", + "route_name": str(resolution.get("route_name") or route_name), + } + + def _check_validation_budget( + self, + route_name: str, + resolved_route: dict[str, Any], + *, + planned_task_count: int = 1, + ) -> dict[str, Any] | None: + advanced_config = self.config.get("advanced_materials") if isinstance(self.config.get("advanced_materials"), dict) else {} + cost_guard_config = self.config.get("cost_guard") if isinstance(self.config.get("cost_guard"), dict) else {} + budget = advanced_config.get("cost_budget") if isinstance(advanced_config.get("cost_budget"), dict) else None + if budget is None and isinstance(cost_guard_config.get("advanced_materials"), dict): + budget = cost_guard_config["advanced_materials"] + if not budget or not self.cost_guard_service or not bool(budget.get("enabled", True)): + return None + unit_prices = budget.get("unit_prices") if isinstance(budget.get("unit_prices"), dict) else None + price_key = str(budget.get("price_key") or "").strip() + if unit_prices is None and price_key: + unit_prices = { + price_key: { + "per_request": _optional_nonnegative_float(budget.get("per_request")), + "per_image": _optional_nonnegative_float(budget.get("per_image")), + "per_1k_tokens": _optional_nonnegative_float(budget.get("per_1k_tokens")), + } + } + guard = self.cost_guard_service.check_generation_budget( + provider_id=resolved_route.get("provider_id"), + provider_model=resolved_route.get("model_id") or route_name, + model_route=route_name, + planned_task_count=max(int(planned_task_count), 1), + planned_image_count=1, + 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=unit_prices, + ) + if not guard.get("allowed"): + raise ApiError(ErrorCode.VALIDATION_FAILED, "advanced material validation budget exceeded", guard) + return guard + + def _validation_routing_context(self, record: Any, ctx: RequestContext) -> dict[str, Any]: + stored = record.metadata.get("governance_context") if isinstance(record.metadata.get("governance_context"), dict) else {} + permissions = stored.get("content_permissions") if isinstance(stored.get("content_permissions"), dict) else {} + user_id = _optional_text(stored.get("user_id")) or ctx.actor_id + group_id = _optional_text(stored.get("group_id")) + access = self.config.get("chat_access") if isinstance(self.config.get("chat_access"), dict) else {} + adult_users = {str(value).strip() for value in access.get("adult_user_allowlist", []) if str(value).strip()} + adult_groups = {str(value).strip() for value in access.get("adult_group_allowlist", []) if str(value).strip()} + return { + "entrypoint": str(stored.get("entrypoint") or _entrypoint_from_context(ctx)), + "user_id": user_id, + "group_id": group_id, + "content_permissions": { + "adult_user_allowed": bool(user_id and user_id in adult_users), + **({"adult_group_allowed": bool(group_id in adult_groups)} if group_id else {}), + "quota_allowed": bool(permissions.get("quota_allowed", True)), + }, + } + + def _queue_recognition(self, record, ctx: RequestContext) -> GenerationTask: + if record.status in IMPORT_ACTIVE_STATUSES and _optional_text(record.metadata.get("active_task_id")): + try: + existing = self.queue_service.get_job(str(record.metadata["active_task_id"])) + except ApiError: + existing = None + if existing is not None and existing.status in {"queued", "running"}: + return existing + task = self.queue_service.create_task( + { + "task_type": "advanced_material_recognition", + "status": "queued", + "model_route": record.recognition_model_route or self._recognition_route(), + "idempotency_key": f"advanced-material-recognition:{record.import_id}:{record.prompt_revision}", + "request": {"import_id": record.import_id, "operation": "recognize"}, + "metadata": { + "source": "advanced_material", + "advanced_material_import_id": record.import_id, + "stage": "recognition", + "task_summary": f"进阶素材/{record.display_name}/识别", + }, + }, + ctx, + ) + self.repository.update_import( + record.import_id, + { + "status": "recognition_queued", + "error": None, + "metadata": {**record.metadata, "active_task_id": task.task_id}, + }, + ) + return task + + def _queue_validation(self, record, ctx: RequestContext): + if record.status in IMPORT_ACTIVE_STATUSES: + active = self.repository.get_active_attempt(record.import_id) + if active is not None and active.task_id: + task = self.queue_service.get_job(active.task_id) + if task.status in {"queued", "running"}: + return active, task + if not record.recognition_prompt: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced material must be recognized before validation generation", + {"import_id": record.import_id, "status": record.status}, + ) + if record.status not in {"ready_for_validation", "adjustment_required", "validation_failed"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced material is not ready to create a validation attempt", + {"import_id": record.import_id, "status": record.status}, + ) + attempt_id = f"advattempt_{uuid4().hex}" + route_name = _optional_text(record.metadata.get("generation_model_route")) or self._generation_route() + attempt = self.repository.create_attempt( + { + "attempt_id": attempt_id, + "import_id": record.import_id, + "status": "queued", + "adjustment_text": _latest_adjustment(record.metadata), + "prompt": record.recognition_prompt, + "negative_prompt": record.recognition_negative_prompt, + "model_route": route_name, + "seed": DEFAULT_VALIDATION_SEED, + "width": 1024, + "height": 1024, + "metadata": {"prompt_revision": record.prompt_revision}, + } + ) + attempt_number = attempt.attempt_number + try: + task = self.queue_service.create_task( + { + "task_type": "advanced_material_validation_generation", + "status": "queued", + "model_route": route_name, + "idempotency_key": f"advanced-material-validation:{attempt_id}", + "request": {"import_id": record.import_id, "attempt_id": attempt_id, "operation": "validate"}, + "metadata": { + "source": "advanced_material", + "advanced_material_import_id": record.import_id, + "advanced_material_attempt_id": attempt_id, + "attempt_number": attempt_number, + "stage": "validation_generation", + "task_summary": f"进阶素材/{record.display_name}/第{attempt_number}轮验证", + }, + }, + ctx, + ) + attempt = self.repository.update_attempt(attempt_id, {"task_id": task.task_id}) + self.repository.update_import( + record.import_id, + { + "status": "validation_queued", + "current_attempt_id": attempt_id, + "error": None, + "metadata": {**record.metadata, "active_task_id": task.task_id}, + }, + ) + except Exception as exc: + self.repository.update_attempt(attempt_id, {"status": "failed", "error": _safe_failure(exc)}) + self.repository.update_import( + record.import_id, + { + "status": "validation_failed", + "error": _safe_failure(exc), + "metadata": {**record.metadata, "active_task_id": None}, + }, + ) + raise + return attempt, task + + def _apply_adjustment(self, record, adjustment: str, ctx: RequestContext): + prompt = _append_adjustment(record.recognition_prompt, adjustment) + history = list(record.metadata.get("adjustment_history") or []) + history.append( + { + "revision": int(record.prompt_revision or 0) + 1, + "text": adjustment, + "actor_id": ctx.actor_id, + } + ) + return self.repository.update_import( + record.import_id, + { + "status": "adjustment_required", + "recognition_prompt": prompt, + "prompt_revision": int(record.prompt_revision or 0) + 1, + "metadata": { + **record.metadata, + "adjustment_history": history[-20:], + "governance_context": _governance_context(self.config, ctx), + }, + }, + ) + + def _recognition_instruction(self, record) -> str: + prompts = self.config.get("recognition_prompts") if isinstance(self.config.get("recognition_prompts"), dict) else {} + base = str(prompts.get("default_instruction") or "").strip() + category = self.material_repository.get_category(record.category_id) if record.category_id else None + category_hint = f"User selected category: {category.name}." if category else "" + return "\n\n".join( + part + for part in ( + base, + category_hint, + "Extract observable colors, material, texture, silhouette, construction, patterns, trim and small details as faithfully as possible.", + "Produce a standalone text-to-image prompt. Do not assume the source image will be supplied to the image generator.", + ) + if part + ) + + def _recognition_route(self) -> str: + assignments = self.config.get("model_assignments") if isinstance(self.config.get("model_assignments"), dict) else {} + vision = self.config.get("vision") if isinstance(self.config.get("vision"), dict) else {} + provider = vision.get("provider") if isinstance(vision.get("provider"), dict) else {} + return str( + assignments.get("advanced_material_recognition") + or assignments.get("material_recognition") + or provider.get("route_name") + or vision.get("default_route") + or "material_vlm" + ).strip() + + def _generation_route(self) -> str: + assignments = self.config.get("model_assignments") if isinstance(self.config.get("model_assignments"), dict) else {} + generation = self.config.get("generation") if isinstance(self.config.get("generation"), dict) else {} + provider = generation.get("provider") if isinstance(generation.get("provider"), dict) else {} + return str( + assignments.get("advanced_material_validation_generation") + or assignments.get("quick_generation") + or generation.get("default_model") + or provider.get("route_name") + or "image_default" + ).strip() + + def _persist_source( + self, + *, + import_id: str, + image_data_url: str, + image_uri: str, + filename: str | None, + declared_content_type: str | None, + declared_size: int | None, + ) -> tuple[str, str, int, str]: + if image_data_url: + content, detected_type, detected_extension = _decode_upload_data_url(image_data_url) + elif image_uri: + source_path = self.storage.ensure_file(image_uri) + try: + reported_size = source_path.stat().st_size + if reported_size > MAX_UPLOAD_BYTES: + raise ApiError( + ErrorCode.UPLOAD_TOO_LARGE, + "advanced material source exceeds the size limit", + {"size_bytes": reported_size, "max_size_bytes": MAX_UPLOAD_BYTES}, + ) + with source_path.open("rb") as handle: + content = handle.read(MAX_UPLOAD_BYTES + 1) + except ApiError: + raise + except OSError as exc: + raise ApiError( + ErrorCode.MEDIA_NOT_FOUND, + "advanced material source image could not be read", + {"uri": image_uri, "exception_type": exc.__class__.__name__}, + ) from None + detected = detect_image_format(content) + if detected is None: + raise ApiError(ErrorCode.UNSUPPORTED_FILE_TYPE, "advanced material source is not a supported image") + detected_type = detected.mime_type + detected_extension = detected.extension + filename = filename or source_path.name + else: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "image_data_url or image_uri is required", + {"fields": ["image_data_url", "image_uri"]}, + ) + if len(content) > MAX_UPLOAD_BYTES: + raise ApiError( + ErrorCode.UPLOAD_TOO_LARGE, + "advanced material upload exceeds the size limit", + {"size_bytes": len(content), "max_size_bytes": MAX_UPLOAD_BYTES}, + ) + if declared_size is not None and declared_size != len(content): + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "declared upload size does not match image bytes", + {"declared_size_bytes": declared_size, "actual_size_bytes": len(content)}, + ) + if declared_content_type and declared_content_type != detected_type: + raise ApiError( + ErrorCode.UNSUPPORTED_FILE_TYPE, + "upload content type does not match image bytes", + {"content_type": declared_content_type, "detected_content_type": detected_type}, + ) + filename_extension = _suffix(filename) + if filename_extension and filename_extension != detected_extension: + aliases = {(".jpg", ".jpeg"), (".jpeg", ".jpg")} + if (filename_extension, detected_extension) not in aliases: + raise ApiError( + ErrorCode.UNSUPPORTED_FILE_TYPE, + "upload filename extension does not match image bytes", + {"filename": filename, "detected_content_type": detected_type}, + ) + safe_name = filename or f"advanced-material{detected_extension}" + stem = PurePosixPath(safe_name).stem or "source" + destination_uri = f"storage://advanced_materials/sources/{import_id}/{uuid4().hex}-{stem}{detected_extension}" + path = self.storage.resolve_uri(destination_uri) + try: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(f"{path.suffix}.part") + temporary.write_bytes(content) + temporary.replace(path) + except OSError as exc: + raise ApiError( + ErrorCode.STORAGE_WRITE_FAILED, + "advanced material source image could not be stored", + {"uri": destination_uri, "exception_type": exc.__class__.__name__}, + ) from None + return destination_uri, detected_type, len(content), safe_name + + def _remove_uri(self, uri: str) -> None: + if not uri: + return + try: + self.storage.resolve_uri(uri).unlink(missing_ok=True) + except (ApiError, OSError): + pass + + def _reconcile_import_task(self, record: Any) -> Any: + if self.style_sets.is_style_set(record): + return self.style_sets.reconcile_missing_tasks(record) + if record.status not in IMPORT_ACTIVE_STATUSES: + return record + task_id = _optional_text(record.metadata.get("active_task_id")) + task_missing = not task_id + if task_id: + try: + self.queue_service.get_job(task_id) + except ApiError: + task_missing = True + if not task_missing: + return record + stage = "validation_generation" if record.status in {"validation_queued", "validating"} else "recognition" + failure = { + "error_type": "queue_task_missing", + "message": "关联的队列记录已被删除;可重新入队或删除整个导入。", + "stage": stage, + "task_id": task_id, + "retryable": True, + } + if stage == "validation_generation": + attempt = self.repository.get_active_attempt(record.import_id) + if attempt is not None: + self.repository.update_attempt( + attempt.attempt_id, + {"status": "failed", "task_id": None, "error": failure}, + ) + status = "validation_failed" + else: + status = "recognition_failed" + return self.repository.update_import( + record.import_id, + { + "status": status, + "error": failure, + "metadata": {**record.metadata, "active_task_id": None}, + }, + ) or record + + def _import_media_uris(self, record: Any) -> set[str]: + values: set[str] = set() + + def add(*items: Any) -> None: + for item in items: + uri = str(item or "").strip() + if uri.startswith("storage://advanced_materials/"): + values.add(uri) + + add(record.source_image_uri, record.source_thumbnail_uri) + if self.style_sets.is_style_set(record): + for source in self.repository.list_style_sources(record.import_id): + add(source.source_image_uri, source.source_thumbnail_uri) + for attempt in self.repository.list_attempts(record.import_id): + add(attempt.validation_image_uri, attempt.validation_thumbnail_uri) + for case in self.repository.list_style_validation_cases(attempt.attempt_id): + add(case.validation_image_uri, case.validation_thumbnail_uri) + return values + + def _ensure_task_active(self, task: GenerationTask, record: Any, *, attempt: Any | None = None) -> None: + if record.status in {"cancelled", "accepted", "archived"}: + raise AdvancedMaterialTaskCancelled( + f"advanced material import is no longer active: {record.status}" + ) + active_task_id = _optional_text(record.metadata.get("active_task_id")) + if active_task_id and active_task_id != task.task_id: + raise AdvancedMaterialTaskCancelled("advanced material task was superseded") + if attempt is not None: + if attempt.status in {"cancelled", "accepted", "rejected", "failed"}: + raise AdvancedMaterialTaskCancelled( + f"advanced material validation attempt is no longer active: {attempt.status}" + ) + if attempt.task_id and attempt.task_id != task.task_id: + raise AdvancedMaterialTaskCancelled("advanced material validation task was superseded") + try: + queued_task = self.queue_service.get_job(task.task_id) + except ApiError as exc: + raise AdvancedMaterialTaskCancelled("advanced material queue task no longer exists") from exc + if queued_task.status not in {"queued", "running", "retrying"}: + raise AdvancedMaterialTaskCancelled( + f"advanced material queue task is no longer active: {queued_task.status}" + ) + + def _require_import(self, import_id: str): + record = self.repository.get_import(import_id) + if record is None or record.status == "archived": + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced material import not found", {"import_id": import_id}) + return record + + def _require_attempt(self, import_id: str, attempt_id: str): + attempt = self.repository.get_attempt(attempt_id) + if attempt is None or attempt.import_id != import_id: + raise ApiError( + ErrorCode.RESOURCE_NOT_FOUND, + "advanced material validation attempt not found", + {"import_id": import_id, "attempt_id": attempt_id}, + ) + return attempt + + +def create_advanced_material_service() -> AdvancedMaterialService: + database = Database(load_database_settings()) + audit = AuditService(database) + config = load_config_payload() + model_service = ModelProviderService(ModelProviderRepository(database)) + sync_generation_provider_from_config(model_service, config) + sync_vision_provider_from_config(model_service, config) + runtime = ModelProviderRuntime(model_service) + storage = VfsStorage() + model_assignments = config.get("model_assignments") if isinstance(config.get("model_assignments"), dict) else {} + governance_config = config.get("prompt_governance") if isinstance(config.get("prompt_governance"), 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 {} + moderation_route = str( + moderation_config.get("model_route") + or model_assignments.get("cross_review_primary") + or "" + ).strip() + moderation_callable = ( + runtime.structured_text_callable(moderation_route) + or astrbot_structured_text_callable(moderation_route) + ) if moderation_route else None + if moderation_callable: + raw_moderation_callable = moderation_callable + moderation_callable = lambda request: raw_moderation_callable( + {**request, "purpose": "advanced material validation prompt content risk classification"} + ) + return AdvancedMaterialService( + repository=AdvancedMaterialRepository(database), + material_repository=MaterialRepository(database), + queue_service=QueueService(JobRepository(database), audit, get_default_event_bus()), + audit_service=audit, + model_provider_service=model_service, + model_provider_runtime=runtime, + config=config, + storage=storage, + single_flow_engine=SingleFlowEngine( + storage=storage, + image_provider_factory=runtime.image_provider_for_route, + allow_mock_fallback=False, + ), + prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable), + generation_route_service=GenerationRouteService(routing_config), + cost_guard_service=CostGuardService(CostService(database)), + ) + + +def _optional_text(value: Any) -> str | None: + if value is None: + return None + text = str(value).strip() + return text or None + + +def _governance_context(config: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: + access = config.get("chat_access") if isinstance(config.get("chat_access"), dict) else {} + adult_users = { + str(value).strip() + for value in access.get("adult_user_allowlist", []) + if str(value).strip() + } + actor_id = _optional_text(ctx.actor_id) + return { + "entrypoint": _entrypoint_from_context(ctx), + "user_id": actor_id, + "group_id": None, + "content_permissions": { + "adult_user_allowed": bool(actor_id and actor_id in adult_users), + "quota_allowed": True, + }, + } + + +def _entrypoint_from_context(ctx: RequestContext) -> str: + value = f"{ctx.platform} {ctx.source}".lower() + if "qq" in value or "onebot" in value: + return "qq" + if "telegram" in value: + return "telegram" + if "discord" in value: + return "discord" + if "api" in value: + return "api" + return "web" + + +def _optional_score(value: Any) -> float | None: + if value in (None, ""): + return None + try: + score = float(value) + except (TypeError, ValueError): + raise ApiError(ErrorCode.VALIDATION_FAILED, "fidelity_score must be a number", {"field": "fidelity_score"}) from None + if score > 1.0: + score /= 100.0 + return min(max(score, 0.0), 1.0) + + +def _optional_nonnegative_float(value: Any) -> float: + try: + return max(float(value or 0), 0.0) + except (TypeError, ValueError): + return 0.0 + + +def _append_adjustment(prompt: str | None, adjustment: str) -> str: + base = str(prompt or "").strip() + requirement = adjustment.strip() + marker = "User fidelity adjustment" + return "\n\n".join(part for part in (base, f"{marker}: {requirement}") if part) + + +def _latest_adjustment(metadata: dict[str, Any]) -> str | None: + history = metadata.get("adjustment_history") + if not isinstance(history, list) or not history: + return None + last = history[-1] + return _optional_text(last.get("text")) if isinstance(last, dict) else None + + +def _safe_failure(exc: Exception) -> dict[str, Any]: + failure: dict[str, Any] = { + "error_type": exc.__class__.__name__, + "exception_type": exc.__class__.__name__, + "message": " ".join(str(exc).split())[:500] or exc.__class__.__name__, + } + if isinstance(exc, ApiError): + failure.update({"error_code": exc.error_code.value, "details": exc.details}) + elif isinstance(exc, ImageProviderError): + failure.update( + { + "provider_id": exc.provider_id, + "status_code": exc.status_code, + "provider_error_type": exc.error_type, + } + ) + return failure diff --git a/backend/services/advanced_material_worker_runtime.py b/backend/services/advanced_material_worker_runtime.py new file mode 100644 index 0000000..65e29c9 --- /dev/null +++ b/backend/services/advanced_material_worker_runtime.py @@ -0,0 +1,155 @@ +"""Persistent worker pool for advanced-material recognition and validation.""" + +from __future__ import annotations + +from datetime import datetime, timezone +from typing import Any + +from backend.dto.job_dto import GenerationTask +from backend.services.advanced_material_service import ( + AdvancedMaterialService, + create_advanced_material_service, +) +from backend.services.worker_service import QueueWorkerPool, RetryPolicy, WorkerTaskUpdate +from core.identity import RequestContext + + +class AdvancedMaterialWorkerRuntime: + def __init__( + self, + service: AdvancedMaterialService, + *, + worker_count: int = 8, + ctx: RequestContext | None = None, + ): + self.service = service + self.ctx = ctx or RequestContext.system("advanced-material-worker") + self.pool = QueueWorkerPool( + service.queue_service, + self._execute, + worker_count=worker_count, + worker_id_prefix="imagestudio-advanced-material", + interval_seconds=0.35, + claim_batch_size=25, + retry_policy=RetryPolicy(max_attempts=1), + task_filter=_is_advanced_material_task, + terminal_callback=self._on_terminal, + # A style set intentionally fans out one task per source image and + # one task per validation scene. They must not share a route-wide + # single-flight lock: every task has its own persisted timeout, + # retry and terminal state. + per_route_limit=worker_count, + ) + + def start(self) -> dict[str, Any]: + recovery = self._recover_interrupted_tasks() + result = self.pool.start(self.ctx) + return {**result, "recovery": recovery} + + def stop(self, *, timeout_seconds: float = 5.0) -> dict[str, Any]: + return self.pool.stop(timeout_seconds=timeout_seconds) + + def _execute(self, task: GenerationTask) -> WorkerTaskUpdate: + return self.service.execute_task(task, self.ctx) + + def _on_terminal( + self, + claimed_task: GenerationTask, + current_task: GenerationTask, + exc: Exception | None, + ) -> None: + if current_task.status in {"failed", "dead_letter", "cancelled"}: + self.service.handle_task_failure( + claimed_task, + exc or RuntimeError(current_task.error_message or "advanced material task failed"), + self.ctx, + ) + + def _recover_interrupted_tasks(self) -> dict[str, Any]: + """Safely recover recognition, but never replay a paid image request. + + Recognition is read-only and idempotent. A validation request may have + reached the remote provider before the plugin process stopped, so it is + marked failed and left for an explicit human retry. + """ + + # The pool has not started yet, so every advanced-material task still + # in running/retrying belongs to the previous process. Do not apply a + # stale-age grace period: a fast container restart must recover tasks + # written only milliseconds earlier. Do not cap the snapshot either, + # otherwise unrelated queue rows can hide advanced-material work. + candidates = self.service.queue_service.repository.list_stale( + statuses=("running", "retrying"), + updated_before=None, + limit=None, + ) + requeued: list[str] = [] + failed: list[str] = [] + skipped: list[str] = [] + for task in candidates: + if not _is_advanced_material_task(task): + skipped.append(task.task_id) + continue + interrupted = self.service.queue_service.update_task_if_status( + task.task_id, + {task.status}, + { + "status": "failed", + "error_message": "task was interrupted by a previous plugin process", + "metadata": { + **task.metadata, + "recovery": { + "source": "advanced_material_startup", + "previous_status": task.status, + "observed_at": datetime.now(timezone.utc).isoformat(), + }, + }, + }, + self.ctx, + ) + if interrupted is None: + skipped.append(task.task_id) + continue + if task.task_type in { + "advanced_material_recognition", + "advanced_style_source_recognition", + "advanced_style_consensus", + }: + queued = self.service.queue_service.update_task_if_status( + task.task_id, + {"failed"}, + { + "status": "queued", + "progress": 0, + "error_message": None, + "metadata": { + **interrupted.metadata, + "recovery": {**interrupted.metadata.get("recovery", {}), "status": "requeued"}, + }, + }, + self.ctx, + ) + if queued is not None: + requeued.append(task.task_id) + continue + self.service.handle_task_failure( + task, + RuntimeError("task was interrupted by a previous plugin process"), + self.ctx, + ) + failed.append(task.task_id) + return {"requeued_task_ids": requeued, "failed_task_ids": failed, "skipped_task_ids": skipped} + + +def create_advanced_material_worker_runtime() -> AdvancedMaterialWorkerRuntime: + return AdvancedMaterialWorkerRuntime(create_advanced_material_service()) + + +def _is_advanced_material_task(task: GenerationTask) -> bool: + return task.metadata.get("source") == "advanced_material" and task.task_type in { + "advanced_material_recognition", + "advanced_material_validation_generation", + "advanced_style_source_recognition", + "advanced_style_consensus", + "advanced_style_validation_generation", + } diff --git a/backend/services/advanced_style_set_service.py b/backend/services/advanced_style_set_service.py new file mode 100644 index 0000000..dc08752 --- /dev/null +++ b/backend/services/advanced_style_set_service.py @@ -0,0 +1,2753 @@ +"""Style-only multi-image extraction and prompt-only transfer validation. + +The existing advanced-material service remains the compatibility boundary for +single-image imports. This coordinator adds a child-task graph only when the +server-confirmed material category is ``风格``/``style``: + +* one independent VLM task per source image; +* one multi-image consensus VLM task after the source barrier; +* one compatibility validation attempt containing three independent image + generation cases with deliberately unrelated characters and scenes. + +No validation request carries a source image. The source set is used only by +the recognition and consensus stages. +""" + +from __future__ import annotations + +import json +import re +from copy import deepcopy +from dataclasses import replace +from typing import Any +from uuid import uuid4 + +from backend.dto.common import ApiError, ErrorCode +from backend.dto.material_dto import Material +from backend.dto.workflow_dto import WorkflowNode +from backend.services.material_normalization_service import MaterialNormalizationError +from backend.services.material_service import ( + _normalize_upload_content_type, + _normalize_upload_filename, + _normalize_upload_metadata, + _normalize_upload_size, + _recognition_metadata, + _storage_image_data_url, + _vision_provider_error, +) +from backend.services.worker_service import WorkerTaskUpdate +from core.identity import RequestContext +from engines.image_provider import ImageProviderError +from engines.vision_provider import VisionProviderError, VisionRecognitionRequest + + +MIN_STYLE_SOURCES = 2 +MAX_STYLE_SOURCES = 8 +STYLE_SOURCE_TERMINAL = {"succeeded", "failed", "excluded", "cancelled"} +STYLE_SOURCE_EXECUTABLE = {"queued", "running"} +STYLE_CONSENSUS_EXECUTABLE = {"queued", "running"} +STYLE_CASE_EXECUTABLE = {"queued", "running"} +STYLE_ATTEMPT_BLOCKING = {"queued", "running", "validation_partial_failed", "awaiting_review"} +STYLE_SET_KIND = "advanced_style_set" +STYLE_VALIDATION_SEEDS = (240719, 240720, 240721) + +# The provider still returns a free-form review, but fidelity is deliberately +# recomputed on the server from a stable set of dimensions. This keeps scores +# comparable across providers and prevents a visually attractive image from +# receiving a high score while missing the actual line, face or shading grammar. +STYLE_REVIEW_SCHEMA_VERSION = 2 +STYLE_REVIEW_DIMENSIONS: tuple[str, ...] = ( + "face_structure", + "eye_design", + "hair_rendering", + "linework", + "palette_global", + "palette_local", + "shading", + "highlights", + "anatomy_scale", + "texture_detail", + "background_rendering", +) +STYLE_REVIEW_DIMENSION_ALIASES: dict[str, tuple[str, ...]] = { + "face_structure": ("face", "face_proportions", "facial_structure", "chin", "mouth_nose"), + "eye_design": ("eyes", "eye_geometry", "iris", "iris_construction", "eyelashes"), + "hair_rendering": ("hair", "hair_strands", "hair_mass", "strand_grouping"), + "linework": ("lines", "line_art", "lineart", "outline", "line_topology"), + "palette_global": ("palette", "color", "colour", "global_palette", "value_range", "saturation"), + "palette_local": ("local_color", "local_colour", "local_contrast", "color_separation", "colour_separation"), + "shading": ("shadow", "shadows", "shadow_rendering", "cel_shading"), + "highlights": ("highlight", "highlight_shape", "specular"), + "anatomy_scale": ("anatomy", "body_ratio", "head_to_body_ratio", "proportions"), + "texture_detail": ("texture", "detail", "detail_density", "rendering_detail"), + "background_rendering": ("background", "scene_rendering", "environment", "optical_effects"), +} +STYLE_REVIEW_WEIGHTS: dict[str, dict[str, float]] = { + "portrait": { + "face_structure": 0.20, "eye_design": 0.18, "hair_rendering": 0.11, "linework": 0.16, + "palette_global": 0.08, "palette_local": 0.07, "shading": 0.09, "highlights": 0.06, + "anatomy_scale": 0.02, "texture_detail": 0.03, "background_rendering": 0.00, + }, + "fullbody": { + "face_structure": 0.08, "eye_design": 0.06, "hair_rendering": 0.09, "linework": 0.19, + "palette_global": 0.10, "palette_local": 0.09, "shading": 0.13, "highlights": 0.05, + "anatomy_scale": 0.14, "texture_detail": 0.06, "background_rendering": 0.01, + }, + "novel_scene": { + "face_structure": 0.08, "eye_design": 0.06, "hair_rendering": 0.08, "linework": 0.18, + "palette_global": 0.12, "palette_local": 0.09, "shading": 0.12, "highlights": 0.06, + "anatomy_scale": 0.07, "texture_detail": 0.07, "background_rendering": 0.07, + }, +} + +DEFAULT_VALIDATION_CASES: tuple[dict[str, Any], ...] = ( + { + "case_key": "portrait", + "content_prompt": ( + "a new fictional heroine with short silver hair and teal eyes wearing a simple navy jacket, " + "head-and-shoulders portrait against a softly lit neutral studio background, with a distinct identity and wardrobe" + ), + "aspect_ratio": "1:1", + }, + { + "case_key": "fullbody", + "content_prompt": ( + "the same new fictional heroine with short silver hair and teal eyes wearing the same simple navy jacket, " + "complete head-to-toe full body standing pose in a clean daylight studio, with a distinct identity and wardrobe" + ), + "aspect_ratio": "2:3", + }, + { + "case_key": "novel_scene", + "content_prompt": ( + "the same new fictional heroine with short silver hair, teal eyes and navy jacket walking through a breezy rooftop garden at dawn, " + "wide environmental view with clear depth and a scene unrelated to the source samples" + ), + "aspect_ratio": "16:9", + }, +) + + +class AdvancedStyleSetService: + """Coordinate style-set work while reusing the advanced-material runtime.""" + + def __init__(self, owner: Any): + self.owner = owner + self.repository = owner.repository + self.material_repository = owner.material_repository + self.queue_service = owner.queue_service + self.audit_service = owner.audit_service + self.storage = owner.storage + self.normalization_service = owner.normalization_service + self.model_provider_runtime = owner.model_provider_runtime + self.single_flow_engine = owner.single_flow_engine + + @staticmethod + def is_style_set(record: Any) -> bool: + metadata = record.metadata if isinstance(getattr(record, "metadata", None), dict) else {} + return str(metadata.get("workflow_kind") or "").strip() == STYLE_SET_KIND + + def upload(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: + category_id = _optional_text(payload.get("category_id")) + category = self.material_repository.get_category(category_id) if category_id else None + if category is None: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "material category not found", {"category_id": category_id}) + if not _is_style_category(category): + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "multi-image advanced imports are only available for the style category", + {"category_id": category_id, "category_name": category.name, "required_category": "风格"}, + ) + images = payload.get("images") + if not isinstance(images, list) or not MIN_STYLE_SOURCES <= len(images) <= MAX_STYLE_SOURCES: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced style sets require between 2 and 8 source images", + {"field": "images", "min_items": MIN_STYLE_SOURCES, "max_items": MAX_STYLE_SOURCES}, + ) + if any(not isinstance(item, dict) for item in images): + raise ApiError(ErrorCode.VALIDATION_FAILED, "every style source must be an object", {"field": "images"}) + + import_id = f"advimp_{uuid4().hex}" + display_name = str(payload.get("display_name") or "进阶画风组").strip() or "进阶画风组" + upload_metadata = _normalize_upload_metadata(payload.get("metadata")) + recognition_route = _optional_text(payload.get("recognition_model_route")) or self.owner._recognition_route() + generation_route = _optional_text(payload.get("generation_model_route")) or self.owner._generation_route() + persisted: list[dict[str, Any]] = [] + try: + for index, image in enumerate(images): + source_id = f"advsrc_{uuid4().hex}" + filename = _normalize_upload_filename(image.get("filename")) + uri, detected_type, size_bytes, original_filename = self.owner._persist_source( + import_id=f"{import_id}/{source_id}", + image_data_url=str(image.get("image_data_url") or "").strip(), + image_uri=str(image.get("image_uri") or "").strip(), + filename=filename, + declared_content_type=_normalize_upload_content_type(image.get("content_type")), + declared_size=_normalize_upload_size(image), + ) + persisted.append( + { + "source_id": source_id, + "uri": uri, + "filename": original_filename, + "content_type": detected_type, + "size_bytes": size_bytes, + "sort_order": index, + "is_primary": index == 0, + "upload_source": str(image.get("upload_source") or "file"), + } + ) + + record, sources = self.repository.create_style_import_with_sources( + { + "import_id": import_id, + "category_id": category_id, + "display_name": display_name, + "source_image_uri": persisted[0]["uri"], + "source_thumbnail_uri": persisted[0]["uri"], + "status": "style_source_recognition_queued", + "recognition_model_route": recognition_route, + "prompt_revision": 0, + "created_by": ctx.actor_id, + "metadata": { + "workflow_kind": STYLE_SET_KIND, + "style_source_count": len(persisted), + "generation_model_route": generation_route, + "governance_context": {"user_id": ctx.actor_id, "entrypoint": "web"}, + "material_tier": "advanced_pending", + "upload": {**upload_metadata, "storage_root": "advanced_materials", "source": "style_set"}, + }, + }, + [ + { + "source_id": item["source_id"], + "import_id": import_id, + "sort_order": item["sort_order"], + "is_primary": item["is_primary"], + "source_image_uri": item["uri"], + "source_thumbnail_uri": item["uri"], + "status": "queued", + "recognition_model_route": recognition_route, + "metadata": { + "upload": { + "filename": item["filename"], + "content_type": item["content_type"], + "size_bytes": item["size_bytes"], + "source": item["upload_source"], + }, + "retry_count": 0, + }, + } + for item in persisted + ], + ) + except Exception: + for item in persisted: + self.owner._remove_uri(str(item.get("uri") or "")) + raise + + tasks = [] + for source in sources: + try: + tasks.append(self._queue_source(record, source, ctx)) + except Exception as exc: + self.repository.update_style_source( + source.source_id, + {"status": "failed", "error": _safe_failure(exc)}, + ) + # If task creation itself failed for every source there will be no + # worker callback to advance the parent record. Running the barrier + # here is harmless while any source is still queued and prevents a + # permanently busy import when all queue writes failed. + self._after_source_terminal(import_id, ctx) + current = self.owner._require_import(import_id) + self.audit_service.record( + ctx=ctx, + action="upload_advanced_style_set", + target_type="advanced_material_import", + target_id=import_id, + after_snapshot=current.to_dict(), + metadata={"source_count": len(sources), "task_ids": [task.task_id for task in tasks]}, + ) + return { + "import": current.to_dict(), + "sources": [item.to_dict() for item in self.repository.list_style_sources(import_id)], + "tasks": [task.to_dict() for task in tasks], + "queued": bool(tasks), + } + + def detail(self, record: Any) -> dict[str, Any]: + record = self.reconcile_missing_tasks(record) + sources = self.repository.list_style_sources(record.import_id) + consensuses = self.repository.list_style_consensus_runs(record.import_id) + attempts = self.repository.list_attempts(record.import_id) + cases = ( + self.repository.list_style_validation_cases(record.current_attempt_id) + if record.current_attempt_id + else [] + ) + return { + "style_set": True, + "sources": [item.to_dict() for item in sources], + "consensus": consensuses[0].to_dict() if consensuses else None, + "consensus_history": [item.to_dict() for item in consensuses], + "validation_cases": [item.to_dict() for item in cases], + "attempts": [item.to_dict() for item in attempts], + } + + def reconcile_missing_tasks(self, record: Any) -> Any: + """Turn dangling active child rows into explicit retryable failures. + + Queue retention and manual queue deletion legitimately remove terminal + task rows. If a split write left a child in queued/running state, the + task foreign key becomes NULL and the style workbench used to remain + busy forever. Reconciliation is deliberately side-effect free with + respect to providers: it never enqueues new work. + """ + + import_id = record.import_id + missing_sources: list[str] = [] + for source in self.repository.list_style_sources(import_id): + if source.status not in STYLE_SOURCE_EXECUTABLE or not self._task_missing(source.task_id): + continue + failure = _missing_queue_task_failure(source.task_id, "style_source_recognition") + self.repository.update_style_source( + source.source_id, + {"status": "failed", "task_id": None, "error": failure}, + ) + missing_sources.append(source.source_id) + + missing_consensus: list[str] = [] + for consensus in self.repository.list_style_consensus_runs(import_id): + if consensus.status not in STYLE_CONSENSUS_EXECUTABLE or not self._task_missing(consensus.task_id): + continue + failure = _missing_queue_task_failure(consensus.task_id, "style_consensus") + self.repository.update_style_consensus_run( + consensus.consensus_id, + {"status": "failed", "task_id": None, "error": failure}, + expected_statuses=STYLE_CONSENSUS_EXECUTABLE, + ) + missing_consensus.append(consensus.consensus_id) + + affected_attempts: set[str] = set() + for attempt in self.repository.list_attempts(import_id): + for case in self.repository.list_style_validation_cases(attempt.attempt_id): + if case.status not in STYLE_CASE_EXECUTABLE or not self._task_missing(case.task_id): + continue + failure = _missing_queue_task_failure(case.task_id, "style_validation_generation") + self.repository.update_style_validation_case( + case.case_id, + {"status": "failed", "task_id": None, "error": failure}, + expected_statuses=STYLE_CASE_EXECUTABLE, + ) + affected_attempts.add(attempt.attempt_id) + for attempt_id in affected_attempts: + self.repository.finalize_style_validation_batch_if_ready(import_id, attempt_id) + + if missing_sources: + record = self.repository.update_import( + import_id, + { + "status": "style_source_review_required", + "error": { + "error_type": "queue_task_missing", + "stage": "style_source_recognition", + "source_ids": missing_sources, + }, + }, + ) or record + elif missing_consensus: + record = self.repository.update_import( + import_id, + { + "status": "style_consensus_failed", + "error": { + "error_type": "queue_task_missing", + "stage": "style_consensus", + "consensus_ids": missing_consensus, + }, + }, + ) or record + elif affected_attempts: + record = self.repository.get_import(import_id) or record + return record + + def _task_missing(self, task_id: str | None) -> bool: + if not str(task_id or "").strip(): + return True + try: + self.queue_service.get_job(str(task_id)) + except ApiError: + return True + return False + + def retry_source(self, import_id: str, source_id: str, ctx: RequestContext) -> dict[str, Any]: + record = self.owner._require_import(import_id) + self._require_style_set(record) + self._require_sources_editable(record) + source = self._require_source(import_id, source_id) + if source.status not in {"failed", "excluded", "cancelled"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "style source is not retryable", + {"source_id": source_id, "status": source.status}, + ) + retry_count = int(source.metadata.get("retry_count") or 0) + 1 + # Failed source tasks persist the route that was active when the style + # set was uploaded. A configuration repair must take effect when the + # user explicitly retries; otherwise an obsolete route such as + # ``material_vlm`` is frozen forever and every retry repeats the same + # pre-provider failure. Keep normal first-run tasks immutable, but + # refresh both the child and parent route at this explicit retry + # boundary so the later consensus stage uses the same repaired chain. + refreshed_route = self.owner._recognition_route() + retry_route = ( + refreshed_route + or source.recognition_model_route + or record.recognition_model_route + ) + if retry_route and retry_route != record.recognition_model_route: + record = self.repository.update_import( + import_id, + {"recognition_model_route": retry_route}, + ) or record + source = self.repository.update_style_source( + source_id, + { + "status": "queued", + "task_id": None, + "error": None, + "excluded_at": None, + "recognition_model_route": retry_route, + "metadata": {**source.metadata, "retry_count": retry_count}, + }, + ) + try: + task = self._queue_source(record, source, ctx) + except Exception as exc: + self.repository.update_style_source( + source_id, + {"status": "failed", "task_id": None, "error": _safe_failure(exc)}, + ) + self._after_source_terminal(import_id, ctx) + raise + return {"import": self.owner._require_import(import_id).to_dict(), "source": source.to_dict(), "task": task.to_dict()} + + def exclude_source( + self, + import_id: str, + source_id: str, + excluded: bool, + ctx: RequestContext, + ) -> dict[str, Any]: + record = self.owner._require_import(import_id) + self._require_style_set(record) + self._require_sources_editable(record) + source = self._require_source(import_id, source_id) + if excluded: + if source.is_primary: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "the primary style source cannot be excluded; choose another primary before upload", + {"source_id": source_id}, + ) + remaining = [item for item in self.repository.list_style_sources(import_id) if item.source_id != source_id and item.status != "excluded"] + if len(remaining) < MIN_STYLE_SOURCES: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "at least two style sources must remain active", + {"min_sources": MIN_STYLE_SOURCES}, + ) + if source.task_id: + try: + self.queue_service.cancel_job(source.task_id, ctx, reason="style source excluded") + except ApiError: + pass + updated = self.repository.update_style_source( + source_id, + { + "status": "excluded", + "metadata": {**source.metadata, "status_before_exclusion": source.status}, + }, + ) + else: + restored = str(source.metadata.get("status_before_exclusion") or "").strip() + if source.recognition_result: + restored = "succeeded" + elif restored not in {"failed", "cancelled"}: + restored = "failed" + updated = self.repository.update_style_source( + source_id, + {"status": restored, "excluded_at": None}, + ) + self.repository.update_import(import_id, {"status": "style_source_review_required"}) + return {"import": self.owner._require_import(import_id).to_dict(), "source": updated.to_dict()} + + def create_consensus( + self, + import_id: str, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + record = self.owner._require_import(import_id) + self._require_style_set(record) + if record.status in {"accepted", "archived", "cancelled"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced style set no longer accepts consensus work", + {"import_id": import_id, "status": record.status}, + ) + if record.current_attempt_id: + current_attempt = self.repository.get_attempt(record.current_attempt_id) + if current_attempt is not None and current_attempt.status in STYLE_ATTEMPT_BLOCKING: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "finish or retry the current style validation batch before creating another consensus", + { + "import_id": import_id, + "attempt_id": current_attempt.attempt_id, + "attempt_status": current_attempt.status, + }, + ) + latest = self.repository.get_latest_style_consensus_run(import_id) + if latest is not None and latest.status in STYLE_CONSENSUS_EXECUTABLE: + task = None + if latest.task_id: + try: + task = self.queue_service.get_job(latest.task_id) + except ApiError: + task = None + if task is not None and task.status in {"queued", "running"}: + return {"import": record.to_dict(), "consensus": latest.to_dict(), "task": task.to_dict()} + # Repair a split write (child row says active but its queue record + # is absent/terminal) before attempting the next revision. The + # partial unique index otherwise rejects every future retry. + stale_error = { + "error_type": "missing_or_terminal_consensus_task", + "task_id": latest.task_id, + "task_status": getattr(task, "status", None), + } + latest = self.repository.update_style_consensus_run( + latest.consensus_id, + {"status": "failed", "error": stale_error}, + expected_statuses=STYLE_CONSENSUS_EXECUTABLE, + ) or latest + + sources = self.repository.list_style_sources(import_id, include_excluded=False) + active = [item for item in sources if item.status not in STYLE_SOURCE_TERMINAL] + succeeded = [item for item in sources if item.status == "succeeded"] + if active: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "style source recognition is still running", + {"active_source_ids": [item.source_id for item in active]}, + ) + if len(succeeded) < MIN_STYLE_SOURCES: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "at least two successfully recognized style sources are required", + {"succeeded": len(succeeded), "min_sources": MIN_STYLE_SOURCES}, + ) + revision = int(latest.revision if latest else 0) + 1 + legacy_adjustment = _optional_text(payload.get("adjustment_text")) + style_adjustment = _optional_text(payload.get("style_adjustment_text")) or legacy_adjustment + validation_instruction = _optional_text(payload.get("validation_instruction")) + reuse_cases = payload.get("reuse_validation_cases") if not validation_instruction else [] + style_adjustment_plan = _style_adjustment_plan(payload.get("style_adjustment_plan"), style_adjustment) + consensus = self.repository.create_style_consensus_run( + { + "consensus_id": f"advconsensus_{uuid4().hex}", + "import_id": import_id, + "revision": revision, + "status": "queued", + "model_route": record.recognition_model_route or self.owner._recognition_route(), + "source_ids": [item.source_id for item in succeeded], + "metadata": { + "adjustment_text": style_adjustment, + "style_adjustment_text": style_adjustment, + "validation_instruction": validation_instruction, + "reuse_validation_cases": reuse_cases if isinstance(reuse_cases, list) else [], + "style_adjustment_plan": style_adjustment_plan, + "comparison_attempt_id": _optional_text(payload.get("comparison_attempt_id")), + "comparison_consensus_id": _optional_text(payload.get("comparison_consensus_id")), + "comparison_source_ids": _string_list(payload.get("comparison_source_ids"))[:3], + "requested_by": ctx.actor_id, + }, + } + ) + try: + task = self.queue_service.create_task( + { + "task_type": "advanced_style_consensus", + "status": "queued", + "model_route": consensus.model_route, + "idempotency_key": f"advanced-style-consensus:{import_id}:{revision}", + "request": {"import_id": import_id, "consensus_id": consensus.consensus_id, "operation": "style_consensus"}, + "metadata": { + "source": "advanced_material", + "advanced_material_import_id": import_id, + "advanced_style_consensus_id": consensus.consensus_id, + "stage": "style_consensus", + "task_summary": f"进阶画风/{record.display_name}/第{revision}版交叉分析", + }, + }, + ctx, + ) + consensus = self.repository.update_style_consensus_run(consensus.consensus_id, {"task_id": task.task_id}) or consensus + self.repository.update_import( + import_id, + { + "status": "style_consensus_queued", + "error": None, + "metadata": {**record.metadata, "current_consensus_id": consensus.consensus_id}, + }, + ) + except Exception as exc: + failure = _safe_failure(exc) + self.repository.update_style_consensus_run( + consensus.consensus_id, + {"status": "failed", "error": failure}, + expected_statuses=STYLE_CONSENSUS_EXECUTABLE, + ) + self.repository.update_import( + import_id, + { + "status": "style_consensus_failed", + "error": failure, + "metadata": {**record.metadata, "current_consensus_id": consensus.consensus_id}, + }, + ) + raise + return {"import": self.owner._require_import(import_id).to_dict(), "consensus": consensus.to_dict(), "task": task.to_dict()} + + def retry_validation_case(self, import_id: str, case_id: str, ctx: RequestContext) -> dict[str, Any]: + record = self.owner._require_import(import_id) + self._require_style_set(record) + case = self._require_case(import_id, case_id) + if case.status not in {"failed", "cancelled"}: + raise ApiError(ErrorCode.VALIDATION_FAILED, "validation case is not retryable", {"case_id": case_id, "status": case.status}) + retry_count = int(case.metadata.get("retry_count") or 0) + 1 + case = self.repository.update_style_validation_case( + case_id, + { + "status": "queued", + "task_id": None, + "error": None, + "metadata": {**case.metadata, "retry_count": retry_count}, + }, + ) + try: + task = self._queue_validation_case(record, case, ctx) + except Exception as exc: + self.repository.update_style_validation_case( + case_id, + {"status": "failed", "task_id": None, "error": _safe_failure(exc)}, + expected_statuses={"queued"}, + ) + self.repository.finalize_style_validation_batch_if_ready(import_id, case.attempt_id) + raise + attempt = self.repository.update_attempt(case.attempt_id, {"status": "running", "error": None}) + self.repository.update_import(import_id, {"status": "validating", "error": None}) + return {"import": self.owner._require_import(import_id).to_dict(), "attempt": attempt.to_dict(), "case": case.to_dict(), "task": task.to_dict()} + + def ensure_validation( + self, + record: Any, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + """Return the active batch or create it from the latest consensus.""" + + self._require_style_set(record) + if record.current_attempt_id: + attempt = self.repository.get_attempt(record.current_attempt_id) + cases = self.repository.list_style_validation_cases(record.current_attempt_id) + if attempt is not None and cases and attempt.status in { + "queued", + "running", + "validation_partial_failed", + "awaiting_review", + }: + tasks = [] + for item in cases: + if not item.task_id: + continue + try: + tasks.append(self.queue_service.get_job(item.task_id).to_dict()) + except ApiError: + # The persisted case state remains authoritative. A + # missing old queue row must not make the detail/retry + # endpoint unusable after queue retention cleanup. + continue + return { + "import": record.to_dict(), + "attempt": attempt.to_dict(), + "validation_cases": [item.to_dict() for item in cases], + "tasks": tasks, + } + adjustment = _optional_text(payload.get("adjustment_text")) + if adjustment: + return self.create_consensus( + record.import_id, + {"adjustment_text": adjustment}, + ctx, + ) + consensus = self.repository.get_latest_style_consensus_run(record.import_id) + if consensus is None or consensus.status != "succeeded": + return self.create_consensus(record.import_id, {}, ctx) + attempt, cases, tasks = self._queue_validation_batch(record, consensus, ctx) + return { + "import": self.owner._require_import(record.import_id).to_dict(), + "attempt": attempt.to_dict(), + "validation_cases": [item.to_dict() for item in cases], + "tasks": [item.to_dict() for item in tasks], + } + + def execute_task(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: + if task.task_type == "advanced_style_source_recognition": + return self._execute_source(task, ctx) + if task.task_type == "advanced_style_consensus": + return self._execute_consensus(task, ctx) + if task.task_type == "advanced_style_validation_generation": + return self._execute_validation_case(task, ctx) + raise RuntimeError(f"unsupported advanced style task type: {task.task_type}") + + def handle_failure(self, task: Any, exc: Exception, ctx: RequestContext) -> None: + import_id = _optional_text(task.metadata.get("advanced_material_import_id")) + if not import_id: + return + record = self.repository.get_import(import_id) + if record is None or record.status in {"accepted", "archived", "cancelled"}: + return + failure = _safe_failure(exc) + handled = False + if task.task_type == "advanced_style_source_recognition": + source_id = _optional_text(task.metadata.get("advanced_style_source_id")) + if source_id: + source = self.repository.get_style_source(source_id) + if source is not None and source.import_id == import_id and source.task_id == task.task_id: + changed = self.repository.update_style_source_if_status( + source_id, + STYLE_SOURCE_EXECUTABLE, + {"status": "failed", "error": failure}, + ) + if changed is not None: + handled = True + self._after_source_terminal(import_id, ctx) + elif task.task_type == "advanced_style_consensus": + consensus_id = _optional_text(task.metadata.get("advanced_style_consensus_id")) + if consensus_id: + consensus = self.repository.get_style_consensus_run(consensus_id) + if consensus is not None and consensus.import_id == import_id and consensus.task_id == task.task_id: + changed = self.repository.update_style_consensus_run( + consensus_id, + {"status": "failed", "error": failure}, + expected_statuses=STYLE_CONSENSUS_EXECUTABLE, + ) + if changed is not None: + handled = True + self.repository.update_import(import_id, {"status": "style_consensus_failed", "error": failure}) + elif task.task_type == "advanced_style_validation_generation": + case_id = _optional_text(task.metadata.get("advanced_style_validation_case_id")) + if case_id: + case = self.repository.get_style_validation_case(case_id) + if case is not None and case.import_id == import_id and case.task_id == task.task_id: + changed = self.repository.update_style_validation_case( + case_id, + {"status": "failed", "error": failure}, + expected_statuses=STYLE_CASE_EXECUTABLE, + ) + if changed is not None: + handled = True + self.repository.finalize_style_validation_batch_if_ready(import_id, case.attempt_id) + if not handled: + # A stale worker/result must not overwrite a later retry, + # exclusion, cancellation or already-published success. + return + self.audit_service.record( + ctx=ctx, + action="advanced_style_task_failed", + target_type="advanced_material_import", + target_id=import_id, + metadata={"task_id": task.task_id, "task_type": task.task_type, "failure": failure}, + ) + + def reject_and_rebuild( + self, + record: Any, + attempt: Any, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + cases = self.repository.list_style_validation_cases(attempt.attempt_id) + if record.current_attempt_id != attempt.attempt_id or record.status != "awaiting_review" or attempt.status != "awaiting_review": + raise ApiError(ErrorCode.VALIDATION_FAILED, "only the current completed style validation batch can be rejected") + legacy_adjustment = _optional_text(payload.get("adjustment_text")) + style_adjustment = _optional_text(payload.get("style_adjustment_text")) + validation_instruction = _optional_text(payload.get("validation_instruction")) + if legacy_adjustment and not style_adjustment and not validation_instruction: + # Backward compatibility: the legacy single text box did not say + # whether feedback targeted style or validation content. Apply it + # to both paths so it can no longer be silently discarded. + style_adjustment = legacy_adjustment + validation_instruction = legacy_adjustment + if not style_adjustment and not validation_instruction: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "style_adjustment_text or validation_instruction is required", + {"fields": ["style_adjustment_text", "validation_instruction"]}, + ) + style_adjustment_plan = _parse_style_adjustment(style_adjustment) + comparison_consensus_id = _optional_text(attempt.metadata.get("style_consensus_id")) + comparison_consensus = ( + self.repository.get_style_consensus_run(comparison_consensus_id) + if comparison_consensus_id + else None + ) + comparison_source_ids = ( + _string_list(comparison_consensus.result.get("representative_source_ids"))[:3] + if comparison_consensus is not None + else [] + ) + adjustment_summary = _review_adjustment_summary(style_adjustment, validation_instruction) + self.repository.update_attempt( + attempt.attempt_id, + { + "status": "rejected", + "decision": "rejected", + "adjustment_text": adjustment_summary, + "decision_notes": _optional_text(payload.get("decision_notes")) or adjustment_summary, + "fidelity_score": _optional_score(payload.get("fidelity_score")), + "metadata": { + **attempt.metadata, + "style_adjustment_text": style_adjustment, + "validation_instruction": validation_instruction, + "style_adjustment_plan": style_adjustment_plan, + "comparison_consensus_id": comparison_consensus_id, + "comparison_source_ids": comparison_source_ids, + "rejected_by": ctx.actor_id, + }, + }, + ) + self.repository.update_import(record.import_id, {"status": "adjustment_required"}) + reuse_cases = [] if validation_instruction else [ + {"case_key": item.case_key, "content_prompt": item.content_prompt, "metadata": item.metadata} + for item in cases + ] + return self.create_consensus( + record.import_id, + { + "style_adjustment_text": style_adjustment, + "validation_instruction": validation_instruction, + "reuse_validation_cases": reuse_cases, + "style_adjustment_plan": style_adjustment_plan, + "comparison_attempt_id": attempt.attempt_id, + "comparison_consensus_id": comparison_consensus_id, + "comparison_source_ids": comparison_source_ids, + }, + ctx, + ) + + def accept( + self, + record: Any, + attempt: Any, + payload: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + if record.accepted_material_id: + material = self.repository.get_material(record.accepted_material_id) + if material is not None: + return {"import": record.to_dict(), "attempt": attempt.to_dict(), "material": material.to_dict()} + cases = self.repository.list_style_validation_cases(attempt.attempt_id) + if ( + record.current_attempt_id != attempt.attempt_id + or record.status != "awaiting_review" + or attempt.status != "awaiting_review" + or len(cases) != 3 + or any(item.status != "succeeded" or not item.validation_image_uri for item in cases) + ): + raise ApiError(ErrorCode.VALIDATION_FAILED, "all three current style validation cases must succeed before sealing") + consensus = self.repository.get_latest_style_consensus_run(record.import_id) + if consensus is None or consensus.status != "succeeded": + raise ApiError(ErrorCode.VALIDATION_FAILED, "the current style consensus is not complete") + expected_consensus = str(attempt.metadata.get("style_consensus_id") or "") + if expected_consensus and expected_consensus != consensus.consensus_id: + raise ApiError(ErrorCode.VALIDATION_FAILED, "validation batch does not belong to the latest style consensus") + sources = [item for item in self.repository.list_style_sources(record.import_id) if item.status == "succeeded"] + source_by_id = {item.source_id: item for item in sources} + result = consensus.result if isinstance(consensus.result, dict) else {} + representative_ids = [item for item in _string_list(result.get("representative_source_ids")) if item in source_by_id] + if not representative_ids: + representative_ids = [item.source_id for item in sources[:3]] + primary = next((item for item in sources if item.is_primary), sources[0]) + capsules = result.get("generation_capsules") if isinstance(result.get("generation_capsules"), dict) else {} + profile = result.get("normalized_asset_profile") if isinstance(result.get("normalized_asset_profile"), dict) else {} + fidelity_score = _optional_score(payload.get("fidelity_score")) + decision_notes = _optional_text(payload.get("decision_notes")) + attempt = self.repository.update_attempt( + attempt.attempt_id, + {"fidelity_score": fidelity_score, "decision_notes": decision_notes}, + ) or attempt + validation_payload = [item.to_dict() for item in cases] + metadata = { + "library_kind": "advanced", + "priority_class": "advanced_verified", + "material_priority": 100, + "workflow_kind": STYLE_SET_KIND, + "style_set": { + "source_ids": [item.source_id for item in sources], + "source_image_uris": [item.source_image_uri for item in sources], + "representative_source_ids": representative_ids[:3], + "reference_source_uris": [source_by_id[item].source_image_uri for item in representative_ids[:3]], + "consensus_id": consensus.consensus_id, + "consensus_revision": consensus.revision, + "validation_cases": validation_payload, + }, + "verification": { + "import_id": record.import_id, + "attempt_id": attempt.attempt_id, + "attempt_number": attempt.attempt_number, + "fidelity_score": fidelity_score, + "decision_notes": decision_notes, + "validation_image_uri": cases[0].validation_image_uri, + "prompt_revision": consensus.revision, + }, + "recognition": result.get("recognition") or {}, + "raw_analysis": result.get("raw_analysis") or {}, + "normalized_asset_profile": {**profile, "category": "style", "role": "style", "body_slots": ["global_style"], "confirmed": True}, + "generation_capsules": capsules, + "content_leakage_exclusions": result.get("content_leakage_exclusions") or [], + "confirmed": True, + } + material = self.repository.accept_attempt( + record.import_id, + attempt.attempt_id, + { + "material_id": f"advmat_{uuid4().hex}", + "category_id": record.category_id, + "display_name": record.display_name, + "source_image_uri": primary.source_image_uri, + "source_thumbnail_uri": primary.source_thumbnail_uri, + "validation_image_uri": cases[0].validation_image_uri, + "validation_thumbnail_uri": cases[0].validation_thumbnail_uri, + "prompt": consensus.prompt or record.recognition_prompt, + "negative_prompt": consensus.negative_prompt or record.recognition_negative_prompt, + "tags": consensus.tags, + "priority": 100, + "status": "active", + "capsule": capsules, + "decision_notes": decision_notes, + "metadata": metadata, + }, + ) + return { + "import": self.owner._require_import(record.import_id).to_dict(), + "attempt": self.owner._require_attempt(record.import_id, attempt.attempt_id).to_dict(), + "material": material.to_dict(), + } + + def cancel(self, record: Any, ctx: RequestContext) -> None: + task_ids: set[str] = set() + for source in self.repository.list_style_sources(record.import_id): + if source.task_id and source.status in STYLE_SOURCE_EXECUTABLE: + task_ids.add(source.task_id) + self.repository.update_style_source(source.source_id, {"status": "cancelled"}) + for consensus in self.repository.list_style_consensus_runs(record.import_id): + if consensus.task_id and consensus.status in STYLE_CONSENSUS_EXECUTABLE: + task_ids.add(consensus.task_id) + self.repository.update_style_consensus_run(consensus.consensus_id, {"status": "cancelled"}) + for attempt in self.repository.list_attempts(record.import_id): + for case in self.repository.list_style_validation_cases(attempt.attempt_id): + if case.task_id and case.status in STYLE_CASE_EXECUTABLE: + task_ids.add(case.task_id) + self.repository.update_style_validation_case(case.case_id, {"status": "cancelled"}) + for task_id in task_ids: + try: + self.queue_service.cancel_job(task_id, ctx, reason="advanced style set cancelled") + except ApiError: + pass + + def _queue_source(self, record: Any, source: Any, ctx: RequestContext): + retry_count = int(source.metadata.get("retry_count") or 0) + task = self.queue_service.create_task( + { + "task_type": "advanced_style_source_recognition", + "status": "queued", + "model_route": source.recognition_model_route or record.recognition_model_route or self.owner._recognition_route(), + "idempotency_key": f"advanced-style-source:{source.source_id}:{retry_count}", + "request": {"import_id": record.import_id, "source_id": source.source_id, "operation": "recognize_style_source"}, + "metadata": { + "source": "advanced_material", + "advanced_material_import_id": record.import_id, + "advanced_style_source_id": source.source_id, + "stage": "style_source_recognition", + "task_summary": f"进阶画风/{record.display_name}/样本{source.sort_order + 1}", + }, + }, + ctx, + ) + self.repository.update_style_source(source.source_id, {"status": "queued", "task_id": task.task_id, "error": None}) + self.repository.update_import(record.import_id, {"status": "style_source_recognition_queued", "error": None}) + return task + + def _execute_source(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: + import_id = _required_task_value(task, "advanced_material_import_id") + source_id = _required_task_value(task, "advanced_style_source_id") + record = self.owner._require_import(import_id) + self._require_style_set(record) + source = self._require_source(import_id, source_id) + if source.status == "succeeded": + return WorkerTaskUpdate(result={"source_id": source_id, "status": "succeeded"}) + if source.status not in STYLE_SOURCE_EXECUTABLE or source.task_id != task.task_id: + raise RuntimeError("style source recognition no longer owns the source") + source = self.repository.update_style_source_if_status(source_id, {"queued", "running"}, {"status": "running", "error": None}) + if source is None: + raise RuntimeError("style source recognition could not claim the source") + self.repository.update_import(import_id, {"status": "recognizing_style_sources"}) + route_name = source.recognition_model_route or record.recognition_model_route or self.owner._recognition_route() + provider = self.model_provider_runtime.vision_provider_for_route( + {"route_name": route_name, "modality": "vision_recognition", "material_id": source_id, "image_uri": source.source_image_uri} + ) + if provider is None: + raise ApiError(ErrorCode.MODEL_CAPABILITY_UNCONFIRMED, "advanced style vision route is unavailable", {"route_name": route_name}) + image_data_url, content_type, size_bytes = _storage_image_data_url(source.source_image_uri, {}, self.storage) + request = VisionRecognitionRequest( + display_name=f"{record.display_name} / sample {source.sort_order + 1}", + image_uri=image_data_url, + metadata={ + "recognition_instruction": _single_style_instruction(), + "style_set": True, + "source_id": source_id, + "vision_input": {"source_uri": source.source_image_uri, "content_type": content_type, "size_bytes": size_bytes}, + }, + ) + try: + recognition = provider.recognize_material(request) + except VisionProviderError as exc: + raise ApiError(ErrorCode.GENERATION_FAILED, "advanced style source recognition failed", _vision_provider_error(exc)) from None + structures = self.normalization_service.normalize_recognition( + recognition.structured_data, + prompt=recognition.prompt, + negative_prompt=recognition.negative_prompt, + tags=recognition.tags, + confidence=recognition.confidence, + provider_id=recognition.provider_id, + model=recognition.model, + route_name=route_name, + category_hint="风格", + ) + structures = _force_style_structures(structures) + result = {"recognition": _recognition_metadata(recognition, route_name=route_name), **structures} + updated = self.repository.update_style_source_if_status( + source_id, + {"running"}, + { + "status": "succeeded", + "provider_id": recognition.provider_id, + "provider_model": recognition.model, + "recognition_prompt": recognition.prompt, + "recognition_negative_prompt": recognition.negative_prompt, + "recognition_tags": recognition.tags, + "recognition_result": result, + "error": None, + }, + ) + if updated is None: + raise RuntimeError("style source result arrived after exclusion or cancellation") + self._after_source_terminal(import_id, ctx) + return WorkerTaskUpdate(result={"import_id": import_id, "source_id": source_id, "status": "succeeded"}, metadata={"pipeline_stage": "style_source_completed"}) + + def _after_source_terminal(self, import_id: str, ctx: RequestContext) -> None: + record = self.repository.get_import(import_id) + if record is None or record.status in {"cancelled", "accepted", "archived"}: + return + sources = self.repository.list_style_sources(import_id, include_excluded=False) + if any(item.status not in STYLE_SOURCE_TERMINAL for item in sources): + return + succeeded = [item for item in sources if item.status == "succeeded"] + if len(succeeded) < MIN_STYLE_SOURCES: + self.repository.update_import(import_id, {"status": "style_source_review_required", "error": {"error_type": "insufficient_style_sources"}}) + return + failed = [item for item in sources if item.status in {"failed", "cancelled"}] + if failed: + self.repository.update_import(import_id, {"status": "style_source_review_required", "error": {"error_type": "style_source_partial_failure", "source_ids": [item.source_id for item in failed]}}) + return + try: + self.create_consensus(import_id, {"automatic": True}, ctx) + except Exception: + latest = self.repository.get_latest_style_consensus_run(import_id) + if latest is None or latest.status not in {"queued", "running", "succeeded"}: + # Source recognition itself succeeded. A queue/database + # failure while scheduling the next stage is represented on + # the parent/consensus and must not retroactively fail the + # source task that happened to cross the barrier last. + failure = latest.error if latest is not None else {"error_type": "consensus_enqueue_failed"} + self.repository.update_import( + import_id, + {"status": "style_consensus_failed", "error": failure}, + ) + return + + def _execute_consensus(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: + import_id = _required_task_value(task, "advanced_material_import_id") + consensus_id = _required_task_value(task, "advanced_style_consensus_id") + record = self.owner._require_import(import_id) + self._require_style_set(record) + consensus = self.repository.get_style_consensus_run(consensus_id) + if consensus is None or consensus.import_id != import_id: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "style consensus does not exist", {"consensus_id": consensus_id}) + if consensus.status == "succeeded": + return WorkerTaskUpdate(result={"consensus_id": consensus_id, "status": "succeeded"}) + if consensus.status not in STYLE_CONSENSUS_EXECUTABLE or consensus.task_id != task.task_id: + raise RuntimeError("style consensus no longer owns the import") + consensus = self.repository.update_style_consensus_run( + consensus_id, + {"status": "running", "error": None}, + expected_statuses={"queued", "running"}, + ) + if consensus is None: + raise RuntimeError("style consensus could not be claimed") + self.repository.update_import(import_id, {"status": "style_consensus_running"}) + sources = [ + self._require_source(import_id, source_id) + for source_id in consensus.source_ids + ] + sources = [item for item in sources if item.status == "succeeded"] + if len(sources) < MIN_STYLE_SOURCES: + raise ApiError(ErrorCode.VALIDATION_FAILED, "style consensus lost its successful source quorum") + source_by_id = {item.source_id: item for item in sources} + source_reports: list[dict[str, Any]] = [] + for source in sources: + source_reports.append( + { + "source_id": source.source_id, + "sort_order": source.sort_order, + "prompt": source.recognition_prompt, + "negative_prompt": source.recognition_negative_prompt, + "tags": source.recognition_tags, + "analysis": source.recognition_result, + } + ) + style_adjustment = _optional_text( + consensus.metadata.get("style_adjustment_text") or consensus.metadata.get("adjustment_text") + ) + style_adjustment_plan = _style_adjustment_plan( + consensus.metadata.get("style_adjustment_plan"), + style_adjustment, + ) + comparison_attempt_id = _optional_text(consensus.metadata.get("comparison_attempt_id")) + comparison_consensus_id = _optional_text(consensus.metadata.get("comparison_consensus_id")) + comparison_consensus = ( + self.repository.get_style_consensus_run(comparison_consensus_id) + if comparison_consensus_id + else None + ) + previous_cases = ( + [ + item + for item in self.repository.list_style_validation_cases(comparison_attempt_id) + if item.import_id == import_id and item.validation_image_uri + ][:3] + if comparison_attempt_id + else [] + ) + image_urls: list[str] = [] + image_manifest: list[dict[str, Any]] = [] + comparison_source_ids = [ + item + for item in _string_list(consensus.metadata.get("comparison_source_ids")) + if item in source_by_id + ][:3] + if previous_cases and not comparison_source_ids and comparison_consensus is not None: + comparison_source_ids = [ + item + for item in _string_list(comparison_consensus.result.get("representative_source_ids")) + if item in source_by_id + ][:3] + if previous_cases: + comparison_source_ids = comparison_source_ids or [item.source_id for item in sources[:3]] + for source_id in comparison_source_ids: + source = source_by_id[source_id] + image_url, _, _ = _storage_image_data_url(source.source_image_uri, {}, self.storage) + image_urls.append(image_url) + image_manifest.append( + { + "image_index": len(image_urls) - 1, + "kind": "source_reference", + "source_id": source.source_id, + "image_uri": source.source_image_uri, + } + ) + for case in previous_cases: + image_url, _, _ = _storage_image_data_url(str(case.validation_image_uri), {}, self.storage) + image_urls.append(image_url) + image_manifest.append( + { + "image_index": len(image_urls) - 1, + "kind": "previous_validation", + "case_id": case.case_id, + "case_key": case.case_key, + "image_uri": case.validation_image_uri, + } + ) + else: + for source in sources: + image_url, _, _ = _storage_image_data_url(source.source_image_uri, {}, self.storage) + image_urls.append(image_url) + image_manifest.append( + { + "image_index": len(image_urls) - 1, + "kind": "source_reference", + "source_id": source.source_id, + "image_uri": source.source_image_uri, + } + ) + automatic_review_feedback = _aggregate_style_review_feedback(previous_cases) + comparison_payload = { + "attempt_id": comparison_attempt_id, + "consensus_id": comparison_consensus_id, + "previous_prompt": comparison_consensus.prompt if comparison_consensus is not None else None, + "previous_negative_prompt": comparison_consensus.negative_prompt if comparison_consensus is not None else None, + "previous_generation_capsules": ( + comparison_consensus.result.get("generation_capsules") + if comparison_consensus is not None + else None + ), + "validation_cases": [ + { + "case_id": item.case_id, + "case_key": item.case_key, + "content_prompt": item.content_prompt, + "final_prompt": item.final_prompt, + "style_review": item.style_review, + "validation_image_uri": item.validation_image_uri, + } + for item in previous_cases + ], + "automatic_review_feedback": automatic_review_feedback, + } + route_name = consensus.model_route or record.recognition_model_route or self.owner._recognition_route() + provider = self.model_provider_runtime.vision_provider_for_route( + {"route_name": route_name, "modality": "vision_recognition", "material_id": consensus_id, "image_uri": sources[0].source_image_uri} + ) + if provider is None: + raise ApiError(ErrorCode.MODEL_CAPABILITY_UNCONFIRMED, "advanced style consensus route is unavailable", {"route_name": route_name}) + request = VisionRecognitionRequest( + display_name=f"{record.display_name} / cross-image style consensus", + image_uri=image_urls[0], + image_uris=tuple(image_urls[1:]), + prompt=json.dumps( + { + "source_reports": source_reports, + "image_manifest": image_manifest, + "previous_validation": comparison_payload, + "automatic_review_feedback": automatic_review_feedback, + "style_adjustment_plan": style_adjustment_plan, + "human_style_feedback": style_adjustment, + }, + ensure_ascii=False, + ), + metadata={ + "recognition_instruction": _consensus_instruction( + source_ids=[item.source_id for item in sources], + style_adjustment=style_adjustment, + style_adjustment_plan=style_adjustment_plan, + validation_instruction=_optional_text(consensus.metadata.get("validation_instruction")), + has_previous_validation=bool(previous_cases), + ), + "style_set": True, + "consensus_id": consensus_id, + "comparison_attempt_id": comparison_attempt_id, + "comparison_consensus_id": comparison_consensus_id, + "image_manifest": image_manifest, + "style_adjustment_plan": style_adjustment_plan, + "automatic_review_feedback": automatic_review_feedback, + }, + ) + try: + recognition = provider.recognize_material(request) + except VisionProviderError as exc: + raise ApiError(ErrorCode.GENERATION_FAILED, "advanced style cross-image analysis failed", _vision_provider_error(exc)) from None + try: + structures = self.normalization_service.normalize_recognition( + recognition.structured_data, + prompt=recognition.prompt, + negative_prompt=recognition.negative_prompt, + tags=recognition.tags, + confidence=recognition.confidence, + provider_id=recognition.provider_id, + model=recognition.model, + route_name=route_name, + category_hint="风格", + ) + except MaterialNormalizationError as exc: + raise ApiError(ErrorCode.GENERATION_FAILED, "style consensus returned invalid structures") from exc + structures = _force_style_structures(structures) + effective_prompt, effective_negative_prompt, structures, adjustment_guard = _apply_style_adjustment_guard( + recognition.prompt, + recognition.negative_prompt, + structures, + style_adjustment_plan, + ) + valid_ids = {item.source_id for item in sources} + provider_result = recognition.structured_data if isinstance(recognition.structured_data, dict) else {} + reused = consensus.metadata.get("reuse_validation_cases") + validation_instruction = _optional_text(consensus.metadata.get("validation_instruction")) + validation_cases = _validation_cases( + provider_result.get("validation_cases"), + reused, + validation_instruction=validation_instruction, + ) + result = { + "recognition": { + **_recognition_metadata(recognition, route_name=route_name), + "effective_prompt": effective_prompt, + "effective_negative_prompt": effective_negative_prompt, + }, + **structures, + "consensus_style": _object(provider_result.get("consensus_style")), + "variable_style_features": _list(provider_result.get("variable_style_features")), + "source_content_features": _list(provider_result.get("source_content_features")), + "content_leakage_exclusions": _string_list(provider_result.get("content_leakage_exclusions")), + "outlier_source_ids": [item for item in _string_list(provider_result.get("outlier_source_ids")) if item in valid_ids], + "representative_source_ids": [item for item in _string_list(provider_result.get("representative_source_ids")) if item in valid_ids][:3] + or [item.source_id for item in sources[:3]], + "consensus_confidence": _calibrated_style_confidence( + provider_result, + recognition.confidence, + structures, + ), + "feature_evidence": _list(provider_result.get("feature_evidence")), + "prompt_priority_groups": _object(provider_result.get("prompt_priority_groups")), + "scale_capsules": _object(provider_result.get("scale_capsules")), + "semantic_risk_audit": _list(provider_result.get("semantic_risk_audit")), + "validation_cases": validation_cases, + "human_adjustments": { + "style_adjustment_text": _optional_text(consensus.metadata.get("style_adjustment_text")), + "validation_instruction": validation_instruction, + "style_adjustment_plan": style_adjustment_plan, + "guard": adjustment_guard, + }, + "comparison_context": comparison_payload, + "automatic_review_feedback": automatic_review_feedback, + "image_manifest": image_manifest, + "effective_style_prompt": effective_prompt, + "effective_style_negative_prompt": effective_negative_prompt, + "source_ids": [item.source_id for item in sources], + } + updated = self.repository.update_style_consensus_run( + consensus_id, + { + "status": "succeeded", + "provider_id": recognition.provider_id, + "provider_model": recognition.model, + "prompt": effective_prompt, + "negative_prompt": effective_negative_prompt, + "tags": recognition.tags, + "result": result, + "error": None, + "metadata": { + **consensus.metadata, + "style_adjustment_plan": style_adjustment_plan, + "comparison_attempt_id": comparison_attempt_id, + "comparison_consensus_id": comparison_consensus_id, + "image_manifest": image_manifest, + }, + }, + expected_statuses={"running"}, + ) + if updated is None: + raise RuntimeError("style consensus result arrived after cancellation or replacement") + self.repository.update_import( + import_id, + { + "status": "ready_for_validation", + "recognition_prompt": effective_prompt, + "recognition_negative_prompt": effective_negative_prompt, + "recognition_tags": recognition.tags, + "recognition_result": result, + "prompt_revision": consensus.revision, + "error": None, + "metadata": {**record.metadata, "current_consensus_id": consensus_id}, + }, + ) + try: + attempt, cases, tasks = self._queue_validation_batch( + self.owner._require_import(import_id), + updated, + ctx, + ) + except Exception as exc: + # The reusable consensus is already valid. Keep it and expose a + # retryable validation-stage failure instead of forcing another + # paid/expensive cross-image analysis. + self.repository.update_import( + import_id, + {"status": "validation_failed", "error": _safe_failure(exc)}, + ) + raise + return WorkerTaskUpdate( + result={"import_id": import_id, "consensus_id": consensus_id, "attempt_id": attempt.attempt_id, "case_ids": [item.case_id for item in cases], "next_task_ids": [item.task_id for item in tasks]}, + metadata={"pipeline_stage": "style_consensus_completed"}, + ) + + def _queue_validation_batch(self, record: Any, consensus: Any, ctx: RequestContext): + route_name = _optional_text(record.metadata.get("generation_model_route")) or self.owner._generation_route() + validation_instruction = _optional_text(consensus.metadata.get("validation_instruction")) + style_adjustment = _optional_text(consensus.metadata.get("style_adjustment_text") or consensus.metadata.get("adjustment_text")) + plans = _validation_cases( + consensus.result.get("validation_cases"), + consensus.metadata.get("reuse_validation_cases"), + validation_instruction=validation_instruction, + ) + leakage = _string_list(consensus.result.get("content_leakage_exclusions")) + detailed_style_prompt = _detailed_style_prompt(consensus.result, consensus.prompt) + detailed_style_negative = _detailed_style_negative_prompt(consensus.result, consensus.negative_prompt) + negative = _join_prompt( + detailed_style_negative, + "exact source character identity, exact source costume design, exact source pose, exact source setting, " + "generic semi-realistic reinterpretation, realistic facial anatomy when absent from the source style, text, watermark", + ) + case_payloads = [] + for index, plan in enumerate(plans): + content_prompt = str(plan["content_prompt"]).strip() + case_key = str(plan["case_key"]) + scale_style_prompt = _scale_specific_style_prompt(consensus.result, case_key) + scale_style_negative = _scale_specific_style_negative_prompt(consensus.result, case_key) + case_negative = _join_prompt(negative, scale_style_negative) + final_prompt = _join_prompt( + detailed_style_prompt, + scale_style_prompt, + content_prompt, + _scale_transfer_instruction(case_key), + "transfer the complete shared visual grammar, including facial proportions, eye geometry, nose and mouth simplification, " + "hair strand grouping, line topology, local line colors, shading edges, palette relationships and highlight shapes; " + "do not reproduce any exact source identity, costume, pose or setting; preserve the requested validation subject and composition", + ) + case_payloads.append( + { + "case_id": f"advcase_{uuid4().hex}", + "case_key": case_key, + "sort_order": index, + "status": "queued", + "content_prompt": content_prompt, + "final_prompt": final_prompt, + "negative_prompt": case_negative, + "model_route": route_name, + "seed": _style_validation_seed(index, consensus.revision, refresh_content=bool(validation_instruction)), + "width": 1024, + "height": 1024, + "metadata": { + "aspect_ratio": plan.get("aspect_ratio") or DEFAULT_VALIDATION_CASES[index]["aspect_ratio"], + "style_consensus_id": consensus.consensus_id, + "style_consensus_revision": consensus.revision, + "style_adjustment_text": style_adjustment, + "style_adjustment_plan": consensus.result.get("human_adjustments", {}).get("style_adjustment_plan", {}), + "validation_instruction": validation_instruction, + "content_refresh": bool(validation_instruction), + "style_capsule_tier": "detailed", + "effective_style_prompt": detailed_style_prompt, + "effective_style_negative_prompt": detailed_style_negative, + "scale_style_prompt": scale_style_prompt, + "scale_style_negative_prompt": scale_style_negative, + "style_compiler_version": 2, + "content_leakage_exclusions": leakage, + "retry_count": 0, + "prompt_only": True, + }, + } + ) + attempt, cases = self.repository.create_style_validation_batch( + { + "attempt_id": f"advattempt_{uuid4().hex}", + "import_id": record.import_id, + "status": "running", + "adjustment_text": _review_adjustment_summary(style_adjustment, validation_instruction), + "prompt": detailed_style_prompt or consensus.prompt or record.recognition_prompt, + "negative_prompt": negative, + "model_route": route_name, + "seed": _style_validation_seed(0, consensus.revision, refresh_content=bool(validation_instruction)), + "width": 1024, + "height": 1024, + "metadata": { + "style_consensus_id": consensus.consensus_id, + "style_consensus_revision": consensus.revision, + "style_set": True, + "style_adjustment_text": style_adjustment, + "validation_instruction": validation_instruction, + }, + }, + case_payloads, + ) + tasks = [] + for case in cases: + try: + tasks.append(self._queue_validation_case(record, case, ctx)) + except Exception as exc: + self.repository.update_style_validation_case( + case.case_id, + {"status": "failed", "task_id": None, "error": _safe_failure(exc)}, + expected_statuses={"queued"}, + ) + self.repository.update_import( + record.import_id, + { + "status": "validating", + "current_attempt_id": attempt.attempt_id, + "error": None, + "metadata": {**record.metadata, "active_task_ids": [item.task_id for item in tasks], "current_consensus_id": consensus.consensus_id}, + }, + ) + # All three task insertions may fail before any worker exists to run + # the aggregation callback. Re-evaluate immediately so the batch is + # retryable instead of remaining in a false "validating" state. + _, attempt, cases = self.repository.finalize_style_validation_batch_if_ready( + record.import_id, + attempt.attempt_id, + ) + return attempt, cases, tasks + + def _queue_validation_case(self, record: Any, case: Any, ctx: RequestContext): + retry_count = int(case.metadata.get("retry_count") or 0) + task = self.queue_service.create_task( + { + "task_type": "advanced_style_validation_generation", + "status": "queued", + "model_route": case.model_route or self.owner._generation_route(), + "idempotency_key": f"advanced-style-validation:{case.case_id}:{retry_count}", + "request": {"import_id": record.import_id, "attempt_id": case.attempt_id, "case_id": case.case_id, "operation": "validate_style_transfer"}, + "metadata": { + "source": "advanced_material", + "advanced_material_import_id": record.import_id, + "advanced_material_attempt_id": case.attempt_id, + "advanced_style_validation_case_id": case.case_id, + "stage": "style_validation_generation", + "task_summary": f"进阶画风/{record.display_name}/{case.case_key}迁移验证", + }, + }, + ctx, + ) + self.repository.update_style_validation_case(case.case_id, {"status": "queued", "task_id": task.task_id, "error": None}) + return task + + def _execute_validation_case(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: + import_id = _required_task_value(task, "advanced_material_import_id") + attempt_id = _required_task_value(task, "advanced_material_attempt_id") + case_id = _required_task_value(task, "advanced_style_validation_case_id") + record = self.owner._require_import(import_id) + self._require_style_set(record) + attempt = self.owner._require_attempt(import_id, attempt_id) + case = self._require_case(import_id, case_id) + if case.status == "succeeded" and case.validation_image_uri: + return WorkerTaskUpdate(result={"case_id": case_id, "status": "succeeded"}) + if case.status not in STYLE_CASE_EXECUTABLE or case.task_id != task.task_id: + raise RuntimeError("style validation case no longer owns the task") + case = self.repository.update_style_validation_case(case_id, {"status": "running", "error": None}, expected_statuses={"queued", "running"}) + if case is None: + raise RuntimeError("style validation case could not be claimed") + self.repository.update_attempt(attempt_id, {"status": "running", "error": None}) + self.repository.update_import(import_id, {"status": "validating", "error": None}) + case_attempt = replace(attempt, prompt=case.final_prompt, negative_prompt=case.negative_prompt, model_route=case.model_route) + requested_route = case.model_route or self.owner._generation_route() + governance = self.owner._govern_validation_prompt(record=record, attempt=case_attempt, requested_route=requested_route, ctx=ctx) + route_name = str(governance["selected_route"]) + resolved_route = self.owner._resolve_generation_route(route_name) + cost_guard = self.owner._check_validation_budget(route_name, resolved_route) + node = WorkflowNode( + node_id=f"advanced-style:{case_id}", + workflow_id=f"advanced-style:{import_id}", + node_key="advanced_style_transfer_validation", + title=f"进阶画风迁移验证 / {case.case_key}", + description=None, + step_name="style_validation", + node_type="generation", + status="running", + branch_name="main", + prompt=governance["prompt"], + negative_prompt=governance["negative_prompt"], + model_route=route_name, + selected_image_id=None, + sort_order=case.sort_order, + metadata={"advanced_material": True, "style_set": True, "prompt_only": True}, + created_at=case.created_at, + updated_at=case.updated_at, + ) + request = { + "count": 1, + "aspect_ratio": str(case.metadata.get("aspect_ratio") or "1:1"), + "quality": "standard", + "seed": int(case.seed or STYLE_VALIDATION_SEEDS[case.sort_order]), + "model_route": route_name, + "resolved_model_route": resolved_route, + "allow_provider_fallback": False, + "expanded_prompt": governance["prompt"], + "expanded_negative_prompt": governance["negative_prompt"], + "prompt_governance": governance["snapshot"], + **({"cost_guard": cost_guard} if cost_guard else {}), + # Intentionally no image/input_images key. This validates style + # transfer from the consensus text into unrelated content. + "output_scope": { + "kind": "advanced_style_validation", + "import_id": import_id, + "attempt_id": attempt_id, + "case_id": case_id, + "case_key": case.case_key, + }, + } + assets = [] + try: + try: + assets = self.single_flow_engine.generate(node, task, request) + except ImageProviderError as exc: + fallback = self.owner._content_safety_fallback( + exc=exc, + runtime_request=request, + governance=governance, + requested_route=requested_route, + record=record, + ctx=ctx, + ) + if fallback is None: + raise + route_name = fallback["model_route"] + resolved_route = fallback["resolved_model_route"] + request = fallback["request"] + assets = self.single_flow_engine.generate(node, task, request) + except Exception: + for asset in assets: + self.owner._remove_uri(str(getattr(asset, "image_uri", "") or "")) + self.owner._remove_uri(str(getattr(asset, "thumbnail_uri", "") or "")) + raise + if len(assets) != 1: + raise ImageProviderError("advanced style validation must return exactly one image", provider_id=str(resolved_route.get("provider_id") or "unknown"), error_type="invalid_response") + asset = assets[0] + latest = self.repository.get_style_validation_case(case_id) + if latest is None or latest.status != "running" or latest.task_id != task.task_id: + self.owner._remove_uri(asset.image_uri) + self.owner._remove_uri(asset.thumbnail_uri) + raise RuntimeError("style validation result arrived after cancellation or retry") + style_review, fidelity_score = self._review_validation_image( + record=record, + case=case, + validation_image_uri=asset.image_uri, + ) + updated = self.repository.update_style_validation_case( + case_id, + { + "status": "succeeded", + "model_route": route_name, + "provider_id": asset.metadata.get("provider_id") or resolved_route.get("provider_id"), + "provider_model": asset.metadata.get("provider_model") or resolved_route.get("model_id"), + "width": asset.width, + "height": asset.height, + "validation_image_uri": asset.image_uri, + "validation_thumbnail_uri": asset.thumbnail_uri, + "usage": asset.metadata.get("usage") or {}, + "style_review": style_review, + "fidelity_score": fidelity_score, + "metadata": { + **case.metadata, + "generation": asset.metadata, + "prompt_governance": governance["snapshot"], + "prompt_only": True, + "automatic_style_review": style_review, + }, + "error": None, + }, + expected_statuses={"running"}, + ) + if updated is None: + self.owner._remove_uri(asset.image_uri) + self.owner._remove_uri(asset.thumbnail_uri) + raise RuntimeError("style validation result could not be published") + current_import, current_attempt, cases = self.repository.finalize_style_validation_batch_if_ready(import_id, attempt_id) + review_scores = [float(item.fidelity_score) for item in cases if item.fidelity_score is not None] + if review_scores: + current_attempt = self.repository.update_attempt( + attempt_id, + { + "fidelity_score": sum(review_scores) / len(review_scores), + "metadata": { + **current_attempt.metadata, + "automatic_style_review": { + "reviewed_cases": len(review_scores), + "total_cases": len(cases), + "average_fidelity_score": sum(review_scores) / len(review_scores), + }, + }, + }, + ) or current_attempt + if current_attempt.status == "awaiting_review": + attempts = self.repository.list_attempts(import_id) + previous_attempt = next( + ( + item + for item in attempts + if item.attempt_id != current_attempt.attempt_id and item.fidelity_score is not None + ), + None, + ) + comparison = _style_attempt_comparison( + current_attempt=current_attempt, + current_cases=cases, + previous_attempt=previous_attempt, + previous_cases=( + self.repository.list_style_validation_cases(previous_attempt.attempt_id) + if previous_attempt is not None + else [] + ), + ) + current_attempt = self.repository.update_attempt( + attempt_id, + { + "metadata": { + **current_attempt.metadata, + "style_regression_evaluation": comparison, + } + }, + ) or current_attempt + return WorkerTaskUpdate( + result={ + "import_id": import_id, + "attempt_id": attempt_id, + "case_id": case_id, + "status": updated.status, + "batch_status": current_attempt.status, + "validation_image_uri": updated.validation_image_uri, + "fidelity_score": updated.fidelity_score, + }, + metadata={"pipeline_stage": "style_validation_case_completed" if current_attempt.status != "awaiting_review" else "awaiting_human_review"}, + ) + + def _review_validation_image( + self, + *, + record: Any, + case: Any, + validation_image_uri: str, + ) -> tuple[dict[str, Any], float | None]: + consensus_id = _optional_text(case.metadata.get("style_consensus_id")) + consensus = self.repository.get_style_consensus_run(consensus_id) if consensus_id else None + if consensus is None or consensus.status != "succeeded": + return {"status": "skipped", "reason": "style_consensus_unavailable"}, None + sources = [item for item in self.repository.list_style_sources(record.import_id) if item.status == "succeeded"] + source_by_id = {item.source_id: item for item in sources} + representative_ids = [ + item + for item in _string_list(consensus.result.get("representative_source_ids")) + if item in source_by_id + ][:3] + representative_ids = representative_ids or [item.source_id for item in sources[:3]] + image_urls: list[str] = [] + image_manifest: list[dict[str, Any]] = [] + try: + for source_id in representative_ids: + source = source_by_id[source_id] + image_url, _, _ = _storage_image_data_url(source.source_image_uri, {}, self.storage) + image_urls.append(image_url) + image_manifest.append( + { + "image_index": len(image_urls) - 1, + "kind": "source_reference", + "source_id": source_id, + } + ) + validation_url, _, _ = _storage_image_data_url(validation_image_uri, {}, self.storage) + image_urls.append(validation_url) + image_manifest.append( + { + "image_index": len(image_urls) - 1, + "kind": "generated_validation", + "case_id": case.case_id, + "case_key": case.case_key, + } + ) + except Exception as exc: + return {"status": "review_failed", "error": _safe_failure(exc)}, None + route_name = consensus.model_route or record.recognition_model_route or self.owner._recognition_route() + provider = self.model_provider_runtime.vision_provider_for_route( + { + "route_name": route_name, + "modality": "vision_recognition", + "material_id": case.case_id, + "image_uri": validation_image_uri, + } + ) + if provider is None: + return {"status": "review_failed", "reason": "vision_route_unavailable", "route_name": route_name}, None + request = VisionRecognitionRequest( + display_name=f"{record.display_name} / {case.case_key} style fidelity review", + image_uri=image_urls[0], + image_uris=tuple(image_urls[1:]), + prompt=json.dumps( + { + "image_manifest": image_manifest, + "consensus_prompt": consensus.prompt, + "consensus_negative_prompt": consensus.negative_prompt, + "generation_capsules": consensus.result.get("generation_capsules"), + "prompt_priority_groups": consensus.result.get("prompt_priority_groups"), + "scale_capsules": consensus.result.get("scale_capsules"), + "semantic_risk_audit": consensus.result.get("semantic_risk_audit"), + "validation_content_prompt": case.content_prompt, + "actual_generation_prompt": case.final_prompt, + "validation_scenario": case.case_key, + }, + ensure_ascii=False, + ), + metadata={ + "recognition_instruction": _style_fidelity_review_instruction(), + "style_validation_review": True, + "style_consensus_id": consensus.consensus_id, + "style_validation_case_id": case.case_id, + "image_manifest": image_manifest, + }, + ) + try: + recognition = provider.recognize_material(request) + except VisionProviderError as exc: + return {"status": "review_failed", "error": _vision_provider_error(exc)}, None + payload = recognition.structured_data if isinstance(recognition.structured_data, dict) else {} + dimension_scores = _normalize_style_dimension_scores(payload.get("dimension_scores")) + provider_score = _score(payload.get("fidelity_score"), recognition.confidence) + score, score_meta = _weighted_style_fidelity_score(case.case_key, dimension_scores, provider_score) + prompt_patch = _normalize_style_prompt_patch( + payload.get("prompt_patch"), + correction_prompt=_optional_text(payload.get("correction_prompt")) or recognition.prompt, + negative_correction_prompt=_optional_text(payload.get("negative_correction_prompt")) or recognition.negative_prompt, + ) + review = { + "status": "succeeded", + "schema_version": STYLE_REVIEW_SCHEMA_VERSION, + "provider_id": recognition.provider_id, + "provider_model": recognition.model, + "fidelity_score": score, + "provider_fidelity_score": provider_score, + "score_calibration": score_meta, + "dimension_scores": dimension_scores, + "matches": _string_list(payload.get("matches")), + "mismatches": _string_list(payload.get("mismatches")), + "style_deltas": _normalize_style_deltas(payload.get("style_deltas"), case_key=case.case_key), + "prompt_patch": prompt_patch, + "semantic_risks": _normalize_semantic_risks(payload.get("semantic_risks")), + "content_leakage": _string_list(payload.get("content_leakage")), + "correction_prompt": _optional_text(payload.get("correction_prompt")) or recognition.prompt, + "negative_correction_prompt": _optional_text(payload.get("negative_correction_prompt")) or recognition.negative_prompt, + "description": recognition.description, + "image_manifest": image_manifest, + } + return review, score + + def _require_style_set(self, record: Any) -> None: + if not self.is_style_set(record): + raise ApiError(ErrorCode.VALIDATION_FAILED, "advanced material import is not a multi-image style set", {"import_id": record.import_id}) + + def _require_sources_editable(self, record: Any) -> None: + if record.status in {"accepted", "archived", "cancelled"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "advanced style source set is no longer editable", + {"import_id": record.import_id, "status": record.status}, + ) + latest = self.repository.get_latest_style_consensus_run(record.import_id) + if latest is not None and latest.status not in {"failed", "cancelled"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "style sources cannot change after a consensus has started", + { + "import_id": record.import_id, + "consensus_id": latest.consensus_id, + "consensus_status": latest.status, + }, + ) + + def _require_source(self, import_id: str, source_id: str): + source = self.repository.get_style_source(source_id) + if source is None or source.import_id != import_id: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced style source not found", {"source_id": source_id}) + return source + + def _require_case(self, import_id: str, case_id: str): + case = self.repository.get_style_validation_case(case_id) + if case is None or case.import_id != import_id: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced style validation case not found", {"case_id": case_id}) + return case + + +def _is_style_category(category: Any) -> bool: + name = str(getattr(category, "name", "") or "").strip().casefold() + metadata = getattr(category, "metadata", None) + group = str(metadata.get("frontend_group") or "").strip().casefold() if isinstance(metadata, dict) else "" + category_id = str(getattr(category, "category_id", "") or "").strip().casefold() + return name in {"风格", "画风", "style"} or group in {"风格", "画风", "style"} or category_id == "cat_imagestudio_风格".casefold() + + +def _single_style_instruction() -> str: + return ( + "Analyze only observable visual style and separate it from exact subject identity, costume, pose, props, text, " + "scene and composition. Extract both surface rendering and structural style grammar. Required structural dimensions " + "include face width/length and chin shape, eye-to-face ratio, eye contour and iris layers, eyelid/lash design, " + "nose and mouth simplification, apparent-age stylization, head-to-body ratio, hand/anatomy simplification, hair mass " + "and strand grouping, line topology/closure/taper/local color, shadow hue/band count/edge softness, skin blush and " + "subsurface tones, highlight shape and placement, palette contrast/saturation/value range, texture, background detail " + "rhythm and optical effects. Do not replace these observations with generic labels such as anime style, beautiful, " + "high quality or vibrant. Return JSON with prompt, negative_prompt, tags, confidence, description, raw_analysis.attributes, " + "normalized_asset_profile(category=style, role=style, body_slots=[global_style], attributes, must_preserve and " + "forbidden_changes), generation_capsules compact/standard/detailed, and source_content_features. Detailed capsule " + "parts must remain complete semantic phrases, not comma fragments. Never name an artist when traits can be described." + ) + + +def _consensus_instruction( + *, + source_ids: list[str], + style_adjustment: str | None, + style_adjustment_plan: dict[str, Any], + validation_instruction: str | None, + has_previous_validation: bool, +) -> str: + style_clause = ( + "Human style correction. Apply this only to transferable style fields, prompts and generation capsules: " + f"{style_adjustment}" + if style_adjustment + else "" + ) + validation_clause = ( + "Human validation-content request. Apply this to every validation_cases.content_prompt while adapting framing " + f"for portrait, fullbody and novel_scene. Do not absorb it into the transferable style prompt: {validation_instruction}" + if validation_instruction + else "" + ) + comparison_clause = ( + "The image_manifest labels source_reference images and previous_validation images. Compare the failed validation " + "images directly against the source references, diagnose which transferable traits moved in the wrong direction, " + "and revise the prompt rather than merely repeating the previous wording. Use automatic_review_feedback to distinguish " + "cross-scenario failures from portrait/fullbody/novel_scene scale-specific failures. A problem repeated in two or more " + "scenarios is a common-style correction; a problem isolated to one scenario belongs in that scenario's scale capsule. " + if has_previous_validation + else "" + ) + adjustment_plan_clause = ( + "Treat this structured adjustment plan as a hard directional constraint. Never invert decrease, increase, remove " + f"or preserve instructions: {json.dumps(style_adjustment_plan, ensure_ascii=False)}. " + if style_adjustment + else "" + ) + return ( + "Read every supplied style sample and its report. Cross-compare them instead of averaging blindly. Identify " + "features shared by at least 60% of samples as core style, 40-60% as variable, and lower support as content or " + "an outlier. Separate character identity, age, gender/species, hair, clothing, pose, props, text, setting and " + "composition from transferable style, while preserving domain-coupled structural stylization such as face proportions, " + "eye geometry, nose/mouth simplification, head-to-body ratio and anatomy abstraction. Do not classify a whole subject " + "class such as young characters, animal-eared characters or dresses as a negative constraint; exclude only exact source " + "identity and exact designs. Return one JSON object with compatibility keys prompt, negative_prompt, " + "tags, confidence and description; raw_analysis; normalized_asset_profile(category=style, role=style, " + "body_slots=[global_style], attributes containing structural and rendering dimensions, and 8-16 concrete must_preserve " + "phrases); generation_capsules compact/standard/detailed with intact semantic phrases; prompt_priority_groups with " + "core, structural and rendering arrays totaling no more than 14 non-redundant phrases; scale_capsules keyed by portrait, " + "fullbody and novel_scene; semantic_risk_audit for wording that could be literalized as an object, effect or composition; " + "each semantic risk item must include original_phrase, risk, safe_rewrite and negative_guard. Prefer physically grounded " + "surface/shape/placement descriptions over metaphors or object-like shorthand. consensus_style; " + "variable_style_features; source_content_features; content_leakage_exclusions; outlier_source_ids; " + "representative_source_ids (1-3); consensus_confidence; feature_evidence where each item has trait, " + "supporting_source_ids, support_ratio and confidence; and validation_cases with exactly portrait, fullbody and " + "novel_scene. Every validation content_prompt must describe a character, clothing, pose, camera and scene " + "semantically different from all source samples but remain in a comparable illustration domain and apparent-age range, " + "and must not contain style wording. Negative prompts must prevent semi-realistic or generic reinterpretation only when " + "the source evidence supports stylized anatomy. Valid source IDs are: " + f"{', '.join(source_ids)}. {comparison_clause}{adjustment_plan_clause}{style_clause} {validation_clause}" + ).strip() + + +def _force_style_structures(value: dict[str, Any]) -> dict[str, Any]: + result = dict(value) + profile = dict(result.get("normalized_asset_profile") or {}) + profile.update({"category": "style", "role": "style", "body_slots": ["global_style"], "wear_layer": None, "stackable": False}) + result["normalized_asset_profile"] = profile + return result + + +def _style_fidelity_review_instruction() -> str: + return ( + "The image_manifest identifies 1-3 source_reference images followed by one generated_validation image. Compare only " + "transferable visual style, never subject identity or exact clothing. Score the generated image against the shared source " + "style on face proportions, eye geometry and iris construction, nose/mouth simplification, apparent-age stylization, " + "head-to-body ratio, hair mass and strand grouping, line topology/taper/local color, skin and blush rendering, shadow hue " + "and edge softness, highlight shape, palette contrast/saturation/value range, texture/detail rhythm and optical effects. " + "Separate global palette/value range from local edge, eye, hair and clothing color separation. Do not translate a local " + "contrast failure into a request for globally stronger saturation. Detect phrases in the actual generation prompt that may " + "have been literalized as an object, lighting effect or composition instead of a surface-bound style property. Return one " + "strict JSON object with prompt, negative_prompt, confidence, description and fidelity_score; dimension_scores must use the " + "fixed keys face_structure, eye_design, hair_rendering, linework, palette_global, palette_local, shading, highlights, " + "anatomy_scale, texture_detail and background_rendering. Also return matches, mismatches; style_deltas as objects with " + "dimension, scope(global/local/scale_specific), direction, severity, source_target, observed, evidence and scenario; " + "prompt_patch with positive_additions, negative_additions, replacements, preserve and scale_overrides; semantic_risks with " + "original_phrase, risk, safe_rewrite and negative_guard; content_leakage; correction_prompt and negative_correction_prompt. " + "Do not reward generic prettiness, resolution, subject similarity or cinematic detail." + ) + + +def _validation_cases( + provider_value: Any, + reuse_value: Any, + *, + validation_instruction: str | None = None, +) -> list[dict[str, Any]]: + candidates = ( + reuse_value + if not validation_instruction and isinstance(reuse_value, list) and len(reuse_value) == 3 + else provider_value + ) + mapped: dict[str, dict[str, Any]] = {} + if isinstance(candidates, list): + for item in candidates: + if not isinstance(item, dict): + continue + key = str(item.get("case_key") or item.get("type") or item.get("scenario") or "").strip() + prompt = str(item.get("content_prompt") or "").strip() + if key in {"portrait", "fullbody", "novel_scene"} and prompt: + mapped[key] = {"case_key": key, "content_prompt": prompt, "aspect_ratio": item.get("aspect_ratio") or (item.get("metadata") or {}).get("aspect_ratio")} + result: list[dict[str, Any]] = [] + for default in DEFAULT_VALIDATION_CASES: + selected = mapped.get(str(default["case_key"]), {}) + case_key = str(default["case_key"]) + content_prompt = str(selected.get("content_prompt") or default["content_prompt"]).strip() + if validation_instruction: + content_prompt = _validation_instruction_prompt(case_key, validation_instruction) + result.append( + { + **default, + **selected, + "content_prompt": content_prompt, + "aspect_ratio": selected.get("aspect_ratio") or default["aspect_ratio"], + } + ) + return result + + +def _validation_instruction_prompt(case_key: str, instruction: str) -> str: + framing = { + "portrait": ( + "For this controlled portrait comparison, preserve every requested identity, hairstyle, color and wardrobe " + "detail, adapting only the camera to a head-and-shoulders composition with a simple neutral background" + ), + "fullbody": ( + "For this controlled full-body comparison, preserve every requested identity, hairstyle, color and wardrobe " + "detail and show the complete character from head to toe in a simple readable environment" + ), + "novel_scene": ( + "For this cross-scene comparison, preserve every requested identity, hairstyle, color and wardrobe detail, " + "then place the same character in a clearly different wide environmental scene" + ), + }.get(case_key, "Preserve every requested subject and wardrobe detail in a controlled comparison composition") + return _join_prompt(f"Mandatory human validation request: {instruction}", framing) + + +def _style_validation_seed(index: int, revision: int, *, refresh_content: bool) -> int: + base = STYLE_VALIDATION_SEEDS[index] + return base + max(1, int(revision)) * 1000 if refresh_content else base + + +def _review_adjustment_summary(style_adjustment: str | None, validation_instruction: str | None) -> str | None: + parts = [] + if style_adjustment: + parts.append(f"画风修正:{style_adjustment}") + if validation_instruction: + parts.append(f"验证内容:{validation_instruction}") + return "\n".join(parts) or None + + +_STYLE_TRAIT_ALIASES: dict[str, tuple[str, ...]] = { + "color contrast": ("颜色对比", "色彩对比", "明暗对比", "color contrast", "colour contrast", "contrast"), + "color saturation": ("颜色饱和", "色彩饱和", "饱和度", "鲜艳度", "color saturation", "colour saturation", "saturation"), + "brightness": ("亮度", "明度", "brightness", "luminance"), + "shadow intensity": ("阴影强度", "阴影浓度", "阴影", "shadow intensity", "shadow strength", "shadows"), + "highlight intensity": ("高光强度", "高光", "highlight intensity", "highlight strength", "highlights"), + "line weight": ("线条粗细", "线宽", "线条", "line weight", "line thickness"), + "detail density": ("细节密度", "细节", "detail density", "level of detail"), + "texture intensity": ("纹理强度", "纹理", "texture intensity", "texture"), +} + +_STYLE_DECREASE_MARKERS = ( + "太强", "太重", "太浓", "太高", "太过", "过于", "过度", "降低", "减弱", "减少", "收敛", + "too strong", "too intense", "too high", "overly", "excessive", "reduce", "decrease", "less", +) +_STYLE_INCREASE_MARKERS = ( + "太弱", "太淡", "太低", "不足", "加强", "增强", "增加", "提高", + "too weak", "too low", "insufficient", "increase", "strengthen", "more", +) +_STYLE_REMOVE_MARKERS = ("不要", "去掉", "移除", "删除", "取消", "remove", "eliminate", "without") +_STYLE_PRESERVE_MARKERS = ("保持", "保留", "不要改变", "维持", "preserve", "retain", "keep") + +_STYLE_DECREASE_GUARDS: dict[str, dict[str, list[str]]] = { + "color contrast": { + "positive_forbidden": [ + "intense color contrast", "extreme color contrast", "high color contrast", "high contrast", + "strong contrast", "dramatic contrast", "extreme color dynamics", + ], + "negative_forbidden": ["low contrast", "washed out", "flat contrast", "muted contrast"], + "positive_add": ["balanced moderate color contrast", "restrained color separation"], + "negative_add": ["excessive color contrast", "extreme color dynamics", "oversaturated color separation"], + }, + "color saturation": { + "positive_forbidden": ["high saturation", "highly saturated", "extreme saturation", "oversaturated", "vivid saturated"], + "negative_forbidden": ["low saturation", "desaturated", "muted colors", "washed out"], + "positive_add": ["controlled moderate color saturation", "restrained chroma"], + "negative_add": ["oversaturated colors", "extreme chroma", "neon color overload"], + }, + "brightness": { + "positive_forbidden": ["extreme brightness", "very bright", "blown-out highlights"], + "negative_forbidden": ["dim", "dark exposure", "underexposed"], + "positive_add": ["balanced moderate brightness"], + "negative_add": ["excessive brightness", "overexposure"], + }, + "shadow intensity": { + "positive_forbidden": ["heavy shadows", "deep harsh shadows", "intense shadows", "strong shadows"], + "negative_forbidden": ["weak shadows", "shadowless", "flat lighting"], + "positive_add": ["controlled moderate shadow intensity"], + "negative_add": ["excessively heavy shadows", "crushed shadow detail"], + }, + "highlight intensity": { + "positive_forbidden": ["intense highlights", "extreme highlights", "strong glossy highlights"], + "negative_forbidden": ["no highlights", "dull highlights"], + "positive_add": ["controlled restrained highlights"], + "negative_add": ["blown-out highlights", "excessive glossy glare"], + }, +} + + +def _parse_style_adjustment(value: str | None) -> dict[str, Any]: + text = _optional_text(value) + plan: dict[str, Any] = { + "increase": [], + "decrease": [], + "remove": [], + "preserve": [], + "unparsed_feedback": [], + "raw_text": text, + "parser_version": 1, + } + if not text: + return plan + matched = False + clauses = [item.strip() for item in re.split(r"[,,。;;\n]+", text.casefold()) if item.strip()] + for clause in clauses: + traits = [ + trait + for trait, aliases in _STYLE_TRAIT_ALIASES.items() + if any(alias.casefold() in clause for alias in aliases) + ] + if not traits: + continue + matched = True + decrease_not_remove = any(marker in clause for marker in ("不要太", "不要过", "not too")) + if any(marker in clause for marker in _STYLE_PRESERVE_MARKERS): + direction = "preserve" + elif any(marker in clause for marker in _STYLE_REMOVE_MARKERS) and not decrease_not_remove: + direction = "remove" + elif decrease_not_remove or any(marker in clause for marker in _STYLE_DECREASE_MARKERS): + direction = "decrease" + elif any(marker in clause for marker in _STYLE_INCREASE_MARKERS): + direction = "increase" + else: + plan["unparsed_feedback"].append(clause) + continue + for trait in traits: + if trait not in plan[direction]: + plan[direction].append(trait) + if not matched: + plan["unparsed_feedback"].append(text) + return plan + + +def _style_adjustment_plan(value: Any, fallback_text: str | None) -> dict[str, Any]: + if not isinstance(value, dict): + return _parse_style_adjustment(fallback_text) + result = { + "increase": _string_list(value.get("increase")), + "decrease": _string_list(value.get("decrease")), + "remove": _string_list(value.get("remove")), + "preserve": _string_list(value.get("preserve")), + "unparsed_feedback": _string_list(value.get("unparsed_feedback")), + "raw_text": _optional_text(value.get("raw_text")) or _optional_text(fallback_text), + "parser_version": int(value.get("parser_version") or 1), + } + if not any(result[key] for key in ("increase", "decrease", "remove", "preserve", "unparsed_feedback")): + return _parse_style_adjustment(fallback_text) + return result + + +def _apply_style_adjustment_guard( + prompt: str | None, + negative_prompt: str | None, + structures: dict[str, Any], + plan: dict[str, Any], +) -> tuple[str, str | None, dict[str, Any], dict[str, Any]]: + positive = str(prompt or "").strip() + negative = _optional_text(negative_prompt) + guarded = deepcopy(structures) + removed_positive: list[str] = [] + removed_negative: list[str] = [] + positive_additions: list[str] = [] + negative_additions: list[str] = [] + for trait in _string_list(plan.get("decrease")): + rules = _STYLE_DECREASE_GUARDS.get( + trait, + { + "positive_forbidden": [f"extreme {trait}", f"intense {trait}", f"high {trait}", f"strong {trait}"], + "negative_forbidden": [f"low {trait}", f"weak {trait}"], + "positive_add": [f"balanced moderate {trait}", f"restrained {trait}"], + "negative_add": [f"excessive {trait}", f"extreme {trait}"], + }, + ) + positive, removed = _remove_prompt_phrases(positive, rules["positive_forbidden"]) + removed_positive.extend(removed) + negative, removed = _remove_prompt_phrases(negative, rules["negative_forbidden"]) + removed_negative.extend(removed) + positive_additions.extend(rules["positive_add"]) + negative_additions.extend(rules["negative_add"]) + for trait in _string_list(plan.get("increase")): + positive_additions.append(f"clearly pronounced {trait}") + negative, removed = _remove_prompt_phrases(negative, [f"high {trait}", f"strong {trait}", f"pronounced {trait}"]) + removed_negative.extend(removed) + for trait in _string_list(plan.get("remove")): + positive, removed = _remove_prompt_phrases(positive, [trait]) + removed_positive.extend(removed) + negative_additions.append(trait) + for trait in _string_list(plan.get("preserve")): + positive_additions.append(f"preserve source-reference {trait}") + positive = _join_prompt(positive, *positive_additions) + negative = _join_prompt(negative, *negative_additions) or None + + capsules = guarded.get("generation_capsules") + if isinstance(capsules, dict): + for tier, raw_capsule in list(capsules.items()): + if not isinstance(raw_capsule, dict): + continue + capsule = dict(raw_capsule) + capsule_positive_parts = _prompt_parts(capsule.get("prompt_parts")) + capsule_negative_parts = _prompt_parts(capsule.get("negative_parts")) + for trait in _string_list(plan.get("decrease")): + rules = _STYLE_DECREASE_GUARDS.get( + trait, + { + "positive_forbidden": [f"extreme {trait}", f"intense {trait}", f"high {trait}", f"strong {trait}"], + "negative_forbidden": [f"low {trait}", f"weak {trait}"], + "positive_add": [f"balanced moderate {trait}", f"restrained {trait}"], + "negative_add": [f"excessive {trait}", f"extreme {trait}"], + }, + ) + capsule_positive_parts, _ = _remove_forbidden_from_parts( + capsule_positive_parts, + rules["positive_forbidden"], + ) + capsule_negative_parts, _ = _remove_forbidden_from_parts( + capsule_negative_parts, + rules["negative_forbidden"], + ) + capsule["prompt_parts"] = _unique_prompt_parts([*capsule_positive_parts, *positive_additions]) + capsule["negative_parts"] = _unique_prompt_parts([*capsule_negative_parts, *negative_additions]) + capsule["style_adjustment_guarded"] = True + capsules[tier] = capsule + return ( + positive, + negative, + guarded, + { + "applied": bool(positive_additions or negative_additions or removed_positive or removed_negative), + "removed_positive_parts": list(dict.fromkeys(removed_positive)), + "removed_negative_parts": list(dict.fromkeys(removed_negative)), + "positive_additions": list(dict.fromkeys(positive_additions)), + "negative_additions": list(dict.fromkeys(negative_additions)), + }, + ) + + +def _remove_prompt_phrases(value: str | None, forbidden: list[str]) -> tuple[str, list[str]]: + parts = [item.strip() for item in re.split(r"[,;\n]+", str(value or "")) if item.strip()] + removed = [item for item in parts if any(token.casefold() in item.casefold() for token in forbidden)] + kept = [item for item in parts if item not in removed] + return ", ".join(kept), removed + + +def _prompt_parts(value: Any) -> list[str]: + if isinstance(value, str): + text = value.strip() + return [text] if text else [] + if not isinstance(value, (list, tuple, set)): + return [] + return _unique_prompt_parts([str(item).strip() for item in value if str(item).strip()]) + + +def _unique_prompt_parts(values: list[str]) -> list[str]: + result: list[str] = [] + seen: set[str] = set() + for value in values: + text = str(value or "").strip(" ,;") + key = text.casefold() + if text and key not in seen: + seen.add(key) + result.append(text) + return result + + +def _remove_forbidden_from_parts(parts: list[str], forbidden: list[str]) -> tuple[list[str], list[str]]: + kept: list[str] = [] + removed: list[str] = [] + for part in parts: + rewritten = part + for phrase in forbidden: + pattern = re.compile(re.escape(phrase), re.IGNORECASE) + if pattern.search(rewritten): + removed.append(phrase) + rewritten = pattern.sub("", rewritten) + rewritten = re.sub(r"\s*,\s*,+", ", ", rewritten).strip(" ,;") + if rewritten: + kept.append(rewritten) + return _unique_prompt_parts(kept), list(dict.fromkeys(removed)) + + +def _normalize_style_dimension_scores(value: Any) -> dict[str, float]: + if not isinstance(value, dict): + return {} + collected: dict[str, list[float]] = {} + for raw_key, raw_value in value.items(): + key = _canonical_style_dimension(raw_key) + if key is None: + continue + candidate = raw_value.get("score") if isinstance(raw_value, dict) else raw_value + score = _score(candidate) + if score is not None: + collected.setdefault(key, []).append(score) + return {key: sum(scores) / len(scores) for key, scores in collected.items() if scores} + + +def _canonical_style_dimension(value: Any) -> str | None: + normalized = re.sub(r"[^a-z0-9]+", "_", str(value or "").strip().casefold()).strip("_") + if not normalized: + return None + for canonical in STYLE_REVIEW_DIMENSIONS: + aliases = (canonical, *STYLE_REVIEW_DIMENSION_ALIASES.get(canonical, ())) + if normalized in {re.sub(r"[^a-z0-9]+", "_", alias.casefold()).strip("_") for alias in aliases}: + return canonical + return None + + +def _weighted_style_fidelity_score( + case_key: Any, + scores: dict[str, float], + provider_score: float | None, +) -> tuple[float | None, dict[str, Any]]: + weights = STYLE_REVIEW_WEIGHTS.get(str(case_key), STYLE_REVIEW_WEIGHTS["novel_scene"]) + available_weight = sum(weights.get(key, 0.0) for key in scores) + if available_weight > 0: + computed = sum(scores[key] * weights.get(key, 0.0) for key in scores) / available_weight + if provider_score is not None and available_weight < 0.75: + score = computed * available_weight + provider_score * (1.0 - available_weight) + else: + score = computed + if available_weight < 0.5: + score = min(score, 0.65 + 0.35 * available_weight) + source = "server_weighted_dimensions" + else: + score = provider_score + computed = None + source = "provider_fallback" + return ( + _score(score), + { + "schema_version": STYLE_REVIEW_SCHEMA_VERSION, + "source": source, + "scenario": str(case_key), + "dimension_coverage": round(available_weight, 4), + "computed_dimension_score": _score(computed), + "provider_score": provider_score, + "missing_dimensions": [key for key in STYLE_REVIEW_DIMENSIONS if key not in scores and weights.get(key, 0.0) > 0], + }, + ) + + +def _normalize_style_deltas(value: Any, *, case_key: Any) -> list[dict[str, Any]]: + if not isinstance(value, list): + return [] + result: list[dict[str, Any]] = [] + for item in value: + if not isinstance(item, dict): + continue + dimension = _canonical_style_dimension(item.get("dimension")) + if dimension is None: + continue + scope = str(item.get("scope") or "scale_specific").strip().casefold() + if scope not in {"global", "local", "scale_specific"}: + scope = "scale_specific" + severity = _score(item.get("severity"), 0.5) + result.append( + { + "dimension": dimension, + "scope": scope, + "direction": _optional_text(item.get("direction")), + "severity": severity, + "source_target": _optional_text(item.get("source_target")), + "observed": _optional_text(item.get("observed")), + "evidence": _optional_text(item.get("evidence")), + "scenario": _optional_text(item.get("scenario")) or str(case_key), + } + ) + return result + + +def _normalize_style_prompt_patch( + value: Any, + *, + correction_prompt: str | None, + negative_correction_prompt: str | None, +) -> dict[str, Any]: + payload = value if isinstance(value, dict) else {} + replacements = [] + for item in _list(payload.get("replacements")): + if not isinstance(item, dict): + continue + original = _optional_text(item.get("from") or item.get("original_phrase")) + rewrite = _optional_text(item.get("to") or item.get("safe_rewrite")) + if original and rewrite and original.casefold() != rewrite.casefold(): + replacements.append({"from": original, "to": rewrite, "reason": _optional_text(item.get("reason"))}) + positive = _prompt_parts(payload.get("positive_additions")) + negative = _prompt_parts(payload.get("negative_additions")) + if not positive and correction_prompt: + positive = [correction_prompt] + if not negative and negative_correction_prompt: + negative = [negative_correction_prompt] + scale_overrides: dict[str, Any] = {} + raw_scales = payload.get("scale_overrides") + if isinstance(raw_scales, dict): + for case_key in ("portrait", "fullbody", "novel_scene"): + raw = raw_scales.get(case_key) + if isinstance(raw, dict): + scale_overrides[case_key] = { + "positive_additions": _prompt_parts(raw.get("positive_additions") or raw.get("prompt_parts")), + "negative_additions": _prompt_parts(raw.get("negative_additions") or raw.get("negative_parts")), + } + elif raw: + scale_overrides[case_key] = {"positive_additions": _prompt_parts(raw), "negative_additions": []} + return { + "positive_additions": _unique_prompt_parts(positive), + "negative_additions": _unique_prompt_parts(negative), + "replacements": replacements, + "preserve": _prompt_parts(payload.get("preserve")), + "scale_overrides": scale_overrides, + } + + +def _normalize_semantic_risks(value: Any) -> list[dict[str, Any]]: + if not isinstance(value, list): + return [] + result = [] + for item in value: + if not isinstance(item, dict): + continue + original = _optional_text(item.get("original_phrase")) + rewrite = _optional_text(item.get("safe_rewrite")) + if original or rewrite: + result.append( + { + "original_phrase": original, + "risk": _optional_text(item.get("risk")), + "safe_rewrite": rewrite, + "negative_guard": _optional_text(item.get("negative_guard")), + } + ) + return result + + +def _aggregate_style_review_feedback(cases: list[Any]) -> dict[str, Any]: + reviewed = [] + dimension_values: dict[str, list[float]] = {} + weak_scenarios: dict[str, list[str]] = {} + deltas: list[dict[str, Any]] = [] + prompt_patches: list[dict[str, Any]] = [] + semantic_risks: list[dict[str, Any]] = [] + scenario_scores: dict[str, float] = {} + for case in cases: + review = case.style_review if isinstance(getattr(case, "style_review", None), dict) else {} + if review.get("status") != "succeeded": + continue + scenario = str(case.case_key) + reviewed.append(str(case.case_id)) + score = _score(review.get("fidelity_score"), getattr(case, "fidelity_score", None)) + if score is not None: + scenario_scores[scenario] = score + scores = _normalize_style_dimension_scores(review.get("dimension_scores")) + for dimension, dimension_score in scores.items(): + dimension_values.setdefault(dimension, []).append(dimension_score) + if dimension_score < 0.72: + weak_scenarios.setdefault(dimension, []).append(scenario) + deltas.extend(_normalize_style_deltas(review.get("style_deltas"), case_key=scenario)) + patch = review.get("prompt_patch") + if isinstance(patch, dict): + prompt_patches.append({"scenario": scenario, **patch}) + semantic_risks.extend(_normalize_semantic_risks(review.get("semantic_risks"))) + recurrent = sorted(dimension for dimension, scenarios in weak_scenarios.items() if len(set(scenarios)) >= 2) + scale_specific = { + scenario: sorted(dimension for dimension, scenarios in weak_scenarios.items() if scenario in scenarios and dimension not in recurrent) + for scenario in ("portrait", "fullbody", "novel_scene") + } + return { + "schema_version": STYLE_REVIEW_SCHEMA_VERSION, + "reviewed_case_ids": reviewed, + "scenario_scores": scenario_scores, + "dimension_averages": { + key: sum(values) / len(values) for key, values in dimension_values.items() if values + }, + "recurrent_weak_dimensions": recurrent, + "scale_specific_weak_dimensions": scale_specific, + "style_deltas": deltas, + "prompt_patches": prompt_patches, + "semantic_risks": semantic_risks, + "correction_policy": { + "common_style": "apply only findings repeated across at least two scenarios or explicitly marked global", + "scale_specific": "keep isolated findings inside the matching portrait/fullbody/novel_scene capsule", + "color": "separate global palette/value range from local color separation and edge contrast", + "semantic_safety": "replace object-like metaphors with surface, geometry and placement language", + }, + } + + +def _style_attempt_comparison( + *, + current_attempt: Any, + current_cases: list[Any], + previous_attempt: Any | None, + previous_cases: list[Any], +) -> dict[str, Any]: + current_score = _score(getattr(current_attempt, "fidelity_score", None)) + previous_score = _score(getattr(previous_attempt, "fidelity_score", None)) if previous_attempt is not None else None + delta = current_score - previous_score if current_score is not None and previous_score is not None else None + if delta is None: + recommendation = "baseline" + elif delta >= 0.02: + recommendation = "adopt_candidate" + elif delta <= -0.02: + recommendation = "keep_previous_candidate" + else: + recommendation = "equivalent_requires_human_review" + current_by_key = {str(item.case_key): _score(item.fidelity_score) for item in current_cases} + previous_by_key = {str(item.case_key): _score(item.fidelity_score) for item in previous_cases} + scenario_deltas = { + key: current_by_key[key] - previous_by_key[key] + for key in current_by_key.keys() & previous_by_key.keys() + if current_by_key[key] is not None and previous_by_key[key] is not None + } + return { + "schema_version": 1, + "current_attempt_id": str(current_attempt.attempt_id), + "previous_attempt_id": str(previous_attempt.attempt_id) if previous_attempt is not None else None, + "current_score": current_score, + "previous_score": previous_score, + "score_delta": delta, + "scenario_deltas": scenario_deltas, + "recommendation": recommendation, + "regression_threshold": 0.02, + } + + +def _detailed_style_prompt(result: Any, fallback: Any) -> str: + payload = result if isinstance(result, dict) else {} + capsules = payload.get("generation_capsules") if isinstance(payload.get("generation_capsules"), dict) else {} + detailed = capsules.get("detailed") if isinstance(capsules.get("detailed"), dict) else {} + must_preserve = _prompt_parts(detailed.get("must_preserve")) + profile = payload.get("normalized_asset_profile") if isinstance(payload.get("normalized_asset_profile"), dict) else {} + must_preserve = _unique_prompt_parts([*must_preserve, *_prompt_parts(profile.get("must_preserve"))]) + priorities = payload.get("prompt_priority_groups") if isinstance(payload.get("prompt_priority_groups"), dict) else {} + priority_parts = [ + *_prompt_parts(priorities.get("core")), + *_prompt_parts(priorities.get("structural")), + *_prompt_parts(priorities.get("rendering")), + ] + parts = [*must_preserve, *priority_parts, *_prompt_parts(detailed.get("prompt_parts"))] + risks = _normalize_semantic_risks(payload.get("semantic_risk_audit")) + compiled = _compact_style_prompt_parts([_apply_semantic_risk_rewrites(item, risks) for item in parts], limit=14) + return _join_prompt(*compiled) if compiled else str(fallback or "").strip() + + +def _detailed_style_negative_prompt(result: Any, fallback: Any) -> str: + payload = result if isinstance(result, dict) else {} + capsules = payload.get("generation_capsules") if isinstance(payload.get("generation_capsules"), dict) else {} + detailed = capsules.get("detailed") if isinstance(capsules.get("detailed"), dict) else {} + parts = _prompt_parts(detailed.get("negative_parts")) + parts.extend( + item["negative_guard"] + for item in _normalize_semantic_risks(payload.get("semantic_risk_audit")) + if item.get("negative_guard") + ) + return _join_prompt(*parts) if parts else str(fallback or "").strip() + + +def _scale_specific_style_prompt(result: Any, case_key: str) -> str: + payload = result if isinstance(result, dict) else {} + scales = payload.get("scale_capsules") if isinstance(payload.get("scale_capsules"), dict) else {} + raw = scales.get(case_key) + if isinstance(raw, dict): + parts = _prompt_parts(raw.get("prompt_parts") or raw.get("positive_additions")) + else: + parts = _prompt_parts(raw) + return _join_prompt(*_compact_style_prompt_parts(parts, limit=5)) + + +def _scale_specific_style_negative_prompt(result: Any, case_key: str) -> str: + payload = result if isinstance(result, dict) else {} + scales = payload.get("scale_capsules") if isinstance(payload.get("scale_capsules"), dict) else {} + raw = scales.get(case_key) + return _join_prompt(*_prompt_parts(raw.get("negative_parts") or raw.get("negative_additions"))) if isinstance(raw, dict) else "" + + +def _scale_transfer_instruction(case_key: str) -> str: + return { + "portrait": ( + "at portrait scale preserve the source style's face contour, eye-to-face ratio, iris layer hierarchy, lash design, " + "nose and mouth abstraction, hair strand grouping and surface-bound highlight placement" + ), + "fullbody": ( + "at full-body scale preserve silhouette language, head-to-body ratio, anatomy abstraction, colored line hierarchy, " + "clothing-fold shading bands and readable but non-exaggerated facial features" + ), + "novel_scene": ( + "in a wide scene keep the character linework, local palette relationships and shading grammar distinct from the " + "background while matching the source style's environment detail rhythm instead of becoming photorealistic" + ), + }.get(case_key, "preserve the transferable style grammar at the requested camera scale") + + +def _apply_semantic_risk_rewrites(value: str, risks: list[dict[str, Any]]) -> str: + result = str(value or "").strip() + for item in risks: + original = _optional_text(item.get("original_phrase")) + rewrite = _optional_text(item.get("safe_rewrite")) + if original and rewrite: + result = re.sub(re.escape(original), rewrite, result, flags=re.IGNORECASE) + return result + + +def _compact_style_prompt_parts(values: list[str], *, limit: int) -> list[str]: + compacted: list[str] = [] + signatures: list[set[str]] = [] + for value in _unique_prompt_parts(values): + words = { + item + for item in re.findall(r"[a-z0-9]+", value.casefold()) + if len(item) > 2 and item not in {"with", "from", "into", "style", "visual", "preserve"} + } + duplicate_index = None + for index, existing in enumerate(signatures): + if not words or not existing: + continue + overlap = len(words & existing) / max(1, min(len(words), len(existing))) + if overlap >= 0.82: + duplicate_index = index + break + if duplicate_index is None: + compacted.append(value) + signatures.append(words) + elif len(value) > len(compacted[duplicate_index]): + compacted[duplicate_index] = value + signatures[duplicate_index] = words + if len(compacted) >= limit: + break + return compacted + + +def _required_task_value(task: Any, key: str) -> str: + value = str(task.metadata.get(key) or "").strip() + if not value: + raise RuntimeError(f"advanced style task is missing {key}") + return value + + +def _join_prompt(*values: Any) -> str: + return ", ".join(dict.fromkeys(str(value).strip() for value in values if str(value or "").strip())) + + +def _optional_text(value: Any) -> str | None: + text = str(value or "").strip() + return text or None + + +def _string_list(value: Any) -> list[str]: + if isinstance(value, str): + values = value.split(",") + elif isinstance(value, (list, tuple, set)): + values = value + else: + values = [] + return list(dict.fromkeys(str(item).strip() for item in values if str(item).strip())) + + +def _list(value: Any) -> list[Any]: + return list(value) if isinstance(value, list) else [] + + +def _object(value: Any) -> dict[str, Any]: + return dict(value) if isinstance(value, dict) else {} + + +def _score(value: Any, fallback: Any = None) -> float | None: + try: + number = float(value if value is not None else fallback) + except (TypeError, ValueError): + return None + return min(max(number, 0.0), 1.0) + + +def _calibrated_style_confidence( + provider_result: dict[str, Any], + fallback: Any, + structures: dict[str, Any], +) -> float | None: + base = _score(provider_result.get("consensus_confidence"), fallback) + if base is None: + return None + evidence_scores: list[float] = [] + for item in _list(provider_result.get("feature_evidence")): + if not isinstance(item, dict): + continue + confidence = _score(item.get("confidence")) + support = _score(item.get("support_ratio")) + if confidence is not None and support is not None: + evidence_scores.append(confidence * support) + if evidence_scores: + base = min(base, sum(evidence_scores) / len(evidence_scores) + 0.1) + profile = structures.get("normalized_asset_profile") if isinstance(structures.get("normalized_asset_profile"), dict) else {} + attributes = profile.get("attributes") if isinstance(profile.get("attributes"), dict) else {} + structural_groups = ( + ("face", "facial", "chin"), + ("eye", "iris", "lash", "eyelid"), + ("nose", "mouth", "lip"), + ("hair", "strand"), + ("anatomy", "body_ratio", "head_to_body", "hand"), + ("line", "outline", "linework"), + ("shadow", "shading"), + ("palette", "color", "saturation", "contrast"), + ) + keys = [str(key).casefold() for key in attributes] + covered = sum(1 for aliases in structural_groups if any(any(alias in key for alias in aliases) for key in keys)) + coverage_cap = 0.55 + 0.45 * (covered / len(structural_groups)) + return min(base, coverage_cap) + + +def _optional_score(value: Any) -> float | None: + return _score(value) + + +def _safe_failure(exc: Exception) -> dict[str, Any]: + text = " ".join(str(exc or type(exc).__name__).split()) + return {"error_type": type(exc).__name__, "message": text[:500] or type(exc).__name__} + + +def _missing_queue_task_failure(task_id: Any, stage: str) -> dict[str, Any]: + return { + "error_type": "queue_task_missing", + "message": "关联的队列记录已被删除;可重新入队、排除样本或删除整个导入。", + "stage": stage, + "task_id": str(task_id or "").strip() or None, + "retryable": True, + } diff --git a/backend/services/composition_builder.py b/backend/services/composition_builder.py index 15a6c53..f2dcbc3 100644 --- a/backend/services/composition_builder.py +++ b/backend/services/composition_builder.py @@ -5,6 +5,7 @@ from __future__ import annotations from dataclasses import dataclass, field from typing import Any, Mapping +from backend.services.material_catalog_resolver import is_trusted_advanced_metadata from backend.services.material_normalization_service import CAPSULE_TIERS, WEAR_LAYERS @@ -31,6 +32,7 @@ CONTRADICTIONS = ( ("fitted", "oversized"), ("matte", "glossy"), ("short sleeve", "long sleeve"), ("transparent", "opaque"), ("minimal", "ornate"), ) +ADVANCED_VERIFIED_PRIORITY_BONUS = 20.0 @dataclass(frozen=True) @@ -130,6 +132,11 @@ class CompositionBuilder: user_adjustment = _float(item.get("user_adjustment"), 0.0) role_bonus = 20.0 if role == "identity" else 8.0 if category in {"dress", "suit", "top", "bottom", "outerwear"} else 0.0 lock_bonus = 100.0 if locked else 0.0 + advanced_verified_bonus = ( + ADVANCED_VERIFIED_PRIORITY_BONUS + if is_trusted_advanced_metadata(metadata) + else 0.0 + ) slots = _string_list(profile.get("body_slots")) automatic_visibility = 10.0 if plan.visible_slots and set(slots) & set(plan.visible_slots) else 0.0 visibility_bonus = _float(item.get("visibility_bonus"), 0.0) + automatic_visibility @@ -137,7 +144,7 @@ class CompositionBuilder: season_penalty = 12.0 if plan.season and _text(item.get("season")) and plan.season.casefold() != _text(item.get("season")).casefold() else 0.0 low_confidence_penalty = max(0.0, 0.80 - confidence) * 40.0 base_weight = BASE_WEIGHTS.get(category, BASE_WEIGHTS["other"]) - effective_weight = base_weight + user_adjustment + role_bonus + lock_bonus + visibility_bonus + restoration_feedback_bonus - low_confidence_penalty - season_penalty + effective_weight = base_weight + user_adjustment + role_bonus + lock_bonus + advanced_verified_bonus + visibility_bonus + restoration_feedback_bonus - low_confidence_penalty - season_penalty tier = _text(item.get("capsule_tier") or "detailed").lower() if tier not in CAPSULE_TIERS: tier = "standard" @@ -164,6 +171,7 @@ class CompositionBuilder: "user_adjustment": user_adjustment, "lock_bonus": lock_bonus, "role_bonus": role_bonus, + "advanced_verified_bonus": advanced_verified_bonus, "visibility_bonus": visibility_bonus, "restoration_feedback_bonus": round(restoration_feedback_bonus, 3), "season_penalty": season_penalty, diff --git a/backend/services/cost_service.py b/backend/services/cost_service.py index 8675b3b..c67fe77 100644 --- a/backend/services/cost_service.py +++ b/backend/services/cost_service.py @@ -73,6 +73,47 @@ class CostService: task_usage["output_tokens"], _usage_number(usage, "output_tokens", "completion_tokens"), ) + if not any((profile_id, workflow_id, node_id)): + # A style-set attempt projects its first validation case onto the + # legacy attempt row for compatibility. Bill the child cases and + # exclude that projection so the representative image is not + # counted twice. + advanced_rows = ( + self._advanced_material_attempt_rows() + + self._advanced_style_validation_case_rows() + ) + for row in advanced_rows: + created_at = _parse_datetime(row["created_at"]) + if since and created_at and created_at < since: + continue + provider = str(row["provider_id"] or "unknown") + if provider_id and provider != provider_id: + continue + provider_model = str(row["provider_model"] or "unknown") + model_route = str(row["model_route"] or "unknown") + usage = _json_loads(row["usage_json"]) + key = (provider, provider_model, model_route) + group = groups.setdefault(key, _new_group(provider, provider_model, model_route)) + if row["validation_image_uri"]: + group["image_count"] += 1 + task_key = str(row["task_id"] or row["billing_id"]) + group["_task_ids"].add(task_key) + task_usage = group["_usage_by_task"].setdefault( + task_key, + {"total_tokens": 0, "input_tokens": 0, "output_tokens": 0}, + ) + task_usage["total_tokens"] = max( + task_usage["total_tokens"], + _usage_number(usage, "total_tokens", "total"), + ) + task_usage["input_tokens"] = max( + task_usage["input_tokens"], + _usage_number(usage, "input_tokens", "prompt_tokens"), + ) + task_usage["output_tokens"] = max( + task_usage["output_tokens"], + _usage_number(usage, "output_tokens", "completion_tokens"), + ) finalized = [_finalize_group(group, prices) for group in groups.values()] totals = { "image_count": sum(group["image_count"] for group in finalized), @@ -158,6 +199,40 @@ class CostService: finally: conn.close() + def _advanced_material_attempt_rows(self) -> list[Any]: + conn = self.database.connect() + try: + return conn.execute( + """ + SELECT attempt_id AS billing_id, task_id, model_route, provider_id, + provider_model, usage_json, validation_image_uri, created_at + FROM advanced_material_validation_attempts AS attempt + WHERE (usage_json IS NOT NULL OR validation_image_uri IS NOT NULL) + AND NOT EXISTS ( + SELECT 1 FROM advanced_style_validation_cases AS style_case + WHERE style_case.attempt_id = attempt.attempt_id + ) + ORDER BY created_at DESC + """ + ).fetchall() + finally: + conn.close() + + def _advanced_style_validation_case_rows(self) -> list[Any]: + conn = self.database.connect() + try: + return conn.execute( + """ + SELECT case_id AS billing_id, task_id, model_route, provider_id, + provider_model, usage_json, validation_image_uri, created_at + FROM advanced_style_validation_cases + WHERE usage_json IS NOT NULL OR validation_image_uri IS NOT NULL + ORDER BY created_at DESC + """ + ).fetchall() + finally: + conn.close() + def _new_group(provider_id: str, provider_model: str, model_route: str) -> dict[str, Any]: return { diff --git a/backend/services/data_backup_service.py b/backend/services/data_backup_service.py index 8462598..197af98 100644 --- a/backend/services/data_backup_service.py +++ b/backend/services/data_backup_service.py @@ -20,6 +20,7 @@ from database.db_helper import load_config_payload, load_database_settings MAX_BACKUP_FILES = 50_000 MAX_RESTORE_BYTES = 10 * 1024 * 1024 * 1024 +PROMPT_BACKUP_PLACEHOLDER = "[EXCLUDED_FROM_BACKUP]" class DataBackupService: @@ -75,7 +76,7 @@ class DataBackupService: storage = config.get("storage") if isinstance(config.get("storage"), dict) else {} media_roots = { key: resolve_data_path(storage.get(f"{key}_path") or f"data/{key}") - for key in ("images", "thumbnails", "materials", "styles") + for key in ("images", "thumbnails", "materials", "advanced_materials", "styles") } if include_media: for key, media_root in media_roots.items(): @@ -89,7 +90,7 @@ class DataBackupService: entries.append(_entry(path, f"media/{key}/{path.relative_to(media_root).as_posix()}")) manifest = { "format": "imagestudio-full-backup", - "version": 2, + "version": 3, "material_schema_version": "1.0", "backup_id": backup_id, "created_at": datetime.now(timezone.utc).isoformat(), @@ -137,7 +138,7 @@ class DataBackupService: shutil.copy2(db_source, db_target) config = load_config_payload(self.config_service.config_path) storage = config.get("storage") if isinstance(config.get("storage"), dict) else {} - for key in ("images", "thumbnails", "materials", "styles"): + for key in ("images", "thumbnails", "materials", "advanced_materials", "styles"): source_root = temp / "media" / key if not source_root.exists(): continue @@ -230,10 +231,56 @@ def _sanitize_sqlite_backup( if not include_prompt_records: if "materials" in tables: conn.execute("UPDATE materials SET prompt = NULL, negative_prompt = NULL") + if "advanced_material_imports" in tables: + conn.execute( + "UPDATE advanced_material_imports " + "SET recognition_prompt = NULL, recognition_negative_prompt = NULL" + ) + if "advanced_material_validation_attempts" in tables: + conn.execute( + "UPDATE advanced_material_validation_attempts " + "SET prompt = ?, negative_prompt = NULL, adjustment_text = NULL, decision_notes = NULL", + (PROMPT_BACKUP_PLACEHOLDER,), + ) + if "advanced_materials" in tables: + conn.execute( + "UPDATE advanced_materials SET prompt = ?, negative_prompt = NULL", + (PROMPT_BACKUP_PLACEHOLDER,), + ) + if "advanced_style_sources" in tables: + conn.execute( + "UPDATE advanced_style_sources " + "SET recognition_prompt = NULL, recognition_negative_prompt = NULL" + ) + if "advanced_style_consensus_runs" in tables: + conn.execute( + "UPDATE advanced_style_consensus_runs SET prompt = NULL, negative_prompt = NULL" + ) + if "advanced_style_validation_cases" in tables: + conn.execute( + "UPDATE advanced_style_validation_cases " + "SET content_prompt = ?, final_prompt = ?, negative_prompt = NULL", + (PROMPT_BACKUP_PLACEHOLDER, PROMPT_BACKUP_PLACEHOLDER), + ) if "generation_images" in tables: conn.execute("UPDATE generation_images SET positive_prompt = NULL, negative_prompt = NULL") json_columns = { "materials": ("material_id", ("metadata_json",)), + "advanced_material_imports": ("import_id", ("recognition_result_json", "error_json", "metadata_json")), + "advanced_material_validation_attempts": ("attempt_id", ("usage_json", "error_json", "metadata_json")), + "advanced_materials": ("material_id", ("capsule_json", "metadata_json")), + "advanced_style_sources": ( + "source_id", + ("recognition_tags_json", "recognition_result_json", "error_json", "metadata_json"), + ), + "advanced_style_consensus_runs": ( + "consensus_id", + ("source_ids_json", "tags_json", "result_json", "error_json", "metadata_json"), + ), + "advanced_style_validation_cases": ( + "case_id", + ("usage_json", "style_review_json", "error_json", "metadata_json"), + ), "generation_images": ("image_id", ("metadata_json",)), "generation_tasks": ("task_id", ("request_json", "result_json", "metadata_json")), "audit_logs": ("audit_id", ("before_snapshot", "after_snapshot", "metadata_json")), @@ -282,7 +329,7 @@ def _strip_sensitive_records( for key, item in value.items(): lowered = str(key).lower() if not include_prompt_records and lowered in prompt_keys: - result[key] = "[EXCLUDED_FROM_BACKUP]" + result[key] = PROMPT_BACKUP_PLACEHOLDER continue if not include_moderation_records and lowered in moderation_keys: continue diff --git a/backend/services/generation_reference_service.py b/backend/services/generation_reference_service.py index adb3c1c..06943f0 100644 --- a/backend/services/generation_reference_service.py +++ b/backend/services/generation_reference_service.py @@ -10,6 +10,7 @@ from urllib.parse import urlsplit from backend.dto.common import ApiError, ErrorCode from backend.services.image_service import ImageService +from backend.services.material_catalog_resolver import is_trusted_advanced_metadata from core.storage import VfsStorage @@ -61,29 +62,29 @@ class GenerationReferenceService: ) if self.material_resolver is not None: for material_id, source in _material_reference_candidates(payload): - prepared, canonical_key, byte_count = self._resolve_material( + for prepared, canonical_key, byte_count in self._resolve_material_references( material_id, source=source, storage_cache=storage_cache, - ) - total_bytes = _append_reference( - resolved, - seen, - prepared, - canonical_key, - byte_count, - total_bytes, - source, - ) + ): + total_bytes = _append_reference( + resolved, + seen, + prepared, + canonical_key, + byte_count, + total_bytes, + source, + ) return tuple(resolved) - def _resolve_material( + def _resolve_material_references( self, material_id: str, *, source: str, storage_cache: dict[str, tuple[str, int]], - ) -> tuple[str, str, int]: + ) -> list[tuple[str, str, int]]: material = self.material_resolver.get_material(material_id) if self.material_resolver else None if material is None: raise ApiError( @@ -101,6 +102,12 @@ class GenerationReferenceService: "source": source, }, ) + metadata = material.metadata if isinstance(getattr(material, "metadata", None), dict) else {} + if is_trusted_advanced_metadata(metadata) and isinstance(metadata.get("style_set"), dict): + # Quick/direct generation consumes the verified style capsule as + # text. Source images are deliberately withheld to avoid leaking + # sample characters, clothing, composition or scenery. + return [] image_uri = _optional_text(material.image_uri) if not image_uri: raise ApiError( @@ -108,7 +115,9 @@ class GenerationReferenceService: "confirmed reference material has no image", {"material_id": material_id, "source": source}, ) - return self._prepare_uri(image_uri, source=source, storage_cache=storage_cache) + # Detailed persisted rounds expand trusted style representatives only + # after the concrete route capabilities are known. + return [self._prepare_uri(image_uri, source=source, storage_cache=storage_cache)] def _resolve_candidate( self, diff --git a/backend/services/generation_service.py b/backend/services/generation_service.py index 75eb635..18b1522 100644 --- a/backend/services/generation_service.py +++ b/backend/services/generation_service.py @@ -222,7 +222,8 @@ class GenerationService: node=node, payload=enriched_payload, ) - execution_payload = _apply_round_reference_snapshot(enriched_payload, material_snapshot) + routed_material_snapshot = _route_aware_reference_snapshot(material_snapshot, route_resolution) + execution_payload = _apply_round_reference_snapshot(enriched_payload, routed_material_snapshot) execution_payload, ephemeral_reference_count = _strip_ephemeral_image_data_urls(execution_payload) if ephemeral_reference_count: raise ApiError( @@ -250,7 +251,7 @@ class GenerationService: ) reference_snapshot = { **provided_reference_snapshot, - **material_snapshot, + **routed_material_snapshot, "reference_binding_mapping": reference_mapping, } reference_snapshot, snapshot_ephemeral_count = _strip_ephemeral_image_data_urls(reference_snapshot) @@ -2195,6 +2196,112 @@ def _apply_round_reference_snapshot( return result +def _route_aware_reference_snapshot( + snapshot: dict[str, Any], + route_resolution: dict[str, Any], +) -> dict[str, Any]: + """Select frozen style references according to the resolved adapter. + + Ordinary materials and temporary references retain their legacy primary- + image behavior. A verified style set may add up to two representative + images only when the route explicitly supports semantic reference roles; + the adapter's global ``max_reference_images`` cap is then applied to the + final immutable list. + """ + + result = copy.deepcopy(snapshot if isinstance(snapshot, dict) else {}) + resolution = route_resolution if isinstance(route_resolution, dict) else {} + settings = resolution.get("settings") if isinstance(resolution.get("settings"), dict) else {} + capabilities = ( + resolution.get("capabilities") + if isinstance(resolution.get("capabilities"), dict) + else {} + ) + supports_roles = _route_capability_bool( + settings, + capabilities, + "supports_reference_roles", + ) is True + supports_reference_images = _route_capability_bool( + settings, + capabilities, + "reference_images", + "supports_reference_images", + ) + supports_style_multi_reference = supports_roles and supports_reference_images is not False + + raw_limit = settings.get("max_reference_images") + if raw_limit is None: + raw_limit = capabilities.get("max_reference_images") + try: + max_references = min(max(int(raw_limit), 0), 16) if raw_limit is not None else 16 + except (TypeError, ValueError): + max_references = 16 + + references: list[str] = [] + materials = result.get("materials") if isinstance(result.get("materials"), list) else [] + for material in materials: + if not isinstance(material, dict): + continue + primary = _optional_text(material.get("image_uri")) + metadata = material.get("metadata") if isinstance(material.get("metadata"), dict) else {} + is_style_set = isinstance(metadata.get("style_set"), dict) + if is_style_set and supports_style_multi_reference: + candidates = _string_list(material.get("reference_image_uris")) + if primary and primary not in candidates: + candidates.insert(0, primary) + selected = candidates[:3] + else: + selected = [primary] if primary else [] + for uri in selected: + if uri and uri not in references: + references.append(uri) + + temporary = ( + result.get("temporary_references") + if isinstance(result.get("temporary_references"), list) + else [] + ) + for item in temporary: + if not isinstance(item, dict): + continue + uri = _optional_text(item.get("image_uri")) + if uri and uri not in references: + references.append(uri) + + result["reference_uris"] = references[:max_references] + result["reference_route_policy"] = { + "supports_reference_roles": supports_roles, + "supports_reference_images": supports_reference_images, + "style_multi_reference_enabled": supports_style_multi_reference, + "max_reference_images": max_references, + "selected_reference_count": len(result["reference_uris"]), + } + return result + + +def _route_capability_bool( + settings: dict[str, Any], + capabilities: dict[str, Any], + *keys: str, +) -> bool | None: + for source in (settings, capabilities): + for key in keys: + if key not in source: + continue + value = source.get(key) + if isinstance(value, bool): + return value + if isinstance(value, (int, float)): + return bool(value) + text = str(value or "").strip().casefold() + if text in {"1", "true", "yes", "on", "enabled"}: + return True + if text in {"0", "false", "no", "off", "disabled", ""}: + return False + return None + + def _round_timeout_seconds(request: dict[str, Any], route_resolution: Any) -> int: resolution = route_resolution if isinstance(route_resolution, dict) else {} settings = resolution.get("settings") if isinstance(resolution.get("settings"), dict) else {} diff --git a/backend/services/material_analytics_service.py b/backend/services/material_analytics_service.py index a645dc8..a0593d8 100644 --- a/backend/services/material_analytics_service.py +++ b/backend/services/material_analytics_service.py @@ -17,6 +17,30 @@ class MaterialAnalyticsService: conn = self.database.connect() try: materials = conn.execute("SELECT recognition_status, metadata_json FROM materials WHERE recognition_status != 'archived'").fetchall() + advanced_materials = conn.execute( + """ + SELECT material.status, material.metadata_json, attempt.fidelity_score + FROM advanced_materials AS material + LEFT JOIN advanced_material_validation_attempts AS attempt + ON attempt.attempt_id = material.accepted_attempt_id + WHERE material.status != 'archived' + """ + ).fetchall() + advanced_attempts = conn.execute( + "SELECT status, fidelity_score FROM advanced_material_validation_attempts" + ).fetchall() + style_imports = conn.execute( + "SELECT status, metadata_json FROM advanced_material_imports" + ).fetchall() + style_sources = conn.execute( + "SELECT status FROM advanced_style_sources" + ).fetchall() + style_consensus_runs = conn.execute( + "SELECT status FROM advanced_style_consensus_runs" + ).fetchall() + style_validation_cases = conn.execute( + "SELECT status, fidelity_score FROM advanced_style_validation_cases" + ).fetchall() audits = conn.execute("SELECT action, after_snapshot, metadata_json FROM audit_logs WHERE action IN ('wardrobe_match','apply_wardrobe_template','recognize_material','renormalize_material')").fetchall() tasks = conn.execute("SELECT model_route, request_json, metadata_json FROM generation_tasks").fetchall() finally: @@ -62,6 +86,26 @@ class MaterialAnalyticsService: route_reasons[str(route.get("reason") or "unknown")] += 1 route_counts[str(row["model_route"] or route.get("selected_route") or "unresolved")] += 1 total = len(materials) + accepted_advanced = sum(1 for row in advanced_materials if str(row["status"]) == "active") + active_style_sets = sum( + 1 + for row in advanced_materials + if str(row["status"]) == "active" and _is_style_set_metadata(_json(row["metadata_json"])) + ) + style_set_import_rows = [ + row for row in style_imports if _is_style_set_metadata(_json(row["metadata_json"])) + ] + style_source_statuses = Counter(str(row["status"] or "unknown") for row in style_sources) + style_consensus_statuses = Counter(str(row["status"] or "unknown") for row in style_consensus_runs) + style_case_statuses = Counter(str(row["status"] or "unknown") for row in style_validation_cases) + style_case_scores = [ + float(row["fidelity_score"]) + for row in style_validation_cases + if row["fidelity_score"] is not None + ] + reviewed_attempts = [row for row in advanced_attempts if str(row["status"]) in {"accepted", "rejected"}] + accepted_attempts = sum(1 for row in reviewed_attempts if str(row["status"]) == "accepted") + scored_attempts = [float(row["fidelity_score"]) for row in reviewed_attempts if row["fidelity_score"] is not None] return { "materials": { "total": total, @@ -71,6 +115,30 @@ class MaterialAnalyticsService: "needs_confirmation": needs_confirmation, "categories": dict(category_counts), }, + "advanced_materials": { + "active": accepted_advanced, + "active_style_sets": active_style_sets, + "validation_attempts": len(advanced_attempts), + "reviewed_attempts": len(reviewed_attempts), + "acceptance_rate": round(accepted_attempts / len(reviewed_attempts), 4) if reviewed_attempts else 0.0, + "average_fidelity_score": round(sum(scored_attempts) / len(scored_attempts), 4) if scored_attempts else None, + }, + "advanced_style_sets": { + "imports": len(style_set_import_rows), + "accepted_imports": sum(1 for row in style_set_import_rows if str(row["status"]) == "accepted"), + "active_materials": active_style_sets, + "sources": len(style_sources), + "source_statuses": dict(style_source_statuses), + "consensus_runs": len(style_consensus_runs), + "consensus_statuses": dict(style_consensus_statuses), + "validation_cases": len(style_validation_cases), + "validation_case_statuses": dict(style_case_statuses), + "average_case_fidelity_score": ( + round(sum(style_case_scores) / len(style_case_scores), 4) + if style_case_scores + else None + ), + }, "composition": { "runs": composition_count, "conflicts": conflicts, @@ -95,3 +163,11 @@ def _json(value: Any) -> dict[str, Any]: except (TypeError, json.JSONDecodeError): return {} return parsed if isinstance(parsed, dict) else {} + + +def _is_style_set_metadata(metadata: dict[str, Any]) -> bool: + return ( + str(metadata.get("workflow_kind") or "").strip().casefold() == "style_set" + or isinstance(metadata.get("style_set"), dict) + or metadata.get("style_set") is True + ) diff --git a/backend/services/material_catalog_resolver.py b/backend/services/material_catalog_resolver.py new file mode 100644 index 0000000..e9bd449 --- /dev/null +++ b/backend/services/material_catalog_resolver.py @@ -0,0 +1,210 @@ +"""Resolve normal and verified advanced materials through one trusted catalog. + +The two libraries deliberately keep separate persistence models. Generation +and workflow code, however, only need the stable :class:`Material` contract. +This adapter is the trust boundary between persisted user-editable metadata and +the composition priority rules: reserved catalog fields are always replaced by +server-derived values and cannot be promoted by writing ordinary metadata. +""" + +from __future__ import annotations + +from copy import deepcopy +from typing import Any + +from backend.dto.advanced_material_dto import AdvancedMaterial +from backend.dto.material_dto import Material, MaterialCategory +from database.repositories.advanced_material_repository import AdvancedMaterialRepository +from database.repositories.material_repository import MaterialRepository + + +ADVANCED_MATERIAL_ID_PREFIX = "advmat_" +ADVANCED_VERIFIED_PRIORITY = 100 +_CATALOG_RESERVED_METADATA_KEYS = frozenset( + {"library_kind", "priority_class", "material_priority", "verification"} +) + + +class CatalogMaterialMetadata(dict[str, Any]): + """Dict-compatible metadata carrying an in-process catalog trust marker. + + The marker is intentionally an attribute rather than a serializable key. + Data loaded from JSON can therefore never manufacture the marker. The + object remains JSON-serializable anywhere the existing ``Material`` DTO is + serialized. + """ + + __slots__ = ("_advanced_verified",) + + def __init__(self, value: dict[str, Any], *, advanced_verified: bool): + super().__init__(value) + self._advanced_verified = bool(advanced_verified) + + @property + def advanced_verified(self) -> bool: + return self._advanced_verified + + +def is_trusted_advanced_metadata(value: Any) -> bool: + """Return whether metadata was resolved from an active advanced record.""" + + return ( + isinstance(value, CatalogMaterialMetadata) + and value.advanced_verified + and value.get("library_kind") == "advanced" + and value.get("priority_class") == "advanced_verified" + and value.get("material_priority") == ADVANCED_VERIFIED_PRIORITY + ) + + +class MaterialCatalogResolver: + """Expose normal and accepted advanced materials via the legacy DTO.""" + + def __init__( + self, + materials: MaterialRepository, + advanced_materials: AdvancedMaterialRepository, + ): + self.materials = materials + self.advanced_materials = advanced_materials + + def get_material(self, material_id: str) -> Material | None: + normalized_id = str(material_id or "").strip() + if not normalized_id: + return None + if normalized_id.startswith(ADVANCED_MATERIAL_ID_PREFIX): + advanced = self.advanced_materials.get_material(normalized_id) + if advanced is None or advanced.status != "active": + return None + return self._advanced_to_material(advanced) + material = self.materials.get_material(normalized_id) + return self._normal_material(material) if material is not None else None + + def get_category(self, category_id: str) -> MaterialCategory | None: + return self.materials.get_category(category_id) + + def update_material(self, material_id: str, payload: dict[str, Any]) -> Material | None: + """Update restoration feedback without crossing the library boundary. + + Catalog identity and priority fields remain server-owned even when the + caller supplies a complete metadata replacement. + """ + + normalized_id = str(material_id or "").strip() + if normalized_id.startswith(ADVANCED_MATERIAL_ID_PREFIX): + current = self.advanced_materials.get_material(normalized_id) + if current is None or current.status != "active": + return None + update = dict(payload or {}) + if "metadata" in update: + update["metadata"] = _without_catalog_fields(update.get("metadata")) + updated = self.advanced_materials.update_material(normalized_id, update) + return ( + self._advanced_to_material(updated) + if updated is not None and updated.status == "active" + else None + ) + update = dict(payload or {}) + if "metadata" in update: + update["metadata"] = _without_catalog_fields(update.get("metadata")) + updated = self.materials.update_material(normalized_id, update) + return self._normal_material(updated) if updated is not None else None + + def _normal_material(self, material: Material) -> Material: + metadata = CatalogMaterialMetadata( + { + **_without_catalog_fields(material.metadata), + "library_kind": "standard", + "priority_class": "standard", + "material_priority": 0, + "verification": {}, + }, + advanced_verified=False, + ) + return Material( + material_id=material.material_id, + category_id=material.category_id, + display_name=material.display_name, + image_uri=material.image_uri, + thumbnail_uri=material.thumbnail_uri, + prompt=material.prompt, + negative_prompt=material.negative_prompt, + tags=list(material.tags), + recognition_status=material.recognition_status, + metadata=metadata, + created_at=material.created_at, + updated_at=material.updated_at, + ) + + def _advanced_to_material(self, material: AdvancedMaterial) -> Material: + attempt = self.advanced_materials.get_attempt(material.accepted_attempt_id) + verification: dict[str, Any] = { + "status": "accepted", + "import_id": material.import_id, + "accepted_attempt_id": material.accepted_attempt_id, + "source_image_uri": material.source_image_uri, + "validation_image_uri": material.validation_image_uri, + "validation_thumbnail_uri": material.validation_thumbnail_uri, + "accepted_at": material.accepted_at, + } + if attempt is not None: + verification.update( + { + "attempt_number": attempt.attempt_number, + "fidelity_score": attempt.fidelity_score, + "decision": attempt.decision, + "decision_notes": attempt.decision_notes, + "model_route": attempt.model_route, + "decided_at": attempt.decided_at, + } + ) + metadata = _without_catalog_fields(material.metadata) + capsules = _generation_capsules(material.capsule, metadata) + if capsules: + metadata["generation_capsules"] = capsules + metadata = CatalogMaterialMetadata( + { + **metadata, + "library_kind": "advanced", + "priority_class": "advanced_verified", + "material_priority": ADVANCED_VERIFIED_PRIORITY, + "verification": verification, + }, + advanced_verified=True, + ) + return Material( + material_id=material.material_id, + category_id=material.category_id, + display_name=material.display_name, + image_uri=material.source_image_uri, + thumbnail_uri=material.source_thumbnail_uri, + prompt=material.prompt, + negative_prompt=material.negative_prompt, + tags=list(material.tags), + recognition_status="confirmed", + metadata=metadata, + created_at=material.created_at, + updated_at=material.updated_at, + ) + + +def _without_catalog_fields(value: Any) -> dict[str, Any]: + source = value if isinstance(value, dict) else {} + return { + str(key): deepcopy(child) + for key, child in source.items() + if str(key) not in _CATALOG_RESERVED_METADATA_KEYS + } + + +def _generation_capsules(capsule: Any, metadata: dict[str, Any]) -> dict[str, Any]: + source = capsule if isinstance(capsule, dict) else {} + nested = source.get("generation_capsules") + if isinstance(nested, dict): + return deepcopy(nested) + if any(isinstance(source.get(tier), dict) for tier in ("compact", "standard", "detailed")): + return deepcopy(source) + if source: + return {"detailed": deepcopy(source)} + existing = metadata.get("generation_capsules") + return deepcopy(existing) if isinstance(existing, dict) else {} diff --git a/backend/services/material_normalization_service.py b/backend/services/material_normalization_service.py index 03e28b3..097a175 100644 --- a/backend/services/material_normalization_service.py +++ b/backend/services/material_normalization_service.py @@ -114,7 +114,14 @@ class MaterialNormalizationService: now = _utc_now() payload = deepcopy(dict(structured_data)) raw_section = payload.get("raw_analysis") if isinstance(payload.get("raw_analysis"), dict) else payload - raw_attributes = self._normalize_attributes(raw_section.get("attributes"), confidence) + profile_input = payload.get("normalized_asset_profile") + if not isinstance(profile_input, dict): + profile_input = payload.get("asset_profile") if isinstance(payload.get("asset_profile"), dict) else {} + profile_attributes = self._normalize_attributes(profile_input.get("attributes"), confidence) + raw_attributes = { + **profile_attributes, + **self._normalize_attributes(raw_section.get("attributes"), confidence), + } if not raw_attributes: raw_attributes = self._attributes_from_legacy(prompt, tags, confidence) raw_analysis = { @@ -127,9 +134,6 @@ class MaterialNormalizationService: "source_payload": payload, } - profile_input = payload.get("normalized_asset_profile") - if not isinstance(profile_input, dict): - profile_input = payload.get("asset_profile") if isinstance(payload.get("asset_profile"), dict) else {} normalized = self._build_profile( profile_input, raw_attributes=raw_attributes, @@ -195,6 +199,9 @@ class MaterialNormalizationService: item.get("source_state") != "observed" or float(item.get("confidence") or 0.0) < 0.80 for item in raw_attributes.values() ) + must_preserve = _string_list(value.get("must_preserve")) + if category == "style" and not must_preserve: + must_preserve = _attribute_prompt_parts(attributes)[:16] return { "schema_version": MATERIAL_SCHEMA_VERSION, "prompt_version": MATERIAL_PROMPT_VERSION, @@ -204,7 +211,7 @@ class MaterialNormalizationService: "body_slots": body_slots, "wear_layer": wear_layer, "attributes": attributes, - "must_preserve": _string_list(value.get("must_preserve")), + "must_preserve": must_preserve, "forbidden_changes": _string_list(value.get("forbidden_changes")) or _split_prompt(negative_prompt), "tags": sorted(set(tags)), "confidence": _confidence(value.get("confidence"), confidence), diff --git a/backend/services/material_service.py b/backend/services/material_service.py index bcfd087..14c1ed2 100644 --- a/backend/services/material_service.py +++ b/backend/services/material_service.py @@ -860,9 +860,16 @@ def _vision_provider_error(exc: VisionProviderError) -> dict[str, Any]: "provider_id": _optional_text(exc.provider_id) or "unknown", "status_code": exc.status_code, "error_type": _optional_text(exc.error_type) or "provider_error", + "response_issue": str(exc)[:300], } if isinstance(exc.details.get("retryable"), bool): failure["retryable"] = exc.details["retryable"] + reason = _optional_text(exc.details.get("reason") or exc.details.get("parse_error")) + if reason: + failure["reason"] = reason[:500] + structured_keys = exc.details.get("structured_keys") + if isinstance(structured_keys, list): + failure["structured_keys"] = [str(item) for item in structured_keys[:50]] return failure diff --git a/backend/services/model_provider_runtime.py b/backend/services/model_provider_runtime.py index 3d21d46..be13646 100644 --- a/backend/services/model_provider_runtime.py +++ b/backend/services/model_provider_runtime.py @@ -9,13 +9,14 @@ from typing import Any from urllib.parse import urlsplit from backend.services.model_provider_service import ModelProviderService +from core.model_route_chain import model_route_candidates from core.secret_service import SecretStore, resolve_secret_value from core.remote_fetch import read_http_response_limited, validate_http_url from core.image_formats import detect_image_format from core.storage import VfsStorage from database.db_helper import load_config_payload from engines.image_provider import FallbackImageProvider, ImageProvider, ImageProviderConfig, OpenAIImageProvider -from engines.vision_provider import OpenAIVisionProvider, VisionProvider, VisionProviderConfig +from engines.vision_provider import FallbackVisionProvider, OpenAIVisionProvider, VisionProvider, VisionProviderConfig class ModelProviderRuntime: @@ -32,22 +33,29 @@ class ModelProviderRuntime: route_name = str(route_context.get("route_name") or "").strip() if not route_name: return None - resolved = self.model_provider_service.resolve_route(route_name, modality="image_generation") - if not resolved: + candidates: list[dict[str, Any]] = [] + seen: set[str] = set() + for candidate_name in model_route_candidates(route_name): + if candidate_name.startswith("astrbot:"): + continue + candidate = self.model_provider_service.resolve_route(candidate_name, modality="image_generation") + if candidate and str(candidate.get("route_id")) not in seen: + candidates.append(candidate) + seen.add(str(candidate.get("route_id"))) + if not candidates: return None - candidates = [resolved] + resolved = candidates[0] route_settings = resolved.get("settings") if isinstance(resolved.get("settings"), dict) else {} # A model selected in the UI must only call its own provider. Generic # cross-provider fallback can silently switch models and used to hide # the selected provider's real error. Safety routing is handled by the # generation governance layer instead. - fallback_enabled = _configured_bool( + fallback_enabled = len(candidates) > 1 or _configured_bool( route_context.get("allow_provider_fallback"), route_settings.get("allow_provider_fallback"), default=False, ) if fallback_enabled: - seen = {str(resolved.get("route_id"))} excluded_routes = {str(item).strip() for item in route_context.get("excluded_fallback_routes", []) if str(item).strip()} if isinstance(route_context.get("excluded_fallback_routes"), list) else set() fallback_routes = sorted( self.model_provider_service.list_routes(enabled=True), @@ -104,6 +112,16 @@ class ModelProviderRuntime: route_name = str(route_context.get("route_name") or "").strip() if not route_name: return None + providers = [ + provider + for candidate in model_route_candidates(route_name) + if (provider := self._vision_provider_for_single_route(candidate)) is not None + ] + if not providers: + return None + return providers[0] if len(providers) == 1 else FallbackVisionProvider(providers) + + def _vision_provider_for_single_route(self, route_name: str) -> VisionProvider | None: if route_name.startswith("astrbot:"): # AstrBot owns this provider's credentials and runtime client. Do # not mirror those secrets into ImageStudio's provider tables. @@ -149,6 +167,32 @@ class ModelProviderRuntime: def structured_text_callable(self, route_name: str): """Return an OpenAI-compatible JSON completion callable for a configured route.""" + callables = [ + completion + for candidate in model_route_candidates(route_name) + if (completion := self._structured_text_callable_for_single_route(candidate)) is not None + ] + if not callables: + return None + if len(callables) == 1: + return callables[0] + + def complete_with_fallback(request_payload: dict[str, Any]) -> dict[str, Any] | str: + failures: list[str] = [] + for completion in callables: + try: + return completion(request_payload) + except Exception as exc: + failures.append(str(exc)[:500]) + raise RuntimeError(f"all configured text routes failed: {' | '.join(failures)}") + + return complete_with_fallback + + def _structured_text_callable_for_single_route(self, route_name: str): + if route_name.startswith("astrbot:"): + from core.astrbot_provider_bridge import astrbot_structured_text_callable + + return astrbot_structured_text_callable(route_name) resolved = self.model_provider_service.resolve_route(route_name) if not resolved: return None @@ -207,6 +251,37 @@ class ModelProviderRuntime: return complete def structured_vision_callable(self, route_name: str, *, storage: VfsStorage | None = None): + callables = [ + review + for candidate in model_route_candidates(route_name) + if (review := self._structured_vision_callable_for_single_route(candidate, storage=storage)) is not None + ] + if not callables: + return None + if len(callables) == 1: + return callables[0] + + def review_with_fallback(request_payload: dict[str, Any]) -> dict[str, Any]: + failures: list[str] = [] + for review in callables: + try: + return review(request_payload) + except Exception as exc: + failures.append(str(exc)[:500]) + raise RuntimeError(f"all configured vision review routes failed: {' | '.join(failures)}") + + return review_with_fallback + + def _structured_vision_callable_for_single_route( + self, + route_name: str, + *, + storage: VfsStorage | None = None, + ): + if route_name.startswith("astrbot:"): + from core.astrbot_provider_bridge import astrbot_structured_vision_callable + + return astrbot_structured_vision_callable(route_name, storage=storage) resolved = self.model_provider_service.resolve_route(route_name) if not resolved: return None diff --git a/backend/services/model_provider_service.py b/backend/services/model_provider_service.py index 7d72861..b24fb29 100644 --- a/backend/services/model_provider_service.py +++ b/backend/services/model_provider_service.py @@ -5,6 +5,7 @@ from __future__ import annotations import re from typing import Any +from core.model_route_chain import model_route_candidates from core.secret_service import redact_provider_secret_state from database.repositories.model_provider_repository import ModelProviderRepository @@ -49,14 +50,21 @@ class ModelProviderService: return self.repository.list_routes(enabled=enabled) def resolve_route(self, route_name: str, *, modality: str | None = None) -> dict[str, Any] | None: - resolved = self.repository.resolve_route(route_name, modality=modality) - if resolved or "/" not in route_name: - return resolved - - provider_id, model_id = route_name.split("/", 1) - if not provider_id or not model_id: - return None - return self.repository.resolve_provider_model(provider_id, model_id, modality=modality) + for candidate in model_route_candidates(route_name): + if candidate.startswith("astrbot:"): + continue + resolved = self.repository.resolve_route(candidate, modality=modality) + if resolved or "/" not in candidate: + if resolved: + return resolved + continue + provider_id, model_id = candidate.split("/", 1) + if not provider_id or not model_id: + continue + resolved = self.repository.resolve_provider_model(provider_id, model_id, modality=modality) + if resolved: + return resolved + return None def _required_text(value: Any, field: str) -> str: diff --git a/backend/services/orphan_media_service.py b/backend/services/orphan_media_service.py index a667052..9a16048 100644 --- a/backend/services/orphan_media_service.py +++ b/backend/services/orphan_media_service.py @@ -34,6 +34,31 @@ class OrphanMediaService: for table, columns in ( ("generation_images", ("image_uri", "thumbnail_uri")), ("materials", ("image_uri", "thumbnail_uri")), + ( + "advanced_material_imports", + ("source_image_uri", "source_thumbnail_uri"), + ), + ( + "advanced_material_validation_attempts", + ("validation_image_uri", "validation_thumbnail_uri"), + ), + ( + "advanced_materials", + ( + "source_image_uri", + "source_thumbnail_uri", + "validation_image_uri", + "validation_thumbnail_uri", + ), + ), + ( + "advanced_style_sources", + ("source_image_uri", "source_thumbnail_uri"), + ), + ( + "advanced_style_validation_cases", + ("validation_image_uri", "validation_thumbnail_uri"), + ), ("character_profiles", ("avatar_image_uri",)), ): for row in conn.execute(f"SELECT {', '.join(columns)} FROM {table}").fetchall(): diff --git a/backend/services/prompt_governance_service.py b/backend/services/prompt_governance_service.py index 7e59675..478b555 100644 --- a/backend/services/prompt_governance_service.py +++ b/backend/services/prompt_governance_service.py @@ -159,9 +159,19 @@ class PromptModerationService: self.reviewer = reviewer def moderate(self, *, original_prompt: str, translated_prompt: str = "", final_prompt: str = "", negative_prompt: str = "", reference_bindings: list[dict[str, Any]] | None = None) -> PromptModerationDecision: - text = "\n".join(_text(value) for value in (original_prompt, translated_prompt, final_prompt, negative_prompt) if _text(value)) - rule = self._rule_decision(text) - model = self._model_decision(text, reference_bindings or []) + positive_text = "\n".join( + _text(value) + for value in (original_prompt, translated_prompt, final_prompt) + if _text(value) + ) + # Negative prompts describe content that should be excluded. Treating + # words such as "nudity", "gore" or "child" there as requested + # content creates false adult/prohibited decisions. + rule = self._rule_decision(positive_text) + review_text = positive_text + if negative := _text(negative_prompt): + review_text = f"{positive_text}\n\nNegative constraints (must be excluded):\n{negative}" + model = self._model_decision(review_text, reference_bindings or []) return _stricter_decision(rule, model) def _rule_decision(self, text: str) -> PromptModerationDecision: @@ -185,8 +195,18 @@ class PromptModerationService: return _decision("safe", 0.85, [], ["no_risk_signal"], "allow", None) def _model_decision(self, text: str, references: list[dict[str, Any]]) -> PromptModerationDecision | None: - if self.reviewer is None or not bool(self.config.get("llm_review_enabled", False)): + if not bool(self.config.get("llm_review_enabled", False)): return None + if self.reviewer is None: + fallback = _text(self.config.get("failure_policy") or "fail_closed") + return _decision( + "uncertain" if fallback == "confirm" else "prohibited", + 0.5, + ["review_unavailable"], + ["moderation_service_unavailable"], + "confirm_or_reject" if fallback == "confirm" else "reject", + "内容审核模型不可用,已采用保守策略。", + ) try: response = self.reviewer({"text": text, "reference_bindings": references, "levels": list(RISK_LEVELS), "rules_version": self.RULES_VERSION}) level = _text(response.get("level")) @@ -254,7 +274,27 @@ class GenerationRouteService: class GenerationFailureClassifier: - CONTENT_SIGNALS = ("nsfw", "safety", "content policy", "moderation", "sexual content", "adult content", "blocked prompt", "内容审核", "敏感内容") + CONTENT_SIGNALS = ( + "nsfw", + "safety", + "content policy", + "moderation", + "sexual content", + "adult content", + "blocked prompt", + "underage", + "child sexual", + "violence", + "gore", + "terror", + "extremism", + "内容审核", + "敏感内容", + ) + ADULT_SAFETY_SIGNALS = ("nsfw", "sexual content", "adult content", "nudity", "erotic", "porn") + MINOR_SAFETY_SIGNALS = ("minor", "underage", "child sexual", "csam") + VIOLENCE_SAFETY_SIGNALS = ("violence", "violent", "gore", "dismember", "beheading", "torture") + TERROR_SAFETY_SIGNALS = ("terror", "extremism", "extremist") def classify(self, failure: Mapping[str, Any] | BaseException) -> dict[str, Any]: if isinstance(failure, Mapping): @@ -269,8 +309,19 @@ class GenerationFailureClassifier: detail = f"{failure} {details}" provider_id = _optional_text(getattr(failure, "provider_id", None)) lower = f"{error_type} {detail}".casefold() + safety_reason = None if any(signal in lower for signal in self.CONTENT_SIGNALS): category = "content_safety_rejection" + if any(signal in lower for signal in self.MINOR_SAFETY_SIGNALS): + safety_reason = "minor" + elif any(signal in lower for signal in self.TERROR_SAFETY_SIGNALS): + safety_reason = "terror" + elif any(signal in lower for signal in self.VIOLENCE_SAFETY_SIGNALS): + safety_reason = "violence" + elif any(signal in lower for signal in self.ADULT_SAFETY_SIGNALS): + safety_reason = "adult" + else: + safety_reason = "unknown" elif "quota" in lower or "credit" in lower or "balance" in lower: category = "quota_exhausted" elif status == 429 or "rate" in lower: @@ -287,7 +338,14 @@ class GenerationFailureClassifier: category = "upstream_error" else: category = "unknown" - return {"failure_class": category, "provider_id": provider_id, "status_code": status, "error_type": error_type, "summary": _redact(detail)[:500]} + return { + "failure_class": category, + "safety_reason": safety_reason, + "provider_id": provider_id, + "status_code": status, + "error_type": error_type, + "summary": _redact(detail)[:500], + } class ImageModerationService: diff --git a/backend/services/settings_service.py b/backend/services/settings_service.py index c23cf6d..73c22ad 100644 --- a/backend/services/settings_service.py +++ b/backend/services/settings_service.py @@ -102,6 +102,8 @@ class SettingsService: "title": "模型分工", "fields": [ _field("material_recognition", "string", label="素材解析路由"), + _field("advanced_material_recognition", "string", label="进阶素材识别路由"), + _field("advanced_material_validation_generation", "string", label="进阶素材验证生图路由"), _field("profile_parse", "string", label="角色导入解析路由"), _field("persona_split", "string", label="人设拆解路由"), _field("prompt_planning", "string", label="提示词规划路由"), @@ -128,6 +130,21 @@ class SettingsService: _field("category_requirements", "list", label="分类附加要求"), ], }, + { + "key": "advanced_materials", + "title": "进阶素材", + "fields": [ + _field("cost_budget.enabled", "bool", label="启用验证预算守卫"), + _field("cost_budget.days", "number", label="用量统计窗口(天)"), + _field("cost_budget.max_task_count", "number", label="窗口内最大验证任务数"), + _field("cost_budget.max_image_count", "number", label="窗口内最大验证图片数"), + _field("cost_budget.max_estimated_cost", "number", label="窗口内最大估算费用"), + _field("cost_budget.price_key", "string", label="计价键(Provider 或模型 ID)"), + _field("cost_budget.per_request", "number", label="每次请求单价"), + _field("cost_budget.per_image", "number", label="每张图片单价"), + _field("cost_budget.per_1k_tokens", "number", label="每千 Token 单价"), + ], + }, { "key": "prompt_governance", "title": "提示词与内容分流", @@ -180,6 +197,7 @@ class SettingsService: _field("images_path", "path", label="图片目录"), _field("thumbnails_path", "path", label="缩略图目录"), _field("materials_path", "path", label="素材目录"), + _field("advanced_materials_path", "path", label="进阶素材独立目录"), _field("styles_path", "path", label="风格目录"), _field("archives_path", "path", label="归档目录"), _field("temp_path", "path", label="临时目录"), @@ -324,6 +342,30 @@ class SettingsService: days = -1 if days < 0: errors.append({"field": f"prompt_governance.retention.{key}", "message": "retention days must be zero or greater"}) + advanced_materials = config.get("advanced_materials", {}) + if isinstance(advanced_materials, Mapping): + budget = advanced_materials.get("cost_budget", {}) + if isinstance(budget, Mapping): + for key in ("days", "max_task_count", "max_image_count"): + value = budget.get(key) + if value in (None, ""): + continue + try: + normalized = int(value) + except (TypeError, ValueError): + normalized = -1 + if normalized < 0: + errors.append({"field": f"advanced_materials.cost_budget.{key}", "message": "value must be zero or greater"}) + for key in ("max_estimated_cost", "per_request", "per_image", "per_1k_tokens"): + value = budget.get(key) + if value in (None, ""): + continue + try: + normalized_cost = float(value) + except (TypeError, ValueError): + normalized_cost = -1 + if normalized_cost < 0: + errors.append({"field": f"advanced_materials.cost_budget.{key}", "message": "value must be zero or greater"}) return {"valid": not errors, "errors": errors, "warnings": warnings} def diff(self, candidate: Mapping[str, Any]) -> dict[str, Any]: diff --git a/backend/services/wardrobe_service.py b/backend/services/wardrobe_service.py index 26fa790..aa75ce8 100644 --- a/backend/services/wardrobe_service.py +++ b/backend/services/wardrobe_service.py @@ -8,13 +8,24 @@ from uuid import uuid4 from backend.dto.common import ApiError, ErrorCode from backend.dto.wardrobe_dto import WardrobeItem -from backend.services.composition_builder import CompositionBuilder, CompositionPlan +from backend.services.composition_builder import ( + ADVANCED_VERIFIED_PRIORITY_BONUS, + CompositionBuilder, + CompositionPlan, +) +from backend.services.material_catalog_resolver import ( + MaterialCatalogResolver, + is_trusted_advanced_metadata, +) from backend.services.material_normalization_service import MaterialNormalizationService from core.audit_service import AuditService from core.identity import RequestContext from database.repositories.material_repository import MaterialRepository from database.repositories.profile_repository import ProfileRepository -from database.repositories.wardrobe_repository import WardrobeRepository +from database.repositories.wardrobe_repository import ( + AdvancedWardrobeRepository, + WardrobeRepository, +) DEFAULT_WARDROBE_CATEGORIES = ("top", "bottom", "dress", "shoes", "accessory") @@ -27,6 +38,8 @@ class WardrobeService: profile_repository: ProfileRepository, material_repository: MaterialRepository, audit_service: AuditService, + advanced_wardrobe_repository: AdvancedWardrobeRepository | None = None, + material_catalog: MaterialCatalogResolver | None = None, composition_builder: CompositionBuilder | None = None, normalization_service: MaterialNormalizationService | None = None, ): @@ -34,6 +47,8 @@ class WardrobeService: self.profile_repository = profile_repository self.material_repository = material_repository self.audit_service = audit_service + self.advanced_wardrobe_repository = advanced_wardrobe_repository + self.material_catalog = material_catalog self.composition_builder = composition_builder or CompositionBuilder() self.normalization_service = normalization_service or MaterialNormalizationService() @@ -49,13 +64,14 @@ class WardrobeService: "wardrobe_category is required", {"field": "wardrobe_category"}, ) - material = self.material_repository.get_material(material_id) + material = self._get_catalog_material(material_id) if material is None or material.recognition_status != "confirmed": raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "confirmed material not found", {"material_id": material_id}) + repository = self._repository_for_material_id(material_id) duplicate = next( ( existing - for existing in self.wardrobe_repository.list_by_profile(profile_id, wardrobe_category) + for existing in repository.list_by_profile(profile_id, wardrobe_category) if existing.material_id == material_id ), None, @@ -63,7 +79,7 @@ class WardrobeService: if duplicate is not None: raise _duplicate_wardrobe_item_error(profile_id, material_id, wardrobe_category, duplicate.wardrobe_item_id) try: - item = self.wardrobe_repository.create( + item = repository.create( { "wardrobe_item_id": payload.get("wardrobe_item_id") or new_wardrobe_item_id(), "profile_id": profile_id, @@ -95,18 +111,21 @@ class WardrobeService: ctx: RequestContext, ) -> list[WardrobeItem]: self._ensure_profile(profile_id, ctx) - return self.wardrobe_repository.list_by_profile(profile_id, wardrobe_category) + items = self.wardrobe_repository.list_by_profile(profile_id, wardrobe_category) + if self.advanced_wardrobe_repository is not None: + items.extend(self.advanced_wardrobe_repository.list_by_profile(profile_id, wardrobe_category)) + return sorted(items, key=lambda item: (item.is_favorite, item.created_at), reverse=True) def delete_item(self, profile_id: str, wardrobe_item_id: str, ctx: RequestContext) -> WardrobeItem: self._ensure_profile(profile_id, ctx) - before = self.wardrobe_repository.get(wardrobe_item_id) + repository, before = self._find_wardrobe_item(wardrobe_item_id) if before is None or before.profile_id != profile_id: raise ApiError( ErrorCode.RESOURCE_NOT_FOUND, "wardrobe item not found", {"wardrobe_item_id": wardrobe_item_id}, ) - deleted = self.wardrobe_repository.delete(wardrobe_item_id) + deleted = repository.delete(wardrobe_item_id) assert deleted is not None self.audit_service.record( ctx=ctx, @@ -128,7 +147,7 @@ class WardrobeService: material_ids = [str(item).strip() for item in payload.get("material_ids", []) if str(item).strip()] if isinstance(payload.get("material_ids"), list) else [] if not name or not material_ids: raise ApiError(ErrorCode.VALIDATION_FAILED, "template name and material_ids are required", {"fields": ["name", "material_ids"]}) - owned_material_ids = {item.material_id for item in self.wardrobe_repository.list_by_profile(profile_id)} + owned_material_ids = {item.material_id for item in self.list_items(profile_id, None, ctx)} missing = [material_id for material_id in material_ids if material_id not in owned_material_ids] if missing: raise ApiError(ErrorCode.VALIDATION_FAILED, "template contains materials outside this wardrobe", {"material_ids": missing}) @@ -165,13 +184,13 @@ class WardrobeService: template = next((item for item in self.list_templates(profile_id, ctx) if item.get("template_id") == template_id), None) if template is None: raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "wardrobe template not found", {"template_id": template_id}) - wardrobe = self.wardrobe_repository.list_by_profile(profile_id) + wardrobe = self.list_items(profile_id, None, ctx) item_by_material = {item.material_id: item for item in wardrobe} selected: list[dict[str, Any]] = [] options = template.get("material_options") if isinstance(template.get("material_options"), dict) else {} for material_id in template.get("material_ids") or []: item = item_by_material.get(str(material_id)) - material = self.material_repository.get_material(str(material_id)) + material = self._get_catalog_material(str(material_id)) if item is None or material is None or material.recognition_status != "confirmed": continue selected.append({ @@ -204,13 +223,13 @@ class WardrobeService: missing_categories: list[str] = [] material_options = payload.get("material_options") if isinstance(payload.get("material_options"), dict) else {} for category in categories: - candidates = self.wardrobe_repository.list_by_profile(profile_id, str(category)) + candidates = self._list_category_candidates(profile_id, str(category)) if not candidates: missing_categories.append(str(category)) continue scored_candidates = [] for index, item in enumerate(candidates): - material = self.material_repository.get_material(item.material_id) + material = self._get_catalog_material(item.material_id) if material is None or material.recognition_status != "confirmed": continue score, breakdown = _score_candidate(item, material, context) @@ -219,7 +238,7 @@ class WardrobeService: missing_categories.append(str(category)) continue score, _order, item, material, breakdown = max(scored_candidates, key=lambda candidate: (candidate[0], candidate[1])) - self.wardrobe_repository.mark_used(item.wardrobe_item_id) + self._repository_for_item(item).mark_used(item.wardrobe_item_id) selected.append( { "wardrobe_item_id": item.wardrobe_item_id, @@ -243,6 +262,7 @@ class WardrobeService: "usage_count": item.usage_count, "score": score, "score_breakdown": breakdown, + "library_kind": item.library_kind, **( material_options.get(material.material_id) if isinstance(material_options.get(material.material_id), dict) @@ -300,6 +320,41 @@ class WardrobeService: raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "profile not found", {"profile_id": profile_id}) return profile + def _get_catalog_material(self, material_id: str): + if self.material_catalog is not None: + return self.material_catalog.get_material(material_id) + return self.material_repository.get_material(material_id) + + def _repository_for_material_id(self, material_id: str) -> WardrobeRepository: + if ( + self.advanced_wardrobe_repository is not None + and self.material_catalog is not None + and str(material_id or "").startswith("advmat_") + ): + return self.advanced_wardrobe_repository + return self.wardrobe_repository + + def _repository_for_item(self, item: WardrobeItem) -> WardrobeRepository: + if item.library_kind == "advanced" and self.advanced_wardrobe_repository is not None: + return self.advanced_wardrobe_repository + return self.wardrobe_repository + + def _find_wardrobe_item(self, wardrobe_item_id: str) -> tuple[WardrobeRepository, WardrobeItem | None]: + standard = self.wardrobe_repository.get(wardrobe_item_id) + if standard is not None: + return self.wardrobe_repository, standard + if self.advanced_wardrobe_repository is not None: + advanced = self.advanced_wardrobe_repository.get(wardrobe_item_id) + if advanced is not None: + return self.advanced_wardrobe_repository, advanced + return self.wardrobe_repository, None + + def _list_category_candidates(self, profile_id: str, category: str) -> list[WardrobeItem]: + candidates = self.wardrobe_repository.list_by_profile(profile_id, category) + if self.advanced_wardrobe_repository is not None: + candidates.extend(self.advanced_wardrobe_repository.list_by_profile(profile_id, category)) + return candidates + def new_wardrobe_item_id() -> str: return f"wardrobe_{uuid4().hex}" @@ -358,7 +413,7 @@ def _match_context(payload: dict[str, Any]) -> dict[str, Any]: } -def _score_candidate(item: WardrobeItem, material, context: dict[str, Any]) -> tuple[int, dict[str, int]]: +def _score_candidate(item: WardrobeItem, material, context: dict[str, Any]) -> tuple[float, dict[str, float]]: item_terms = _text_set(item.tags) | _text_set(material.tags) | _words(material.display_name) | _words(material.prompt) requested_tags = context["requested_tags"] tag_overlap = len(item_terms & requested_tags) @@ -371,6 +426,9 @@ def _score_candidate(item: WardrobeItem, material, context: dict[str, Any]) -> t "prompt_hits": prompt_hits * 3, "season": 12 if context["season"] and _optional_lower(item.season) == context["season"] else 0, "style": 12 if context["style"] and _optional_lower(item.style) == context["style"] else 0, + "advanced_verified": ADVANCED_VERIFIED_PRIORITY_BONUS + if is_trusted_advanced_metadata(getattr(material, "metadata", None)) + else 0, } return sum(breakdown.values()), breakdown diff --git a/backend/services/workflow_material_snapshot_service.py b/backend/services/workflow_material_snapshot_service.py index 172ab99..afe7e08 100644 --- a/backend/services/workflow_material_snapshot_service.py +++ b/backend/services/workflow_material_snapshot_service.py @@ -10,6 +10,7 @@ from typing import Any from urllib.parse import urlsplit from backend.dto.common import ApiError, ErrorCode +from backend.services.material_catalog_resolver import MaterialCatalogResolver, is_trusted_advanced_metadata from database.repositories.material_repository import MaterialRepository from database.repositories.workflow_repository import WorkflowRepository @@ -19,6 +20,7 @@ _SAFE_MATERIAL_METADATA_KEYS = frozenset( { "normalized_asset_profile", "generation_capsule", + "generation_capsules", "body_slot", "wear_layer", "material_type", @@ -27,6 +29,10 @@ _SAFE_MATERIAL_METADATA_KEYS = frozenset( "user_locked", "stackable", "note", + "library_kind", + "priority_class", + "material_priority", + "verification", } ) @@ -35,7 +41,7 @@ class WorkflowMaterialSnapshotService: def __init__( self, workflows: WorkflowRepository, - materials: MaterialRepository, + materials: MaterialRepository | MaterialCatalogResolver, ): self.workflows = workflows self.materials = materials @@ -94,6 +100,20 @@ class WorkflowMaterialSnapshotService: }, ) image_uri = normalize_persistent_reference_uri(material.image_uri, field="material.image_uri") + raw_metadata = material.metadata if isinstance(material.metadata, dict) else {} + metadata = _safe_material_metadata(raw_metadata) + style_set = ( + raw_metadata.get("style_set") + if is_trusted_advanced_metadata(raw_metadata) and isinstance(raw_metadata.get("style_set"), dict) + else {} + ) + if style_set: + metadata["style_set"] = _plain_value(style_set) + reference_image_uris = [ + normalize_persistent_reference_uri(uri, field="material.metadata.style_set.reference_source_uris") + for uri in _string_list(style_set.get("reference_source_uris"))[:3] + ] + reference_image_uris = list(dict.fromkeys([image_uri, *reference_image_uris]))[:3] category = self.materials.get_category(material.category_id) if material.category_id else None binding = binding_by_material.get(material_id, {}) frozen_materials.append( @@ -103,6 +123,7 @@ class WorkflowMaterialSnapshotService: "category_id": material.category_id, "category_name": category.name if category else None, "image_uri": image_uri, + "reference_image_uris": reference_image_uris, "thumbnail_uri": _optional_persistent_uri(material.thumbnail_uri), "prompt": material.prompt, "negative_prompt": material.negative_prompt, @@ -110,7 +131,7 @@ class WorkflowMaterialSnapshotService: "recognition_status": material.recognition_status, "reference_strength": _plain_value(binding.get("reference_strength")), "target_node_keys": _string_list(binding.get("target_node_keys")), - "metadata": _safe_material_metadata(material.metadata), + "metadata": metadata, "source_updated_at": material.updated_at, } ) @@ -140,7 +161,11 @@ class WorkflowMaterialSnapshotService: "created_at": datetime.now(UTC).isoformat(), "material_ids": [item["material_id"] for item in frozen_materials], "reference_uris": [ - *[item["image_uri"] for item in frozen_materials], + *[ + uri + for item in frozen_materials + for uri in item.get("reference_image_uris", [item["image_uri"]]) + ], *[item["image_uri"] for item in frozen_temporary], ], "prompt_context": [ diff --git a/backend/services/workflow_node_material_service.py b/backend/services/workflow_node_material_service.py index 78f5e6e..fc57afc 100644 --- a/backend/services/workflow_node_material_service.py +++ b/backend/services/workflow_node_material_service.py @@ -20,6 +20,7 @@ from backend.services.material_binding_schema_service import ( NODE_MATERIAL_BINDING_SCHEMA_VERSION, material_bindings_for_node, ) +from backend.services.material_catalog_resolver import MaterialCatalogResolver from backend.services.resource_access_service import ResourceAccessService from backend.services.workflow_material_snapshot_service import ( normalize_persistent_reference_uri, @@ -58,7 +59,7 @@ class WorkflowNodeMaterialService: def __init__( self, workflow_service: WorkflowService, - material_repository: MaterialRepository, + material_repository: MaterialRepository | MaterialCatalogResolver, *, round_repository: WorkflowRoundRepository | None = None, access_service: ResourceAccessService | None = None, @@ -304,6 +305,7 @@ class WorkflowNodeMaterialService: material_source = source.get("material") if isinstance(source.get("material"), dict) else {} strength = _reference_strength(source.get("reference_strength")) colors = _string_list(material.metadata.get("colors")) if isinstance(material.metadata, dict) else [] + catalog_metadata = material.metadata if isinstance(material.metadata, dict) else {} return { "id": str(source.get("id") or f"node_material_{material_id}"), "category": str( @@ -319,6 +321,10 @@ class WorkflowNodeMaterialService: "group": category.name if category is not None else None, "prompt": material.prompt or material_source.get("prompt"), "colors": colors, + "library_kind": catalog_metadata.get("library_kind", "standard"), + "priority_class": catalog_metadata.get("priority_class", "standard"), + "material_priority": catalog_metadata.get("material_priority", 0), + "verification": deepcopy(catalog_metadata.get("verification") or {}), }, "target_stages": [], "target_node_keys": [canonical_gradual_node_key(node.node_key)], diff --git a/config.yaml b/config.yaml index 994403e..445a98a 100644 --- a/config.yaml +++ b/config.yaml @@ -1,7 +1,7 @@ plugin: name: astrbot_plugin_imagestudio display_name: ImageStudio - version: 1.0.20 + version: 1.0.32 features: quick_profile: true @@ -46,6 +46,8 @@ vision: # 按功能分配模型路由。留空时回退到 generation.default_model 或 vision.default_route。 model_assignments: material_recognition: material_vlm + advanced_material_recognition: material_vlm + advanced_material_validation_generation: "" profile_parse: "" persona_split: "" prompt_planning: "" @@ -71,6 +73,20 @@ recognition_prompts: 请先判断图片中素材的准确分类,再尽可能完整地提取所有可见事实,包括物品类型、主色与辅色、材质、纹理、结构、轮廓、图案、裁剪、缝线、褶皱、装饰、配件、状态、视角、光照及可复用的设计特征。不要把无法确认的推测写成事实,并明确区分确定信息与低置信度判断。根据识别结果生成一段细节充分、可直接用于生图且能够保留原素材设计的正向提示词,同时生成用于排除错误类别、错误材质、结构畸变、文字、水印和无关背景的负向提示词。仅返回 JSON,字段必须包含 prompt、negative_prompt、tags、confidence、description;tags 应简短、可检索,并包含分类、颜色、材质和关键设计元素。 category_requirements: [] +# 进阶素材验证图的独立预算守卫。开启后,每次验证(含自动 NSFW +# 回退)都会在调用提供方前检查时间窗口内的任务、图片和估算费用。 +advanced_materials: + cost_budget: + enabled: false + days: 30 + max_task_count: null + max_image_count: null + max_estimated_cost: null + price_key: "" + per_request: 0 + per_image: 0 + per_1k_tokens: 0 + # 提示词转译、内容审核和普通/NSFW 模型动态分流。 # 默认只启用本地规则审核;LLM 转译与成人自动分流必须由管理员明确开启。 prompt_governance: @@ -126,6 +142,7 @@ storage: images_path: data/images thumbnails_path: data/thumbnails materials_path: data/materials + advanced_materials_path: data/advanced_materials styles_path: data/styles archives_path: data/archives temp_path: data/temp diff --git a/core/astrbot_provider_bridge.py b/core/astrbot_provider_bridge.py index 4b39b0d..6e1f3f1 100644 --- a/core/astrbot_provider_bridge.py +++ b/core/astrbot_provider_bridge.py @@ -3,15 +3,19 @@ from __future__ import annotations import asyncio +import base64 import concurrent.futures import json import re from typing import Any, Mapping +from core.image_formats import detect_image_format +from core.storage import VfsStorage from engines.vision_provider import ( VisionProviderError, VisionRecognitionRequest, VisionRecognitionResult, + vision_image_urls, ) @@ -93,6 +97,75 @@ def astrbot_structured_text_callable(route_name: str): return complete +def astrbot_structured_vision_callable( + route_name: str, + *, + storage: VfsStorage | None = None, +): + """Return a generic structured-image reviewer backed by AstrBot. + + Unlike :func:`astrbot_vision_provider`, this adapter does not require the + response to contain a material ``prompt`` field. It is used by generated + image moderation and other JSON-only vision checks. + """ + + route = str(route_name or "").strip() + if not route.startswith("astrbot:"): + return None + provider_id = route.split(":", 1)[1].strip() + provider = _provider_by_id(provider_id) + loop = _runtime_loop + if provider is None or loop is None or loop.is_closed(): + return None + vfs = storage or VfsStorage() + model = str( + _call_text(provider, "get_model") + or _provider_config(provider).get("model") + or _meta_value(provider, "model") + or "" + ).strip() + + def review(request_payload: dict[str, Any]) -> dict[str, Any]: + image = request_payload.get("image") if isinstance(request_payload.get("image"), dict) else {} + uri = str(image.get("image_uri") or image.get("thumbnail_uri") or "").strip() + if uri.startswith("storage://"): + path = vfs.ensure_file(uri) + body = path.read_bytes() + if len(body) > 25 * 1024 * 1024: + raise ValueError("image moderation input exceeds size limit") + image_format = detect_image_format(body) + if image_format is None: + raise ValueError("image moderation input is not a supported image") + uri = f"data:{image_format.mime_type};base64,{base64.b64encode(body).decode('ascii')}" + if not uri.startswith(("data:image/", "http://", "https://")): + raise ValueError("image moderation requires a storage, data, or HTTP image URI") + + async def invoke() -> str: + response = await provider.text_chat( + prompt=json.dumps(request_payload, ensure_ascii=False), + image_urls=[uri], + system_prompt=( + "Review the attached image and return one JSON object only. Follow the requested actions and " + "requirements exactly. Detect age ambiguity, unexpected nudity, terrorism, high-risk violence, " + "extreme gore, and content beyond the allowed request. Never weaken a safety classification." + ), + model=model or None, + ) + return str(getattr(response, "completion_text", "") or "").strip() + + future = asyncio.run_coroutine_threadsafe(invoke(), loop) + try: + text = future.result(timeout=ASTRBOT_VISION_TIMEOUT_SECONDS) + except concurrent.futures.TimeoutError as exc: + future.cancel() + raise RuntimeError("AstrBot structured vision provider timed out") from exc + if not text: + raise ValueError("AstrBot structured vision provider returned an empty response") + return _json_object_from_text(text) + + return review + + def astrbot_vision_provider(route_name: str): """Return a synchronous material-vision adapter backed by AstrBot. @@ -140,7 +213,8 @@ class _AstrBotVisionProvider: self.loop = loop def recognize_material(self, request: VisionRecognitionRequest) -> VisionRecognitionResult: - if not str(request.image_uri or "").startswith(("data:image/", "http://", "https://")): + image_urls = list(vision_image_urls(request)) + if not image_urls: raise VisionProviderError( "AstrBot vision input must be a data or HTTP image URL", provider_id=self.provider_id, @@ -150,7 +224,7 @@ class _AstrBotVisionProvider: async def invoke() -> str: response = await self.provider.text_chat( prompt=_material_user_prompt(request), - image_urls=[request.image_uri], + image_urls=image_urls, system_prompt=_material_system_prompt(request), model=request.model or self.model or None, ) diff --git a/core/config_service.py b/core/config_service.py index 429e08e..06f2646 100644 --- a/core/config_service.py +++ b/core/config_service.py @@ -10,7 +10,7 @@ from core.runtime_paths import resolve_config_path from database.db_helper import load_config_payload -PLUGIN_VERSION = "1.0.20" +PLUGIN_VERSION = "1.0.32" @dataclass(frozen=True) @@ -25,6 +25,7 @@ class StorageConfig: images_path: str = "data/images" thumbnails_path: str = "data/thumbnails" materials_path: str = "data/materials" + advanced_materials_path: str = "data/advanced_materials" styles_path: str = "data/styles" archives_path: str = "data/archives" temp_path: str = "data/temp" @@ -74,6 +75,9 @@ class ConfigService: images_path=str(storage.get("images_path", "data/images")), thumbnails_path=str(storage.get("thumbnails_path", "data/thumbnails")), materials_path=str(storage.get("materials_path", "data/materials")), + advanced_materials_path=str( + storage.get("advanced_materials_path", "data/advanced_materials") + ), styles_path=str(storage.get("styles_path", "data/styles")), archives_path=str(storage.get("archives_path", "data/archives")), temp_path=str(storage.get("temp_path", "data/temp")), diff --git a/core/model_route_chain.py b/core/model_route_chain.py new file mode 100644 index 0000000..5e5f7f7 --- /dev/null +++ b/core/model_route_chain.py @@ -0,0 +1,79 @@ +"""Backward-compatible two-source model route chains. + +The AstrBot configuration schema exposes model assignments as strings. Keep +that stable while allowing each assignment to carry one ImageStudio route and +one AstrBot-hosted fallback route. +""" + +from __future__ import annotations + +import json +from dataclasses import dataclass +from typing import Any + + +ROUTE_CHAIN_PREFIX = "route-chain:" + + +@dataclass(frozen=True) +class ModelRouteChain: + plugin: str = "" + astrbot: str = "" + + @property + def candidates(self) -> tuple[str, ...]: + values: list[str] = [] + for value in (self.plugin, self.astrbot): + route = str(value or "").strip() + if route and route not in values: + values.append(route) + return tuple(values) + + +def parse_model_route_chain(value: Any) -> ModelRouteChain: + route = str(value or "").strip() + if not route: + return ModelRouteChain() + if route.startswith(ROUTE_CHAIN_PREFIX): + try: + payload = json.loads(route[len(ROUTE_CHAIN_PREFIX) :]) + except (TypeError, ValueError, json.JSONDecodeError): + payload = None + if isinstance(payload, dict): + return ModelRouteChain( + plugin=_text(payload.get("plugin")), + astrbot=_astrbot_text(payload.get("astrbot")), + ) + if route.startswith("astrbot:"): + return ModelRouteChain(astrbot=route) + return ModelRouteChain(plugin=route) + + +def encode_model_route_chain(plugin: Any = "", astrbot: Any = "") -> str: + plugin_route = _text(plugin) + astrbot_route = _astrbot_text(astrbot) + if plugin_route and not astrbot_route: + return plugin_route + if astrbot_route and not plugin_route: + return astrbot_route + if not plugin_route and not astrbot_route: + return "" + return ROUTE_CHAIN_PREFIX + json.dumps( + {"plugin": plugin_route, "astrbot": astrbot_route}, + ensure_ascii=False, + separators=(",", ":"), + sort_keys=True, + ) + + +def model_route_candidates(value: Any) -> tuple[str, ...]: + return parse_model_route_chain(value).candidates + + +def _text(value: Any) -> str: + return str(value or "").strip() + + +def _astrbot_text(value: Any) -> str: + route = _text(value) + return route if not route or route.startswith("astrbot:") else "" diff --git a/core/storage.py b/core/storage.py index bbd91a0..07bf818 100644 --- a/core/storage.py +++ b/core/storage.py @@ -148,6 +148,7 @@ def _storage_roots(config: ImageStudioConfig) -> dict[str, str]: "images": config.storage.images_path, "thumbnails": config.storage.thumbnails_path, "materials": config.storage.materials_path, + "advanced_materials": config.storage.advanced_materials_path, "styles": config.storage.styles_path, "archives": config.storage.archives_path, "temp": config.storage.temp_path, diff --git a/database/migrations/0016_advanced_materials.sql b/database/migrations/0016_advanced_materials.sql new file mode 100644 index 0000000..2a7108d --- /dev/null +++ b/database/migrations/0016_advanced_materials.sql @@ -0,0 +1,109 @@ +CREATE TABLE IF NOT EXISTS advanced_material_imports ( + import_id TEXT PRIMARY KEY, + category_id TEXT, + display_name TEXT NOT NULL, + source_image_uri TEXT NOT NULL, + source_thumbnail_uri TEXT, + status TEXT NOT NULL DEFAULT 'pending_recognition', + recognition_prompt TEXT, + recognition_negative_prompt TEXT, + recognition_tags_json TEXT, + recognition_result_json TEXT, + recognition_model_route TEXT, + prompt_revision INTEGER NOT NULL DEFAULT 0, + current_attempt_id TEXT, + accepted_material_id TEXT, + idempotency_key TEXT, + created_by TEXT, + error_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + FOREIGN KEY(category_id) REFERENCES material_categories(category_id) ON DELETE SET NULL +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_material_imports_idempotency + ON advanced_material_imports(idempotency_key) + WHERE idempotency_key IS NOT NULL; + +CREATE INDEX IF NOT EXISTS idx_advanced_material_imports_status + ON advanced_material_imports(status, updated_at); + +CREATE INDEX IF NOT EXISTS idx_advanced_material_imports_category + ON advanced_material_imports(category_id, created_at); + +CREATE TABLE IF NOT EXISTS advanced_material_validation_attempts ( + attempt_id TEXT PRIMARY KEY, + import_id TEXT NOT NULL, + attempt_number INTEGER NOT NULL, + status TEXT NOT NULL DEFAULT 'queued', + adjustment_text TEXT, + prompt TEXT NOT NULL, + negative_prompt TEXT, + model_route TEXT, + provider_id TEXT, + provider_model TEXT, + task_id TEXT, + validation_image_uri TEXT, + validation_thumbnail_uri TEXT, + seed INTEGER, + width INTEGER, + height INTEGER, + usage_json TEXT, + fidelity_score REAL, + decision TEXT, + decision_notes TEXT, + error_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + completed_at TIMESTAMP, + decided_at TIMESTAMP, + FOREIGN KEY(import_id) REFERENCES advanced_material_imports(import_id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES generation_tasks(task_id) ON DELETE SET NULL +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_material_attempts_sequence + ON advanced_material_validation_attempts(import_id, attempt_number); + +CREATE INDEX IF NOT EXISTS idx_advanced_material_attempts_status + ON advanced_material_validation_attempts(status, updated_at); + +CREATE INDEX IF NOT EXISTS idx_advanced_material_attempts_task + ON advanced_material_validation_attempts(task_id); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_material_attempts_one_active + ON advanced_material_validation_attempts(import_id) + WHERE status IN ('queued', 'running'); + +CREATE TABLE IF NOT EXISTS advanced_materials ( + material_id TEXT PRIMARY KEY, + import_id TEXT NOT NULL UNIQUE, + accepted_attempt_id TEXT NOT NULL UNIQUE, + category_id TEXT, + display_name TEXT NOT NULL, + source_image_uri TEXT NOT NULL, + source_thumbnail_uri TEXT, + validation_image_uri TEXT NOT NULL, + validation_thumbnail_uri TEXT, + prompt TEXT NOT NULL, + negative_prompt TEXT, + tags_json TEXT, + priority INTEGER NOT NULL DEFAULT 100, + status TEXT NOT NULL DEFAULT 'active', + capsule_json TEXT, + metadata_json TEXT, + accepted_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + archived_at TIMESTAMP, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + FOREIGN KEY(import_id) REFERENCES advanced_material_imports(import_id) ON DELETE RESTRICT, + FOREIGN KEY(accepted_attempt_id) REFERENCES advanced_material_validation_attempts(attempt_id) ON DELETE RESTRICT, + FOREIGN KEY(category_id) REFERENCES material_categories(category_id) ON DELETE SET NULL +); + +CREATE INDEX IF NOT EXISTS idx_advanced_materials_catalog + ON advanced_materials(status, priority, accepted_at); + +CREATE INDEX IF NOT EXISTS idx_advanced_materials_category + ON advanced_materials(category_id, status, priority, accepted_at); diff --git a/database/migrations/0017_advanced_wardrobe_items.sql b/database/migrations/0017_advanced_wardrobe_items.sql new file mode 100644 index 0000000..21f75aa --- /dev/null +++ b/database/migrations/0017_advanced_wardrobe_items.sql @@ -0,0 +1,22 @@ +CREATE TABLE IF NOT EXISTS advanced_wardrobe_items ( + wardrobe_item_id TEXT PRIMARY KEY, + profile_id TEXT NOT NULL, + material_id TEXT NOT NULL, + wardrobe_category TEXT NOT NULL, + tags_json TEXT, + season TEXT, + style TEXT, + is_favorite INTEGER NOT NULL DEFAULT 0, + usage_count INTEGER NOT NULL DEFAULT 0, + last_used_at TIMESTAMP, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + FOREIGN KEY(profile_id) REFERENCES character_profiles(profile_id) ON DELETE CASCADE, + FOREIGN KEY(material_id) REFERENCES advanced_materials(material_id) ON DELETE CASCADE +); + +CREATE INDEX IF NOT EXISTS idx_advanced_wardrobe_profile + ON advanced_wardrobe_items(profile_id, wardrobe_category); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_wardrobe_profile_material + ON advanced_wardrobe_items(profile_id, material_id, wardrobe_category); diff --git a/database/migrations/0018_advanced_style_sets.sql b/database/migrations/0018_advanced_style_sets.sql new file mode 100644 index 0000000..96e1155 --- /dev/null +++ b/database/migrations/0018_advanced_style_sets.sql @@ -0,0 +1,115 @@ +CREATE TABLE IF NOT EXISTS advanced_style_sources ( + source_id TEXT PRIMARY KEY, + import_id TEXT NOT NULL, + sort_order INTEGER NOT NULL, + is_primary INTEGER NOT NULL DEFAULT 0, + source_image_uri TEXT NOT NULL, + source_thumbnail_uri TEXT, + status TEXT NOT NULL DEFAULT 'queued', + recognition_model_route TEXT, + provider_id TEXT, + provider_model TEXT, + task_id TEXT, + recognition_prompt TEXT, + recognition_negative_prompt TEXT, + recognition_tags_json TEXT, + recognition_result_json TEXT, + error_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + completed_at TIMESTAMP, + excluded_at TIMESTAMP, + FOREIGN KEY(import_id) REFERENCES advanced_material_imports(import_id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES generation_tasks(task_id) ON DELETE SET NULL +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_style_sources_order + ON advanced_style_sources(import_id, sort_order); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_style_sources_one_primary + ON advanced_style_sources(import_id) + WHERE is_primary = 1; + +CREATE INDEX IF NOT EXISTS idx_advanced_style_sources_status + ON advanced_style_sources(import_id, status, updated_at); + +CREATE INDEX IF NOT EXISTS idx_advanced_style_sources_task + ON advanced_style_sources(task_id); + +CREATE TABLE IF NOT EXISTS advanced_style_consensus_runs ( + consensus_id TEXT PRIMARY KEY, + import_id TEXT NOT NULL, + revision INTEGER NOT NULL, + status TEXT NOT NULL DEFAULT 'queued', + task_id TEXT, + model_route TEXT, + provider_id TEXT, + provider_model TEXT, + source_ids_json TEXT, + prompt TEXT, + negative_prompt TEXT, + tags_json TEXT, + result_json TEXT, + error_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + completed_at TIMESTAMP, + FOREIGN KEY(import_id) REFERENCES advanced_material_imports(import_id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES generation_tasks(task_id) ON DELETE SET NULL +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_style_consensus_revision + ON advanced_style_consensus_runs(import_id, revision); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_style_consensus_one_active + ON advanced_style_consensus_runs(import_id) + WHERE status IN ('queued', 'running'); + +CREATE INDEX IF NOT EXISTS idx_advanced_style_consensus_task + ON advanced_style_consensus_runs(task_id); + +CREATE TABLE IF NOT EXISTS advanced_style_validation_cases ( + case_id TEXT PRIMARY KEY, + attempt_id TEXT NOT NULL, + import_id TEXT NOT NULL, + case_key TEXT NOT NULL, + sort_order INTEGER NOT NULL, + status TEXT NOT NULL DEFAULT 'queued', + task_id TEXT, + content_prompt TEXT NOT NULL, + final_prompt TEXT NOT NULL, + negative_prompt TEXT, + model_route TEXT, + provider_id TEXT, + provider_model TEXT, + seed INTEGER, + width INTEGER, + height INTEGER, + validation_image_uri TEXT, + validation_thumbnail_uri TEXT, + usage_json TEXT, + style_review_json TEXT, + fidelity_score REAL, + error_json TEXT, + metadata_json TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + completed_at TIMESTAMP, + FOREIGN KEY(attempt_id) REFERENCES advanced_material_validation_attempts(attempt_id) ON DELETE CASCADE, + FOREIGN KEY(import_id) REFERENCES advanced_material_imports(import_id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES generation_tasks(task_id) ON DELETE SET NULL +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_style_validation_case_key + ON advanced_style_validation_cases(attempt_id, case_key); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_advanced_style_validation_case_order + ON advanced_style_validation_cases(attempt_id, sort_order); + +CREATE INDEX IF NOT EXISTS idx_advanced_style_validation_case_status + ON advanced_style_validation_cases(import_id, attempt_id, status, updated_at); + +CREATE INDEX IF NOT EXISTS idx_advanced_style_validation_case_task + ON advanced_style_validation_cases(task_id); diff --git a/database/models.py b/database/models.py index eac5611..664f46a 100644 --- a/database/models.py +++ b/database/models.py @@ -232,6 +232,161 @@ TABLES: tuple[TableSpec, ...] = ( ColumnSpec("recognition_status", nullable=False), ), ), + TableSpec( + "advanced_material_imports", + "import_id", + ( + ColumnSpec("import_id", nullable=False), + ColumnSpec("category_id"), + ColumnSpec("display_name", nullable=False), + ColumnSpec("source_image_uri", nullable=False), + ColumnSpec("source_thumbnail_uri"), + ColumnSpec("status", nullable=False), + ColumnSpec("recognition_prompt"), + ColumnSpec("recognition_negative_prompt"), + ColumnSpec("recognition_tags_json"), + ColumnSpec("recognition_result_json"), + ColumnSpec("recognition_model_route"), + ColumnSpec("prompt_revision", nullable=False), + ColumnSpec("current_attempt_id"), + ColumnSpec("accepted_material_id"), + ColumnSpec("idempotency_key"), + ColumnSpec("created_by"), + ColumnSpec("error_json"), + ColumnSpec("metadata_json"), + ), + ), + TableSpec( + "advanced_material_validation_attempts", + "attempt_id", + ( + ColumnSpec("attempt_id", nullable=False), + ColumnSpec("import_id", nullable=False), + ColumnSpec("attempt_number", nullable=False), + ColumnSpec("status", nullable=False), + ColumnSpec("adjustment_text"), + ColumnSpec("prompt", nullable=False), + ColumnSpec("negative_prompt"), + ColumnSpec("model_route"), + ColumnSpec("provider_id"), + ColumnSpec("provider_model"), + ColumnSpec("task_id"), + ColumnSpec("validation_image_uri"), + ColumnSpec("validation_thumbnail_uri"), + ColumnSpec("seed"), + ColumnSpec("width"), + ColumnSpec("height"), + ColumnSpec("usage_json"), + ColumnSpec("fidelity_score"), + ColumnSpec("decision"), + ColumnSpec("decision_notes"), + ColumnSpec("error_json"), + ColumnSpec("metadata_json"), + ColumnSpec("completed_at"), + ColumnSpec("decided_at"), + ), + ), + TableSpec( + "advanced_materials", + "material_id", + ( + ColumnSpec("material_id", nullable=False), + ColumnSpec("import_id", nullable=False), + ColumnSpec("accepted_attempt_id", nullable=False), + ColumnSpec("category_id"), + ColumnSpec("display_name", nullable=False), + ColumnSpec("source_image_uri", nullable=False), + ColumnSpec("source_thumbnail_uri"), + ColumnSpec("validation_image_uri", nullable=False), + ColumnSpec("validation_thumbnail_uri"), + ColumnSpec("prompt", nullable=False), + ColumnSpec("negative_prompt"), + ColumnSpec("tags_json"), + ColumnSpec("priority", nullable=False), + ColumnSpec("status", nullable=False), + ColumnSpec("capsule_json"), + ColumnSpec("metadata_json"), + ColumnSpec("accepted_at", nullable=False), + ColumnSpec("archived_at"), + ), + ), + TableSpec( + "advanced_style_sources", + "source_id", + ( + ColumnSpec("source_id", nullable=False), + ColumnSpec("import_id", nullable=False), + ColumnSpec("sort_order", nullable=False), + ColumnSpec("is_primary", nullable=False), + ColumnSpec("source_image_uri", nullable=False), + ColumnSpec("source_thumbnail_uri"), + ColumnSpec("status", nullable=False), + ColumnSpec("recognition_model_route"), + ColumnSpec("provider_id"), + ColumnSpec("provider_model"), + ColumnSpec("task_id"), + ColumnSpec("recognition_prompt"), + ColumnSpec("recognition_negative_prompt"), + ColumnSpec("recognition_tags_json"), + ColumnSpec("recognition_result_json"), + ColumnSpec("error_json"), + ColumnSpec("metadata_json"), + ColumnSpec("completed_at"), + ColumnSpec("excluded_at"), + ), + ), + TableSpec( + "advanced_style_consensus_runs", + "consensus_id", + ( + ColumnSpec("consensus_id", nullable=False), + ColumnSpec("import_id", nullable=False), + ColumnSpec("revision", nullable=False), + ColumnSpec("status", nullable=False), + ColumnSpec("task_id"), + ColumnSpec("model_route"), + ColumnSpec("provider_id"), + ColumnSpec("provider_model"), + ColumnSpec("source_ids_json"), + ColumnSpec("prompt"), + ColumnSpec("negative_prompt"), + ColumnSpec("tags_json"), + ColumnSpec("result_json"), + ColumnSpec("error_json"), + ColumnSpec("metadata_json"), + ColumnSpec("completed_at"), + ), + ), + TableSpec( + "advanced_style_validation_cases", + "case_id", + ( + ColumnSpec("case_id", nullable=False), + ColumnSpec("attempt_id", nullable=False), + ColumnSpec("import_id", nullable=False), + ColumnSpec("case_key", nullable=False), + ColumnSpec("sort_order", nullable=False), + ColumnSpec("status", nullable=False), + ColumnSpec("task_id"), + ColumnSpec("content_prompt", nullable=False), + ColumnSpec("final_prompt", nullable=False), + ColumnSpec("negative_prompt"), + ColumnSpec("model_route"), + ColumnSpec("provider_id"), + ColumnSpec("provider_model"), + ColumnSpec("seed"), + ColumnSpec("width"), + ColumnSpec("height"), + ColumnSpec("validation_image_uri"), + ColumnSpec("validation_thumbnail_uri"), + ColumnSpec("usage_json"), + ColumnSpec("style_review_json"), + ColumnSpec("fidelity_score"), + ColumnSpec("error_json"), + ColumnSpec("metadata_json"), + ColumnSpec("completed_at"), + ), + ), TableSpec( "audit_logs", "audit_id", @@ -269,6 +424,22 @@ TABLES: tuple[TableSpec, ...] = ( ColumnSpec("last_used_at"), ), ), + TableSpec( + "advanced_wardrobe_items", + "wardrobe_item_id", + ( + ColumnSpec("wardrobe_item_id", nullable=False), + ColumnSpec("profile_id", nullable=False), + ColumnSpec("material_id", nullable=False), + ColumnSpec("wardrobe_category", nullable=False), + ColumnSpec("tags_json"), + ColumnSpec("season"), + ColumnSpec("style"), + ColumnSpec("is_favorite", nullable=False), + ColumnSpec("usage_count", nullable=False), + ColumnSpec("last_used_at"), + ), + ), TableSpec( "integration_logs", "integration_log_id", diff --git a/database/repositories/advanced_material_repository.py b/database/repositories/advanced_material_repository.py new file mode 100644 index 0000000..927ae68 --- /dev/null +++ b/database/repositories/advanced_material_repository.py @@ -0,0 +1,2123 @@ +"""Persistence for isolated advanced-material imports and validation attempts.""" + +from __future__ import annotations + +import json +from typing import Any +from uuid import uuid4 + +from backend.dto.advanced_material_dto import ( + AdvancedMaterial, + AdvancedMaterialImport, + AdvancedMaterialValidationAttempt, + AdvancedStyleConsensusRun, + AdvancedStyleSource, + AdvancedStyleValidationCase, +) +from database.db_helper import Database + + +IMPORT_COLUMNS = """ + import_id, + category_id, + display_name, + source_image_uri, + source_thumbnail_uri, + status, + recognition_prompt, + recognition_negative_prompt, + recognition_tags_json, + recognition_result_json, + recognition_model_route, + prompt_revision, + current_attempt_id, + accepted_material_id, + idempotency_key, + created_by, + error_json, + metadata_json, + created_at, + updated_at +""" + +ATTEMPT_COLUMNS = """ + attempt_id, + import_id, + attempt_number, + status, + adjustment_text, + prompt, + negative_prompt, + model_route, + provider_id, + provider_model, + task_id, + validation_image_uri, + validation_thumbnail_uri, + seed, + width, + height, + usage_json, + fidelity_score, + decision, + decision_notes, + error_json, + metadata_json, + created_at, + updated_at, + completed_at, + decided_at +""" + +MATERIAL_COLUMNS = """ + material_id, + import_id, + accepted_attempt_id, + category_id, + display_name, + source_image_uri, + source_thumbnail_uri, + validation_image_uri, + validation_thumbnail_uri, + prompt, + negative_prompt, + tags_json, + priority, + status, + capsule_json, + metadata_json, + accepted_at, + archived_at, + created_at, + updated_at +""" + +STYLE_SOURCE_COLUMNS = """ + source_id, + import_id, + sort_order, + is_primary, + source_image_uri, + source_thumbnail_uri, + status, + recognition_model_route, + provider_id, + provider_model, + task_id, + recognition_prompt, + recognition_negative_prompt, + recognition_tags_json, + recognition_result_json, + error_json, + metadata_json, + created_at, + updated_at, + completed_at, + excluded_at +""" + +STYLE_CONSENSUS_COLUMNS = """ + consensus_id, + import_id, + revision, + status, + task_id, + model_route, + provider_id, + provider_model, + source_ids_json, + prompt, + negative_prompt, + tags_json, + result_json, + error_json, + metadata_json, + created_at, + updated_at, + completed_at +""" + +STYLE_VALIDATION_CASE_COLUMNS = """ + case_id, + attempt_id, + import_id, + case_key, + sort_order, + status, + task_id, + content_prompt, + final_prompt, + negative_prompt, + model_route, + provider_id, + provider_model, + seed, + width, + height, + validation_image_uri, + validation_thumbnail_uri, + usage_json, + style_review_json, + fidelity_score, + error_json, + metadata_json, + created_at, + updated_at, + completed_at +""" + + +class AdvancedMaterialRepository: + def __init__(self, database: Database): + self.database = database + + @property + def placeholder(self) -> str: + return self.database._placeholder + + def create_import(self, payload: dict[str, Any]) -> AdvancedMaterialImport: + import_id = _payload_id(payload, "import_id", "advimp") + placeholder = self.placeholder + conn = self.database.connect() + try: + conn.execute( + f""" + INSERT INTO advanced_material_imports ( + import_id, category_id, display_name, source_image_uri, + source_thumbnail_uri, status, recognition_prompt, + recognition_negative_prompt, recognition_tags_json, + recognition_result_json, recognition_model_route, + prompt_revision, current_attempt_id, accepted_material_id, + idempotency_key, created_by, error_json, metadata_json + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder} + ) + """, + ( + import_id, + payload.get("category_id"), + str(payload["display_name"]), + str(payload["source_image_uri"]), + payload.get("source_thumbnail_uri"), + payload.get("status", "pending_recognition"), + payload.get("recognition_prompt"), + payload.get("recognition_negative_prompt"), + _json_or_none(payload.get("recognition_tags") or []), + _json_or_none(payload.get("recognition_result")), + payload.get("recognition_model_route"), + int(payload.get("prompt_revision", 0) or 0), + payload.get("current_attempt_id"), + payload.get("accepted_material_id"), + payload.get("idempotency_key"), + payload.get("created_by"), + _json_or_none(payload.get("error")), + _json_or_none(payload.get("metadata")), + ), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + created = self.get_import(import_id) + if created is None: + raise RuntimeError("advanced material import was inserted but could not be read back") + return created + + def create_style_import_with_sources( + self, + import_payload: dict[str, Any], + source_payloads: list[dict[str, Any]], + ) -> tuple[AdvancedMaterialImport, list[AdvancedStyleSource]]: + """Atomically persist a 2-8 image style-set draft and all source rows.""" + + if not 2 <= len(source_payloads) <= 8: + raise ValueError("advanced style sets require between two and eight sources") + import_id = _payload_id(import_payload, "import_id", "advimp") + source_ids = [_payload_id(item, "source_id", "advsrc") for item in source_payloads] + sort_orders = [int(item.get("sort_order", index)) for index, item in enumerate(source_payloads)] + primary_flags = [bool(item.get("is_primary")) for item in source_payloads] + if len(set(source_ids)) != len(source_ids): + raise ValueError("advanced style source IDs must be unique") + if len(set(sort_orders)) != len(sort_orders): + raise ValueError("advanced style source sort orders must be unique") + if sum(primary_flags) != 1: + raise ValueError("advanced style sets require exactly one primary source") + placeholder = self.placeholder + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + conn.execute( + f""" + INSERT INTO advanced_material_imports ( + import_id, category_id, display_name, source_image_uri, + source_thumbnail_uri, status, recognition_prompt, + recognition_negative_prompt, recognition_tags_json, + recognition_result_json, recognition_model_route, + prompt_revision, current_attempt_id, accepted_material_id, + idempotency_key, created_by, error_json, metadata_json + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder} + ) + """, + ( + import_id, + import_payload.get("category_id"), + str(import_payload["display_name"]), + str(import_payload["source_image_uri"]), + import_payload.get("source_thumbnail_uri"), + import_payload.get("status", "style_source_recognition_queued"), + import_payload.get("recognition_prompt"), + import_payload.get("recognition_negative_prompt"), + _json_or_none(import_payload.get("recognition_tags") or []), + _json_or_none(import_payload.get("recognition_result")), + import_payload.get("recognition_model_route"), + int(import_payload.get("prompt_revision", 0) or 0), + import_payload.get("current_attempt_id"), + import_payload.get("accepted_material_id"), + import_payload.get("idempotency_key"), + import_payload.get("created_by"), + _json_or_none(import_payload.get("error")), + _json_or_none(import_payload.get("metadata")), + ), + ) + for index, source_payload in enumerate(source_payloads): + conn.execute( + f""" + INSERT INTO advanced_style_sources ( + source_id, import_id, sort_order, is_primary, + source_image_uri, source_thumbnail_uri, status, + recognition_model_route, provider_id, provider_model, + task_id, recognition_prompt, recognition_negative_prompt, + recognition_tags_json, recognition_result_json, error_json, + metadata_json, completed_at, excluded_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder} + ) + """, + ( + source_ids[index], + import_id, + sort_orders[index], + 1 if primary_flags[index] else 0, + str(source_payload["source_image_uri"]), + source_payload.get("source_thumbnail_uri"), + source_payload.get("status", "queued"), + source_payload.get("recognition_model_route"), + source_payload.get("provider_id"), + source_payload.get("provider_model"), + source_payload.get("task_id"), + source_payload.get("recognition_prompt"), + source_payload.get("recognition_negative_prompt"), + _json_or_none(source_payload.get("recognition_tags") or []), + _json_or_none(source_payload.get("recognition_result")), + _json_or_none(source_payload.get("error")), + _json_or_none(source_payload.get("metadata")), + source_payload.get("completed_at"), + source_payload.get("excluded_at"), + ), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + record = self.get_import(import_id) + sources = self.list_style_sources(import_id) + if record is None or len(sources) != len(source_payloads): + raise RuntimeError("advanced style import was not readable after atomic creation") + return record, sources + + def get_import(self, import_id: str) -> AdvancedMaterialImport | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE import_id = {self.placeholder}", + (import_id,), + ).fetchone() + finally: + conn.close() + return _row_to_import(row) if row else None + + def get_import_by_idempotency_key(self, idempotency_key: str) -> AdvancedMaterialImport | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE idempotency_key = {self.placeholder}", + (idempotency_key,), + ).fetchone() + finally: + conn.close() + return _row_to_import(row) if row else None + + def update_import(self, import_id: str, payload: dict[str, Any]) -> AdvancedMaterialImport | None: + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "category_id": "category_id", + "display_name": "display_name", + "source_image_uri": "source_image_uri", + "source_thumbnail_uri": "source_thumbnail_uri", + "status": "status", + "recognition_prompt": "recognition_prompt", + "recognition_negative_prompt": "recognition_negative_prompt", + "recognition_tags": "recognition_tags_json", + "recognition_result": "recognition_result_json", + "recognition_model_route": "recognition_model_route", + "prompt_revision": "prompt_revision", + "current_attempt_id": "current_attempt_id", + "accepted_material_id": "accepted_material_id", + "idempotency_key": "idempotency_key", + "created_by": "created_by", + "error": "error_json", + "metadata": "metadata_json", + }, + ) + if not assignments: + return self.get_import(import_id) + assignments.append("updated_at = CURRENT_TIMESTAMP") + params.append(import_id) + conn = self.database.connect() + try: + conn.execute( + f"UPDATE advanced_material_imports SET {', '.join(assignments)} WHERE import_id = {self.placeholder}", + tuple(params), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_import(import_id) + + def update_import_if_status( + self, + import_id: str, + expected_statuses: set[str] | tuple[str, ...] | list[str], + payload: dict[str, Any], + ) -> AdvancedMaterialImport | None: + """CAS-update an import so cancellation cannot be overwritten.""" + + statuses = tuple(sorted({str(item).strip() for item in expected_statuses if str(item).strip()})) + if not statuses: + return None + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "category_id": "category_id", + "display_name": "display_name", + "source_image_uri": "source_image_uri", + "source_thumbnail_uri": "source_thumbnail_uri", + "status": "status", + "recognition_prompt": "recognition_prompt", + "recognition_negative_prompt": "recognition_negative_prompt", + "recognition_tags": "recognition_tags_json", + "recognition_result": "recognition_result_json", + "recognition_model_route": "recognition_model_route", + "prompt_revision": "prompt_revision", + "current_attempt_id": "current_attempt_id", + "accepted_material_id": "accepted_material_id", + "idempotency_key": "idempotency_key", + "created_by": "created_by", + "error": "error_json", + "metadata": "metadata_json", + }, + ) + if not assignments: + current = self.get_import(import_id) + return current if current and current.status in statuses else None + placeholder = self.placeholder + assignments.append("updated_at = CURRENT_TIMESTAMP") + status_placeholders = ", ".join(placeholder for _ in statuses) + params.extend((import_id, *statuses)) + conn = self.database.connect() + try: + cursor = conn.execute( + f""" + UPDATE advanced_material_imports + SET {', '.join(assignments)} + WHERE import_id = {placeholder} + AND status IN ({status_placeholders}) + """, + tuple(params), + ) + changed = int(cursor.rowcount or 0) > 0 + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_import(import_id) if changed else None + + def list_imports( + self, + *, + status: str | None = None, + category_id: str | None = None, + keyword: str | None = None, + created_by: str | None = None, + page: int = 1, + page_size: int = 30, + ) -> tuple[list[AdvancedMaterialImport], int]: + where: list[str] = [] + params: list[Any] = [] + placeholder = self.placeholder + if status: + where.append(f"status = {placeholder}") + params.append(status) + if category_id: + where.append(f"category_id = {placeholder}") + params.append(category_id) + if created_by: + where.append(f"created_by = {placeholder}") + params.append(created_by) + if keyword: + where.append( + f"(display_name LIKE {placeholder} OR recognition_prompt LIKE {placeholder})" + ) + like = f"%{keyword}%" + params.extend((like, like)) + where_clause = f"WHERE {' AND '.join(where)}" if where else "" + normalized_page = _page(page) + normalized_page_size = _page_size(page_size) + offset = (normalized_page - 1) * normalized_page_size + conn = self.database.connect() + try: + total_row = conn.execute( + f"SELECT COUNT(*) AS total FROM advanced_material_imports {where_clause}", + tuple(params), + ).fetchone() + rows = conn.execute( + f""" + SELECT {IMPORT_COLUMNS} + FROM advanced_material_imports + {where_clause} + ORDER BY created_at DESC, import_id DESC + LIMIT {placeholder} OFFSET {placeholder} + """, + tuple(params + [normalized_page_size, offset]), + ).fetchall() + finally: + conn.close() + return [_row_to_import(row) for row in rows], int(total_row["total"] if total_row else 0) + + def delete_import(self, import_id: str) -> AdvancedMaterialImport | None: + """Delete one unsealed import and all of its cascade-owned children.""" + + placeholder = self.placeholder + lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports " + f"WHERE import_id = {placeholder}{lock}", + (import_id,), + ).fetchone() + if row is None: + return None + record = _row_to_import(row) + material = conn.execute( + f"SELECT material_id FROM advanced_materials WHERE import_id = {placeholder}{lock}", + (import_id,), + ).fetchone() + if record.accepted_material_id or material is not None: + raise ValueError("accepted advanced material imports cannot be deleted") + cursor = conn.execute( + f"DELETE FROM advanced_material_imports WHERE import_id = {placeholder}", + (import_id,), + ) + if int(cursor.rowcount or 0) <= 0: + _rollback(conn) + return None + conn.commit() + return record + except Exception: + _rollback(conn) + raise + finally: + conn.close() + + def create_style_source(self, payload: dict[str, Any]) -> AdvancedStyleSource: + source_id = _payload_id(payload, "source_id", "advsrc") + placeholder = self.placeholder + conn = self.database.connect() + try: + conn.execute( + f""" + INSERT INTO advanced_style_sources ( + source_id, import_id, sort_order, is_primary, + source_image_uri, source_thumbnail_uri, status, + recognition_model_route, provider_id, provider_model, + task_id, recognition_prompt, recognition_negative_prompt, + recognition_tags_json, recognition_result_json, error_json, + metadata_json, completed_at, excluded_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder} + ) + """, + ( + source_id, + str(payload["import_id"]), + int(payload.get("sort_order", 0)), + 1 if bool(payload.get("is_primary")) else 0, + str(payload["source_image_uri"]), + payload.get("source_thumbnail_uri"), + payload.get("status", "queued"), + payload.get("recognition_model_route"), + payload.get("provider_id"), + payload.get("provider_model"), + payload.get("task_id"), + payload.get("recognition_prompt"), + payload.get("recognition_negative_prompt"), + _json_or_none(payload.get("recognition_tags") or []), + _json_or_none(payload.get("recognition_result")), + _json_or_none(payload.get("error")), + _json_or_none(payload.get("metadata")), + payload.get("completed_at"), + payload.get("excluded_at"), + ), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + created = self.get_style_source(source_id) + if created is None: + raise RuntimeError("advanced style source was inserted but could not be read back") + return created + + def get_style_source(self, source_id: str) -> AdvancedStyleSource | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {STYLE_SOURCE_COLUMNS} FROM advanced_style_sources " + f"WHERE source_id = {self.placeholder}", + (source_id,), + ).fetchone() + finally: + conn.close() + return _row_to_style_source(row) if row else None + + def list_style_sources( + self, + import_id: str, + *, + include_excluded: bool = True, + ) -> list[AdvancedStyleSource]: + where = f"import_id = {self.placeholder}" + if not include_excluded: + where += " AND status <> 'excluded'" + conn = self.database.connect() + try: + rows = conn.execute( + f"SELECT {STYLE_SOURCE_COLUMNS} FROM advanced_style_sources " + f"WHERE {where} ORDER BY sort_order ASC, source_id ASC", + (import_id,), + ).fetchall() + finally: + conn.close() + return [_row_to_style_source(row) for row in rows] + + def update_style_source( + self, + source_id: str, + payload: dict[str, Any], + ) -> AdvancedStyleSource | None: + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "sort_order": "sort_order", + "is_primary": "is_primary", + "source_image_uri": "source_image_uri", + "source_thumbnail_uri": "source_thumbnail_uri", + "status": "status", + "recognition_model_route": "recognition_model_route", + "provider_id": "provider_id", + "provider_model": "provider_model", + "task_id": "task_id", + "recognition_prompt": "recognition_prompt", + "recognition_negative_prompt": "recognition_negative_prompt", + "recognition_tags": "recognition_tags_json", + "recognition_result": "recognition_result_json", + "error": "error_json", + "metadata": "metadata_json", + "completed_at": "completed_at", + "excluded_at": "excluded_at", + }, + ) + if not assignments: + return self.get_style_source(source_id) + status = str(payload.get("status") or "").strip() + if status == "succeeded" and "completed_at" not in payload: + assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") + if status == "excluded" and "excluded_at" not in payload: + assignments.append("excluded_at = COALESCE(excluded_at, CURRENT_TIMESTAMP)") + assignments.append("updated_at = CURRENT_TIMESTAMP") + params.append(source_id) + conn = self.database.connect() + try: + conn.execute( + f"UPDATE advanced_style_sources SET {', '.join(assignments)} " + f"WHERE source_id = {self.placeholder}", + tuple(params), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_style_source(source_id) + + def update_style_source_if_status( + self, + source_id: str, + expected_statuses: set[str] | tuple[str, ...] | list[str], + payload: dict[str, Any], + ) -> AdvancedStyleSource | None: + statuses = tuple(sorted({str(item).strip() for item in expected_statuses if str(item).strip()})) + if not statuses: + return None + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "status": "status", + "task_id": "task_id", + "provider_id": "provider_id", + "provider_model": "provider_model", + "recognition_prompt": "recognition_prompt", + "recognition_negative_prompt": "recognition_negative_prompt", + "recognition_tags": "recognition_tags_json", + "recognition_result": "recognition_result_json", + "error": "error_json", + "metadata": "metadata_json", + "completed_at": "completed_at", + "excluded_at": "excluded_at", + }, + ) + if not assignments: + current = self.get_style_source(source_id) + return current if current and current.status in statuses else None + target_status = str(payload.get("status") or "").strip() + if target_status == "succeeded" and "completed_at" not in payload: + assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") + if target_status == "excluded" and "excluded_at" not in payload: + assignments.append("excluded_at = COALESCE(excluded_at, CURRENT_TIMESTAMP)") + assignments.append("updated_at = CURRENT_TIMESTAMP") + placeholders = ", ".join(self.placeholder for _ in statuses) + params.extend((source_id, *statuses)) + conn = self.database.connect() + try: + cursor = conn.execute( + f"UPDATE advanced_style_sources SET {', '.join(assignments)} " + f"WHERE source_id = {self.placeholder} AND status IN ({placeholders})", + tuple(params), + ) + changed = int(cursor.rowcount or 0) > 0 + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_style_source(source_id) if changed else None + + def create_style_consensus_run(self, payload: dict[str, Any]) -> AdvancedStyleConsensusRun: + consensus_id = _payload_id(payload, "consensus_id", "advconsensus") + placeholder = self.placeholder + conn = self.database.connect() + try: + conn.execute( + f""" + INSERT INTO advanced_style_consensus_runs ( + consensus_id, import_id, revision, status, task_id, + model_route, provider_id, provider_model, source_ids_json, + prompt, negative_prompt, tags_json, result_json, error_json, + metadata_json, completed_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder} + ) + """, + ( + consensus_id, + str(payload["import_id"]), + int(payload.get("revision", 0)), + payload.get("status", "queued"), + payload.get("task_id"), + payload.get("model_route"), + payload.get("provider_id"), + payload.get("provider_model"), + _json_or_none(payload.get("source_ids") or []), + payload.get("prompt"), + payload.get("negative_prompt"), + _json_or_none(payload.get("tags") or []), + _json_or_none(payload.get("result")), + _json_or_none(payload.get("error")), + _json_or_none(payload.get("metadata")), + payload.get("completed_at"), + ), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + created = self.get_style_consensus_run(consensus_id) + if created is None: + raise RuntimeError("advanced style consensus was inserted but could not be read back") + return created + + def get_style_consensus_run(self, consensus_id: str) -> AdvancedStyleConsensusRun | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {STYLE_CONSENSUS_COLUMNS} FROM advanced_style_consensus_runs " + f"WHERE consensus_id = {self.placeholder}", + (consensus_id,), + ).fetchone() + finally: + conn.close() + return _row_to_style_consensus(row) if row else None + + def get_latest_style_consensus_run(self, import_id: str) -> AdvancedStyleConsensusRun | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {STYLE_CONSENSUS_COLUMNS} FROM advanced_style_consensus_runs " + f"WHERE import_id = {self.placeholder} ORDER BY revision DESC, created_at DESC LIMIT 1", + (import_id,), + ).fetchone() + finally: + conn.close() + return _row_to_style_consensus(row) if row else None + + def list_style_consensus_runs(self, import_id: str) -> list[AdvancedStyleConsensusRun]: + conn = self.database.connect() + try: + rows = conn.execute( + f"SELECT {STYLE_CONSENSUS_COLUMNS} FROM advanced_style_consensus_runs " + f"WHERE import_id = {self.placeholder} ORDER BY revision DESC, created_at DESC", + (import_id,), + ).fetchall() + finally: + conn.close() + return [_row_to_style_consensus(row) for row in rows] + + def update_style_consensus_run( + self, + consensus_id: str, + payload: dict[str, Any], + *, + expected_statuses: set[str] | tuple[str, ...] | list[str] | None = None, + ) -> AdvancedStyleConsensusRun | None: + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "status": "status", + "task_id": "task_id", + "model_route": "model_route", + "provider_id": "provider_id", + "provider_model": "provider_model", + "source_ids": "source_ids_json", + "prompt": "prompt", + "negative_prompt": "negative_prompt", + "tags": "tags_json", + "result": "result_json", + "error": "error_json", + "metadata": "metadata_json", + "completed_at": "completed_at", + }, + ) + if not assignments: + return self.get_style_consensus_run(consensus_id) + status = str(payload.get("status") or "").strip() + if status == "succeeded" and "completed_at" not in payload: + assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") + assignments.append("updated_at = CURRENT_TIMESTAMP") + where = f"consensus_id = {self.placeholder}" + params.append(consensus_id) + statuses = tuple(sorted({str(item).strip() for item in (expected_statuses or ()) if str(item).strip()})) + if statuses: + where += f" AND status IN ({', '.join(self.placeholder for _ in statuses)})" + params.extend(statuses) + conn = self.database.connect() + try: + cursor = conn.execute( + f"UPDATE advanced_style_consensus_runs SET {', '.join(assignments)} WHERE {where}", + tuple(params), + ) + changed = int(cursor.rowcount or 0) > 0 + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_style_consensus_run(consensus_id) if changed else None + + def create_attempt(self, payload: dict[str, Any]) -> AdvancedMaterialValidationAttempt: + attempt_id = _payload_id(payload, "attempt_id", "advattempt") + import_id = str(payload["import_id"]) + placeholder = self.placeholder + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + import_row = conn.execute( + "SELECT import_id, status, accepted_material_id " + f"FROM advanced_material_imports WHERE import_id = {placeholder}" + + (" FOR UPDATE" if self.database.backend == "postgresql" else ""), + (import_id,), + ).fetchone() + if import_row is None: + raise ValueError("advanced material import does not exist") + if str(import_row["status"] or "") in {"accepted", "archived", "cancelled"}: + raise ValueError("advanced material import no longer accepts validation attempts") + if import_row["accepted_material_id"]: + raise ValueError("advanced material import has already been accepted") + # Reserve the sequence under the same import lock. Callers may + # display a predicted number, but persistence remains the source + # of truth so two simultaneous retries cannot claim one round. + sequence_row = conn.execute( + f""" + SELECT COALESCE(MAX(attempt_number), 0) + 1 AS next_number + FROM advanced_material_validation_attempts + WHERE import_id = {placeholder} + """, + (import_id,), + ).fetchone() + attempt_number = int(sequence_row["next_number"] if sequence_row else 1) + conn.execute( + f""" + INSERT INTO advanced_material_validation_attempts ( + attempt_id, import_id, attempt_number, status, + adjustment_text, prompt, negative_prompt, model_route, + provider_id, provider_model, task_id, validation_image_uri, + validation_thumbnail_uri, seed, width, height, usage_json, + fidelity_score, decision, decision_notes, error_json, metadata_json, + completed_at, decided_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder} + ) + """, + ( + attempt_id, + import_id, + int(attempt_number), + payload.get("status", "queued"), + payload.get("adjustment_text"), + str(payload["prompt"]), + payload.get("negative_prompt"), + payload.get("model_route"), + payload.get("provider_id"), + payload.get("provider_model"), + payload.get("task_id"), + payload.get("validation_image_uri"), + payload.get("validation_thumbnail_uri"), + _optional_int(payload.get("seed")), + _optional_int(payload.get("width")), + _optional_int(payload.get("height")), + _json_or_none(payload.get("usage")), + _optional_float(payload.get("fidelity_score")), + payload.get("decision"), + payload.get("decision_notes"), + _json_or_none(payload.get("error")), + _json_or_none(payload.get("metadata")), + payload.get("completed_at"), + payload.get("decided_at"), + ), + ) + conn.execute( + f""" + UPDATE advanced_material_imports + SET current_attempt_id = {placeholder}, error_json = NULL, + updated_at = CURRENT_TIMESTAMP + WHERE import_id = {placeholder} + """, + (attempt_id, import_id), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + created = self.get_attempt(attempt_id) + if created is None: + raise RuntimeError("advanced material validation attempt was inserted but could not be read back") + return created + + def create_style_validation_batch( + self, + attempt_payload: dict[str, Any], + case_payloads: list[dict[str, Any]], + ) -> tuple[AdvancedMaterialValidationAttempt, list[AdvancedStyleValidationCase]]: + """Atomically create one compatibility attempt and its three validation cases.""" + + if len(case_payloads) != 3: + raise ValueError("advanced style validation requires exactly three cases") + case_keys = [str(item.get("case_key") or "").strip() for item in case_payloads] + if any(not item for item in case_keys) or len(set(case_keys)) != 3: + raise ValueError("advanced style validation case keys must be non-empty and unique") + attempt_id = _payload_id(attempt_payload, "attempt_id", "advattempt") + import_id = str(attempt_payload["import_id"]) + placeholder = self.placeholder + case_ids: list[str] = [] + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" + import_row = conn.execute( + "SELECT import_id, status, accepted_material_id " + f"FROM advanced_material_imports WHERE import_id = {placeholder}{lock}", + (import_id,), + ).fetchone() + if import_row is None: + raise ValueError("advanced material import does not exist") + if str(import_row["status"] or "") in {"accepted", "archived", "cancelled"}: + raise ValueError("advanced material import no longer accepts validation attempts") + if import_row["accepted_material_id"]: + raise ValueError("advanced material import has already been accepted") + sequence_row = conn.execute( + f"SELECT COALESCE(MAX(attempt_number), 0) + 1 AS next_number " + f"FROM advanced_material_validation_attempts WHERE import_id = {placeholder}", + (import_id,), + ).fetchone() + attempt_number = int(sequence_row["next_number"] if sequence_row else 1) + conn.execute( + f""" + INSERT INTO advanced_material_validation_attempts ( + attempt_id, import_id, attempt_number, status, + adjustment_text, prompt, negative_prompt, model_route, + provider_id, provider_model, task_id, validation_image_uri, + validation_thumbnail_uri, seed, width, height, usage_json, + fidelity_score, decision, decision_notes, error_json, metadata_json, + completed_at, decided_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder} + ) + """, + ( + attempt_id, + import_id, + attempt_number, + attempt_payload.get("status", "queued"), + attempt_payload.get("adjustment_text"), + str(attempt_payload["prompt"]), + attempt_payload.get("negative_prompt"), + attempt_payload.get("model_route"), + attempt_payload.get("provider_id"), + attempt_payload.get("provider_model"), + attempt_payload.get("task_id"), + attempt_payload.get("validation_image_uri"), + attempt_payload.get("validation_thumbnail_uri"), + _optional_int(attempt_payload.get("seed")), + _optional_int(attempt_payload.get("width")), + _optional_int(attempt_payload.get("height")), + _json_or_none(attempt_payload.get("usage")), + _optional_float(attempt_payload.get("fidelity_score")), + attempt_payload.get("decision"), + attempt_payload.get("decision_notes"), + _json_or_none(attempt_payload.get("error")), + _json_or_none(attempt_payload.get("metadata")), + attempt_payload.get("completed_at"), + attempt_payload.get("decided_at"), + ), + ) + for index, case_payload in enumerate(case_payloads): + case_id = _payload_id(case_payload, "case_id", "advcase") + case_ids.append(case_id) + conn.execute( + f""" + INSERT INTO advanced_style_validation_cases ( + case_id, attempt_id, import_id, case_key, sort_order, + status, task_id, content_prompt, final_prompt, + negative_prompt, model_route, provider_id, provider_model, + seed, width, height, validation_image_uri, + validation_thumbnail_uri, usage_json, style_review_json, + fidelity_score, error_json, metadata_json, completed_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder} + ) + """, + ( + case_id, + attempt_id, + import_id, + case_keys[index], + int(case_payload.get("sort_order", index)), + case_payload.get("status", "queued"), + case_payload.get("task_id"), + str(case_payload["content_prompt"]), + str(case_payload["final_prompt"]), + case_payload.get("negative_prompt"), + case_payload.get("model_route") or attempt_payload.get("model_route"), + case_payload.get("provider_id"), + case_payload.get("provider_model"), + _optional_int(case_payload.get("seed")), + _optional_int(case_payload.get("width")), + _optional_int(case_payload.get("height")), + case_payload.get("validation_image_uri"), + case_payload.get("validation_thumbnail_uri"), + _json_or_none(case_payload.get("usage")), + _json_or_none(case_payload.get("style_review")), + _optional_float(case_payload.get("fidelity_score")), + _json_or_none(case_payload.get("error")), + _json_or_none(case_payload.get("metadata")), + case_payload.get("completed_at"), + ), + ) + conn.execute( + f"UPDATE advanced_material_imports SET current_attempt_id = {placeholder}, " + f"error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", + (attempt_id, import_id), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + attempt = self.get_attempt(attempt_id) + cases = self.list_style_validation_cases(attempt_id) + if attempt is None or len(cases) != 3: + raise RuntimeError("advanced style validation batch was not readable after creation") + return attempt, cases + + def get_style_validation_case(self, case_id: str) -> AdvancedStyleValidationCase | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {STYLE_VALIDATION_CASE_COLUMNS} FROM advanced_style_validation_cases " + f"WHERE case_id = {self.placeholder}", + (case_id,), + ).fetchone() + finally: + conn.close() + return _row_to_style_validation_case(row) if row else None + + def list_style_validation_cases(self, attempt_id: str) -> list[AdvancedStyleValidationCase]: + conn = self.database.connect() + try: + rows = conn.execute( + f"SELECT {STYLE_VALIDATION_CASE_COLUMNS} FROM advanced_style_validation_cases " + f"WHERE attempt_id = {self.placeholder} ORDER BY sort_order ASC, case_id ASC", + (attempt_id,), + ).fetchall() + finally: + conn.close() + return [_row_to_style_validation_case(row) for row in rows] + + def update_style_validation_case( + self, + case_id: str, + payload: dict[str, Any], + *, + expected_statuses: set[str] | tuple[str, ...] | list[str] | None = None, + ) -> AdvancedStyleValidationCase | None: + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "status": "status", + "task_id": "task_id", + "content_prompt": "content_prompt", + "final_prompt": "final_prompt", + "negative_prompt": "negative_prompt", + "model_route": "model_route", + "provider_id": "provider_id", + "provider_model": "provider_model", + "seed": "seed", + "width": "width", + "height": "height", + "validation_image_uri": "validation_image_uri", + "validation_thumbnail_uri": "validation_thumbnail_uri", + "usage": "usage_json", + "style_review": "style_review_json", + "fidelity_score": "fidelity_score", + "error": "error_json", + "metadata": "metadata_json", + "completed_at": "completed_at", + }, + ) + if not assignments: + return self.get_style_validation_case(case_id) + status = str(payload.get("status") or "").strip() + if status == "succeeded" and "completed_at" not in payload: + assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") + assignments.append("updated_at = CURRENT_TIMESTAMP") + where = f"case_id = {self.placeholder}" + params.append(case_id) + statuses = tuple(sorted({str(item).strip() for item in (expected_statuses or ()) if str(item).strip()})) + if statuses: + where += f" AND status IN ({', '.join(self.placeholder for _ in statuses)})" + params.extend(statuses) + conn = self.database.connect() + try: + cursor = conn.execute( + f"UPDATE advanced_style_validation_cases SET {', '.join(assignments)} WHERE {where}", + tuple(params), + ) + changed = int(cursor.rowcount or 0) > 0 + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_style_validation_case(case_id) if changed else None + + def finalize_style_validation_batch_if_ready( + self, + import_id: str, + attempt_id: str, + ) -> tuple[AdvancedMaterialImport, AdvancedMaterialValidationAttempt, list[AdvancedStyleValidationCase]]: + """Aggregate child cases and publish the compatibility attempt state.""" + + placeholder = self.placeholder + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" + import_row = conn.execute( + f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports " + f"WHERE import_id = {placeholder}{lock}", + (import_id,), + ).fetchone() + attempt_row = conn.execute( + f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts " + f"WHERE attempt_id = {placeholder}{lock}", + (attempt_id,), + ).fetchone() + case_rows = conn.execute( + f"SELECT {STYLE_VALIDATION_CASE_COLUMNS} FROM advanced_style_validation_cases " + f"WHERE attempt_id = {placeholder} ORDER BY sort_order ASC, case_id ASC{lock}", + (attempt_id,), + ).fetchall() + if import_row is None or attempt_row is None or str(attempt_row["import_id"]) != import_id: + raise ValueError("advanced style validation batch does not exist") + if len(case_rows) != 3: + raise ValueError("advanced style validation batch must contain exactly three cases") + statuses = [str(row["status"] or "") for row in case_rows] + if any(status in {"queued", "running"} for status in statuses): + conn.commit() + elif all(status == "succeeded" for status in statuses): + primary = case_rows[0] + metadata = _json_object(attempt_row["metadata_json"]) + metadata["style_validation_case_ids"] = [str(row["case_id"]) for row in case_rows] + conn.execute( + f""" + UPDATE advanced_material_validation_attempts + SET status = 'awaiting_review', + validation_image_uri = {placeholder}, + validation_thumbnail_uri = {placeholder}, + provider_id = {placeholder}, provider_model = {placeholder}, + width = {placeholder}, height = {placeholder}, + metadata_json = {placeholder}, error_json = NULL, + completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP), + updated_at = CURRENT_TIMESTAMP + WHERE attempt_id = {placeholder} + """, + ( + primary["validation_image_uri"], + primary["validation_thumbnail_uri"], + primary["provider_id"], + primary["provider_model"], + primary["width"], + primary["height"], + _json_or_none(metadata), + attempt_id, + ), + ) + conn.execute( + f"UPDATE advanced_material_imports SET status = 'awaiting_review', " + f"current_attempt_id = {placeholder}, error_json = NULL, " + f"updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", + (attempt_id, import_id), + ) + conn.commit() + else: + failed = [str(row["case_id"]) for row in case_rows if str(row["status"] or "") != "succeeded"] + error = {"error_type": "validation_partial_failure", "failed_case_ids": failed} + conn.execute( + f"UPDATE advanced_material_validation_attempts " + f"SET status = 'validation_partial_failed', error_json = {placeholder}, " + f"updated_at = CURRENT_TIMESTAMP WHERE attempt_id = {placeholder}", + (_json_or_none(error), attempt_id), + ) + conn.execute( + f"UPDATE advanced_material_imports SET status = 'validation_partial_failed', " + f"current_attempt_id = {placeholder}, error_json = {placeholder}, " + f"updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", + (attempt_id, _json_or_none(error), import_id), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + record = self.get_import(import_id) + attempt = self.get_attempt(attempt_id) + cases = self.list_style_validation_cases(attempt_id) + if record is None or attempt is None: + raise RuntimeError("advanced style validation batch disappeared after aggregation") + return record, attempt, cases + + def get_attempt(self, attempt_id: str) -> AdvancedMaterialValidationAttempt | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts " + f"WHERE attempt_id = {self.placeholder}", + (attempt_id,), + ).fetchone() + finally: + conn.close() + return _row_to_attempt(row) if row else None + + def update_attempt( + self, + attempt_id: str, + payload: dict[str, Any], + ) -> AdvancedMaterialValidationAttempt | None: + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "status": "status", + "adjustment_text": "adjustment_text", + "prompt": "prompt", + "negative_prompt": "negative_prompt", + "model_route": "model_route", + "provider_id": "provider_id", + "provider_model": "provider_model", + "task_id": "task_id", + "validation_image_uri": "validation_image_uri", + "validation_thumbnail_uri": "validation_thumbnail_uri", + "seed": "seed", + "width": "width", + "height": "height", + "usage": "usage_json", + "fidelity_score": "fidelity_score", + "decision": "decision", + "decision_notes": "decision_notes", + "error": "error_json", + "metadata": "metadata_json", + "completed_at": "completed_at", + "decided_at": "decided_at", + }, + ) + if not assignments: + return self.get_attempt(attempt_id) + target_status = str(payload.get("status") or "").strip() + if ( + target_status in {"awaiting_review", "succeeded", "completed"} + and "completed_at" not in payload + ): + assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") + if target_status in {"accepted", "rejected", "cancelled"} and "decided_at" not in payload: + assignments.append("decided_at = COALESCE(decided_at, CURRENT_TIMESTAMP)") + assignments.append("updated_at = CURRENT_TIMESTAMP") + params.append(attempt_id) + conn = self.database.connect() + try: + conn.execute( + "UPDATE advanced_material_validation_attempts " + f"SET {', '.join(assignments)} WHERE attempt_id = {self.placeholder}", + tuple(params), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_attempt(attempt_id) + + def list_attempts(self, import_id: str) -> list[AdvancedMaterialValidationAttempt]: + conn = self.database.connect() + try: + rows = conn.execute( + f""" + SELECT {ATTEMPT_COLUMNS} + FROM advanced_material_validation_attempts + WHERE import_id = {self.placeholder} + ORDER BY attempt_number DESC, created_at DESC + """, + (import_id,), + ).fetchall() + finally: + conn.close() + return [_row_to_attempt(row) for row in rows] + + def get_active_attempt(self, import_id: str) -> AdvancedMaterialValidationAttempt | None: + conn = self.database.connect() + try: + row = conn.execute( + f""" + SELECT {ATTEMPT_COLUMNS} + FROM advanced_material_validation_attempts + WHERE import_id = {self.placeholder} + AND status IN ('queued', 'running') + ORDER BY attempt_number DESC + LIMIT 1 + """, + (import_id,), + ).fetchone() + finally: + conn.close() + return _row_to_attempt(row) if row else None + + def mark_attempt_running( + self, + import_id: str, + attempt_id: str, + ) -> tuple[AdvancedMaterialImport, AdvancedMaterialValidationAttempt] | None: + """Atomically enter provider execution unless the import was cancelled.""" + + placeholder = self.placeholder + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" + import_row = conn.execute( + f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE import_id = {placeholder}{lock}", + (import_id,), + ).fetchone() + attempt_row = conn.execute( + f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts WHERE attempt_id = {placeholder}{lock}", + (attempt_id,), + ).fetchone() + if import_row is None or attempt_row is None or str(attempt_row["import_id"]) != import_id: + conn.commit() + return None + import_status = str(import_row["status"] or "") + attempt_status = str(attempt_row["status"] or "") + if import_status == "validating" and attempt_status == "running": + conn.commit() + return _row_to_import(import_row), _row_to_attempt(attempt_row) + if ( + import_status != "validation_queued" + or attempt_status != "queued" + or str(import_row["current_attempt_id"] or "") != attempt_id + ): + conn.commit() + return None + conn.execute( + f"UPDATE advanced_material_validation_attempts SET status = 'running', error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE attempt_id = {placeholder}", + (attempt_id,), + ) + conn.execute( + f"UPDATE advanced_material_imports SET status = 'validating', error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", + (import_id,), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + current_import = self.get_import(import_id) + current_attempt = self.get_attempt(attempt_id) + if current_import is None or current_attempt is None: + return None + return current_import, current_attempt + + def complete_attempt_if_active( + self, + import_id: str, + attempt_id: str, + *, + attempt_payload: dict[str, Any], + import_payload: dict[str, Any], + ) -> tuple[AdvancedMaterialImport, AdvancedMaterialValidationAttempt] | None: + """Atomically publish a validation result only while it still owns the import.""" + + placeholder = self.placeholder + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" + import_row = conn.execute( + f"SELECT status, current_attempt_id FROM advanced_material_imports WHERE import_id = {placeholder}{lock}", + (import_id,), + ).fetchone() + attempt_row = conn.execute( + f"SELECT status, import_id FROM advanced_material_validation_attempts WHERE attempt_id = {placeholder}{lock}", + (attempt_id,), + ).fetchone() + if ( + import_row is None + or attempt_row is None + or str(attempt_row["import_id"] or "") != import_id + or str(import_row["current_attempt_id"] or "") != attempt_id + or str(import_row["status"] or "") != "validating" + or str(attempt_row["status"] or "") != "running" + ): + conn.commit() + return None + attempt_assignments, attempt_params = _update_assignments( + {**attempt_payload, "status": "awaiting_review", "error": None}, + placeholder, + { + "status": "status", + "model_route": "model_route", + "provider_id": "provider_id", + "provider_model": "provider_model", + "validation_image_uri": "validation_image_uri", + "validation_thumbnail_uri": "validation_thumbnail_uri", + "width": "width", + "height": "height", + "usage": "usage_json", + "error": "error_json", + "metadata": "metadata_json", + }, + ) + attempt_assignments.extend(( + "completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)", + "updated_at = CURRENT_TIMESTAMP", + )) + attempt_params.append(attempt_id) + conn.execute( + f"UPDATE advanced_material_validation_attempts SET {', '.join(attempt_assignments)} WHERE attempt_id = {placeholder}", + tuple(attempt_params), + ) + import_assignments, import_params = _update_assignments( + {**import_payload, "status": "awaiting_review", "current_attempt_id": attempt_id, "error": None}, + placeholder, + { + "status": "status", + "current_attempt_id": "current_attempt_id", + "error": "error_json", + "metadata": "metadata_json", + }, + ) + import_assignments.append("updated_at = CURRENT_TIMESTAMP") + import_params.append(import_id) + conn.execute( + f"UPDATE advanced_material_imports SET {', '.join(import_assignments)} WHERE import_id = {placeholder}", + tuple(import_params), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + current_import = self.get_import(import_id) + current_attempt = self.get_attempt(attempt_id) + if current_import is None or current_attempt is None: + return None + return current_import, current_attempt + + def create_material(self, payload: dict[str, Any]) -> AdvancedMaterial: + material_id = _payload_id(payload, "material_id", "advmat") + placeholder = self.placeholder + conn = self.database.connect() + try: + _insert_material(conn, placeholder, material_id, payload) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + created = self.get_material(material_id) + if created is None: + raise RuntimeError("advanced material was inserted but could not be read back") + return created + + def get_material(self, material_id: str) -> AdvancedMaterial | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {MATERIAL_COLUMNS} FROM advanced_materials WHERE material_id = {self.placeholder}", + (material_id,), + ).fetchone() + finally: + conn.close() + return _row_to_material(row) if row else None + + def get_material_by_import(self, import_id: str) -> AdvancedMaterial | None: + conn = self.database.connect() + try: + row = conn.execute( + f"SELECT {MATERIAL_COLUMNS} FROM advanced_materials WHERE import_id = {self.placeholder}", + (import_id,), + ).fetchone() + finally: + conn.close() + return _row_to_material(row) if row else None + + def list_materials( + self, + *, + category_id: str | None = None, + status: str | None = "active", + keyword: str | None = None, + page: int = 1, + page_size: int = 30, + ) -> tuple[list[AdvancedMaterial], int]: + where: list[str] = [] + params: list[Any] = [] + placeholder = self.placeholder + if status: + where.append(f"status = {placeholder}") + params.append(status) + if category_id: + where.append(f"category_id = {placeholder}") + params.append(category_id) + if keyword: + where.append(f"(display_name LIKE {placeholder} OR prompt LIKE {placeholder})") + like = f"%{keyword}%" + params.extend((like, like)) + where_clause = f"WHERE {' AND '.join(where)}" if where else "" + normalized_page = _page(page) + normalized_page_size = _page_size(page_size) + offset = (normalized_page - 1) * normalized_page_size + conn = self.database.connect() + try: + total_row = conn.execute( + f"SELECT COUNT(*) AS total FROM advanced_materials {where_clause}", + tuple(params), + ).fetchone() + rows = conn.execute( + f""" + SELECT {MATERIAL_COLUMNS} + FROM advanced_materials + {where_clause} + ORDER BY priority DESC, accepted_at DESC, material_id DESC + LIMIT {placeholder} OFFSET {placeholder} + """, + tuple(params + [normalized_page_size, offset]), + ).fetchall() + finally: + conn.close() + return [_row_to_material(row) for row in rows], int(total_row["total"] if total_row else 0) + + def update_material(self, material_id: str, payload: dict[str, Any]) -> AdvancedMaterial | None: + assignments, params = _update_assignments( + payload, + self.placeholder, + { + "category_id": "category_id", + "display_name": "display_name", + "source_image_uri": "source_image_uri", + "source_thumbnail_uri": "source_thumbnail_uri", + "validation_image_uri": "validation_image_uri", + "validation_thumbnail_uri": "validation_thumbnail_uri", + "prompt": "prompt", + "negative_prompt": "negative_prompt", + "tags": "tags_json", + "priority": "priority", + "status": "status", + "capsule": "capsule_json", + "metadata": "metadata_json", + "accepted_at": "accepted_at", + "archived_at": "archived_at", + }, + ) + if not assignments: + return self.get_material(material_id) + assignments.append("updated_at = CURRENT_TIMESTAMP") + params.append(material_id) + conn = self.database.connect() + try: + conn.execute( + f"UPDATE advanced_materials SET {', '.join(assignments)} WHERE material_id = {self.placeholder}", + tuple(params), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_material(material_id) + + def archive_material(self, material_id: str) -> AdvancedMaterial | None: + conn = self.database.connect() + try: + conn.execute( + f""" + UPDATE advanced_materials + SET status = 'archived', + archived_at = COALESCE(archived_at, CURRENT_TIMESTAMP), + updated_at = CURRENT_TIMESTAMP + WHERE material_id = {self.placeholder} + """, + (material_id,), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + return self.get_material(material_id) + + def accept_attempt( + self, + import_id: str, + attempt_id: str, + payload: dict[str, Any], + ) -> AdvancedMaterial: + """Atomically seal one successful validation attempt into the high-priority catalog.""" + + placeholder = self.placeholder + conn = self.database.connect() + try: + if self.database.backend == "sqlite": + conn.execute("BEGIN IMMEDIATE") + lock_suffix = " FOR UPDATE" if self.database.backend == "postgresql" else "" + import_row = conn.execute( + f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE import_id = {placeholder}{lock_suffix}", + (import_id,), + ).fetchone() + if import_row is None: + raise ValueError("advanced material import does not exist") + attempt_row = conn.execute( + f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts " + f"WHERE attempt_id = {placeholder}{lock_suffix}", + (attempt_id,), + ).fetchone() + if attempt_row is None: + raise ValueError("advanced material validation attempt does not exist") + if str(attempt_row["import_id"]) != str(import_id): + raise ValueError("validation attempt belongs to another advanced material import") + current_attempt_id = _optional_text(import_row["current_attempt_id"]) + if current_attempt_id and current_attempt_id != attempt_id: + raise ValueError("only the current validation attempt can be accepted") + + existing_row = conn.execute( + f"SELECT {MATERIAL_COLUMNS} FROM advanced_materials WHERE import_id = {placeholder}", + (import_id,), + ).fetchone() + if existing_row is not None: + existing = _row_to_material(existing_row) + if existing.accepted_attempt_id != attempt_id: + raise ValueError("advanced material import has already accepted another attempt") + conn.commit() + return existing + if import_row["accepted_material_id"]: + raise ValueError("advanced material import points to a missing accepted material") + + style_case_rows = conn.execute( + f"SELECT status FROM advanced_style_validation_cases " + f"WHERE attempt_id = {placeholder}{lock_suffix}", + (attempt_id,), + ).fetchall() + if style_case_rows and ( + len(style_case_rows) != 3 + or any(str(row["status"] or "") != "succeeded" for row in style_case_rows) + ): + raise ValueError("all three advanced style validation cases must succeed before acceptance") + attempt_status = str(attempt_row["status"] or "") + if attempt_status not in {"awaiting_review", "succeeded", "completed", "accepted"}: + raise ValueError("only a completed validation attempt can be accepted") + validation_image_uri = payload.get("validation_image_uri") or attempt_row["validation_image_uri"] + if not validation_image_uri: + raise ValueError("validation attempt does not have a generated verification image") + + material_id = _payload_id(payload, "material_id", "advmat") + insert_payload = { + "import_id": import_id, + "accepted_attempt_id": attempt_id, + "category_id": payload.get("category_id", import_row["category_id"]), + "display_name": payload.get("display_name", import_row["display_name"]), + "source_image_uri": payload.get("source_image_uri", import_row["source_image_uri"]), + "source_thumbnail_uri": payload.get( + "source_thumbnail_uri", import_row["source_thumbnail_uri"] + ), + "validation_image_uri": validation_image_uri, + "validation_thumbnail_uri": payload.get("validation_thumbnail_uri") + or attempt_row["validation_thumbnail_uri"], + "prompt": payload.get("prompt") or attempt_row["prompt"] + or import_row["recognition_prompt"], + "negative_prompt": payload.get("negative_prompt") + if "negative_prompt" in payload + else attempt_row["negative_prompt"] or import_row["recognition_negative_prompt"], + "tags": payload.get("tags") + if "tags" in payload + else _json_list(import_row["recognition_tags_json"]), + "priority": payload.get("priority", 100), + "status": payload.get("status", "active"), + "capsule": payload.get("capsule"), + "metadata": payload.get("metadata"), + "accepted_at": payload.get("accepted_at"), + } + if not insert_payload["prompt"]: + raise ValueError("accepted advanced material requires a reusable prompt") + _insert_material(conn, placeholder, material_id, insert_payload) + conn.execute( + f""" + UPDATE advanced_material_validation_attempts + SET status = 'accepted', decision = 'accepted', + decision_notes = {placeholder}, decided_at = CURRENT_TIMESTAMP, + updated_at = CURRENT_TIMESTAMP + WHERE attempt_id = {placeholder} + """, + (payload.get("decision_notes"), attempt_id), + ) + conn.execute( + f""" + UPDATE advanced_material_imports + SET status = 'accepted', current_attempt_id = {placeholder}, + accepted_material_id = {placeholder}, error_json = NULL, + updated_at = CURRENT_TIMESTAMP + WHERE import_id = {placeholder} + """, + (attempt_id, material_id, import_id), + ) + conn.commit() + except Exception: + _rollback(conn) + raise + finally: + conn.close() + accepted = self.get_material(material_id) + if accepted is None: + raise RuntimeError("accepted advanced material was not readable after transaction") + return accepted + + +def _insert_material( + conn, + placeholder: str, + material_id: str, + payload: dict[str, Any], +) -> None: + conn.execute( + f""" + INSERT INTO advanced_materials ( + material_id, import_id, accepted_attempt_id, category_id, + display_name, source_image_uri, source_thumbnail_uri, + validation_image_uri, validation_thumbnail_uri, prompt, + negative_prompt, tags_json, priority, status, capsule_json, + metadata_json, accepted_at, archived_at + ) VALUES ( + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + {placeholder}, {placeholder}, {placeholder}, {placeholder}, + COALESCE({placeholder}, CURRENT_TIMESTAMP), {placeholder} + ) + """, + ( + material_id, + payload["import_id"], + payload["accepted_attempt_id"], + payload.get("category_id"), + str(payload["display_name"]), + str(payload["source_image_uri"]), + payload.get("source_thumbnail_uri"), + str(payload["validation_image_uri"]), + payload.get("validation_thumbnail_uri"), + str(payload["prompt"]), + payload.get("negative_prompt"), + _json_or_none(payload.get("tags") or []), + int(payload.get("priority", 100) or 100), + payload.get("status", "active"), + _json_or_none(payload.get("capsule")), + _json_or_none(payload.get("metadata")), + payload.get("accepted_at"), + payload.get("archived_at"), + ), + ) + + +def _row_to_import(row) -> AdvancedMaterialImport: + return AdvancedMaterialImport( + import_id=str(row["import_id"]), + category_id=_optional_text(row["category_id"]), + display_name=str(row["display_name"]), + source_image_uri=str(row["source_image_uri"]), + source_thumbnail_uri=_optional_text(row["source_thumbnail_uri"]), + status=str(row["status"]), + recognition_prompt=_optional_text(row["recognition_prompt"]), + recognition_negative_prompt=_optional_text(row["recognition_negative_prompt"]), + recognition_tags=_json_list(row["recognition_tags_json"]), + recognition_result=_json_object(row["recognition_result_json"]), + recognition_model_route=_optional_text(row["recognition_model_route"]), + prompt_revision=int(row["prompt_revision"] or 0), + current_attempt_id=_optional_text(row["current_attempt_id"]), + accepted_material_id=_optional_text(row["accepted_material_id"]), + idempotency_key=_optional_text(row["idempotency_key"]), + created_by=_optional_text(row["created_by"]), + error=_json_object(row["error_json"]), + metadata=_json_object(row["metadata_json"]), + created_at=str(row["created_at"]), + updated_at=str(row["updated_at"]), + ) + + +def _row_to_attempt(row) -> AdvancedMaterialValidationAttempt: + return AdvancedMaterialValidationAttempt( + attempt_id=str(row["attempt_id"]), + import_id=str(row["import_id"]), + attempt_number=int(row["attempt_number"] or 0), + status=str(row["status"]), + adjustment_text=_optional_text(row["adjustment_text"]), + prompt=str(row["prompt"] or ""), + negative_prompt=_optional_text(row["negative_prompt"]), + model_route=_optional_text(row["model_route"]), + provider_id=_optional_text(row["provider_id"]), + provider_model=_optional_text(row["provider_model"]), + task_id=_optional_text(row["task_id"]), + validation_image_uri=_optional_text(row["validation_image_uri"]), + validation_thumbnail_uri=_optional_text(row["validation_thumbnail_uri"]), + seed=_optional_int(row["seed"]), + width=_optional_int(row["width"]), + height=_optional_int(row["height"]), + usage=_json_object(row["usage_json"]), + fidelity_score=_optional_float(row["fidelity_score"]), + decision=_optional_text(row["decision"]), + decision_notes=_optional_text(row["decision_notes"]), + error=_json_object(row["error_json"]), + metadata=_json_object(row["metadata_json"]), + created_at=str(row["created_at"]), + updated_at=str(row["updated_at"]), + completed_at=_optional_text(row["completed_at"]), + decided_at=_optional_text(row["decided_at"]), + ) + + +def _row_to_material(row) -> AdvancedMaterial: + return AdvancedMaterial( + material_id=str(row["material_id"]), + import_id=str(row["import_id"]), + accepted_attempt_id=str(row["accepted_attempt_id"]), + category_id=_optional_text(row["category_id"]), + display_name=str(row["display_name"]), + source_image_uri=str(row["source_image_uri"]), + source_thumbnail_uri=_optional_text(row["source_thumbnail_uri"]), + validation_image_uri=str(row["validation_image_uri"]), + validation_thumbnail_uri=_optional_text(row["validation_thumbnail_uri"]), + prompt=str(row["prompt"]), + negative_prompt=_optional_text(row["negative_prompt"]), + tags=_json_list(row["tags_json"]), + priority=int(row["priority"] or 0), + status=str(row["status"]), + capsule=_json_object(row["capsule_json"]), + metadata=_json_object(row["metadata_json"]), + accepted_at=str(row["accepted_at"]), + archived_at=_optional_text(row["archived_at"]), + created_at=str(row["created_at"]), + updated_at=str(row["updated_at"]), + ) + + +def _row_to_style_source(row) -> AdvancedStyleSource: + return AdvancedStyleSource( + source_id=str(row["source_id"]), + import_id=str(row["import_id"]), + sort_order=int(row["sort_order"] or 0), + is_primary=bool(row["is_primary"]), + source_image_uri=str(row["source_image_uri"]), + source_thumbnail_uri=_optional_text(row["source_thumbnail_uri"]), + status=str(row["status"]), + recognition_model_route=_optional_text(row["recognition_model_route"]), + provider_id=_optional_text(row["provider_id"]), + provider_model=_optional_text(row["provider_model"]), + task_id=_optional_text(row["task_id"]), + recognition_prompt=_optional_text(row["recognition_prompt"]), + recognition_negative_prompt=_optional_text(row["recognition_negative_prompt"]), + recognition_tags=_json_list(row["recognition_tags_json"]), + recognition_result=_json_object(row["recognition_result_json"]), + error=_json_object(row["error_json"]), + metadata=_json_object(row["metadata_json"]), + created_at=str(row["created_at"]), + updated_at=str(row["updated_at"]), + completed_at=_optional_text(row["completed_at"]), + excluded_at=_optional_text(row["excluded_at"]), + ) + + +def _row_to_style_consensus(row) -> AdvancedStyleConsensusRun: + return AdvancedStyleConsensusRun( + consensus_id=str(row["consensus_id"]), + import_id=str(row["import_id"]), + revision=int(row["revision"] or 0), + status=str(row["status"]), + task_id=_optional_text(row["task_id"]), + model_route=_optional_text(row["model_route"]), + provider_id=_optional_text(row["provider_id"]), + provider_model=_optional_text(row["provider_model"]), + source_ids=_json_list(row["source_ids_json"]), + prompt=_optional_text(row["prompt"]), + negative_prompt=_optional_text(row["negative_prompt"]), + tags=_json_list(row["tags_json"]), + result=_json_object(row["result_json"]), + error=_json_object(row["error_json"]), + metadata=_json_object(row["metadata_json"]), + created_at=str(row["created_at"]), + updated_at=str(row["updated_at"]), + completed_at=_optional_text(row["completed_at"]), + ) + + +def _row_to_style_validation_case(row) -> AdvancedStyleValidationCase: + return AdvancedStyleValidationCase( + case_id=str(row["case_id"]), + attempt_id=str(row["attempt_id"]), + import_id=str(row["import_id"]), + case_key=str(row["case_key"]), + sort_order=int(row["sort_order"] or 0), + status=str(row["status"]), + task_id=_optional_text(row["task_id"]), + content_prompt=str(row["content_prompt"] or ""), + final_prompt=str(row["final_prompt"] or ""), + negative_prompt=_optional_text(row["negative_prompt"]), + model_route=_optional_text(row["model_route"]), + provider_id=_optional_text(row["provider_id"]), + provider_model=_optional_text(row["provider_model"]), + seed=_optional_int(row["seed"]), + width=_optional_int(row["width"]), + height=_optional_int(row["height"]), + validation_image_uri=_optional_text(row["validation_image_uri"]), + validation_thumbnail_uri=_optional_text(row["validation_thumbnail_uri"]), + usage=_json_object(row["usage_json"]), + style_review=_json_object(row["style_review_json"]), + fidelity_score=_optional_float(row["fidelity_score"]), + error=_json_object(row["error_json"]), + metadata=_json_object(row["metadata_json"]), + created_at=str(row["created_at"]), + updated_at=str(row["updated_at"]), + completed_at=_optional_text(row["completed_at"]), + ) + + +def _update_assignments( + payload: dict[str, Any], + placeholder: str, + columns: dict[str, str], +) -> tuple[list[str], list[Any]]: + assignments: list[str] = [] + params: list[Any] = [] + for key, column in columns.items(): + if key not in payload: + continue + value = payload[key] + if column.endswith("_json"): + value = _json_or_none(value) + elif key in { + "prompt_revision", "priority", "seed", "width", "height", + "sort_order", "revision", "is_primary", + }: + value = _optional_int(value) + elif key == "fidelity_score": + value = _optional_float(value) + assignments.append(f"{column} = {placeholder}") + params.append(value) + return assignments, params + + +def _payload_id(payload: dict[str, Any], key: str, prefix: str) -> str: + value = str(payload.get(key) or "").strip() + return value or f"{prefix}_{uuid4().hex}" + + +def _json_or_none(value: Any | None) -> str | None: + if value is None: + return None + return json.dumps(value, ensure_ascii=False, sort_keys=True) + + +def _json_object(value: str | None) -> dict[str, Any]: + if not value: + return {} + parsed = json.loads(value) + return parsed if isinstance(parsed, dict) else {} + + +def _json_list(value: str | None) -> list[str]: + if not value: + return [] + parsed = json.loads(value) + return [str(item) for item in parsed] if isinstance(parsed, list) else [] + + +def _optional_text(value: Any) -> str | None: + if value is None: + return None + text = str(value).strip() + return text or None + + +def _optional_int(value: Any) -> int | None: + if value in (None, ""): + return None + return int(value) + + +def _optional_float(value: Any) -> float | None: + if value in (None, ""): + return None + return float(value) + + +def _page(value: int) -> int: + return max(int(value or 1), 1) + + +def _page_size(value: int) -> int: + return min(max(int(value or 30), 1), 200) + + +def _rollback(conn) -> None: + try: + conn.rollback() + except Exception: + return diff --git a/database/repositories/job_repository.py b/database/repositories/job_repository.py index 15e2e13..9d63dfe 100644 --- a/database/repositories/job_repository.py +++ b/database/repositories/job_repository.py @@ -160,14 +160,16 @@ class JobRepository: self, *, statuses: set[str] | tuple[str, ...] | list[str], - updated_before: str, - limit: int = 100, + updated_before: str | None, + limit: int | None = 100, ) -> list[GenerationTask]: """Return oldest tasks that were left in an executable state. Recovery decides which task sources are safe to requeue. Keeping the JSON-source filter in the service makes this query portable across the - SQLite and PostgreSQL backends. + SQLite and PostgreSQL backends. Startup recovery may omit both the + age boundary and limit because it runs before the new worker pool is + started and must inspect every task owned by the previous process. """ normalized_statuses = tuple( @@ -177,6 +179,13 @@ class JobRepository: return [] placeholder = self.placeholder status_placeholders = ", ".join(placeholder for _ in normalized_statuses) + age_clause = f"AND updated_at <= {placeholder}" if updated_before else "" + limit_clause = f"LIMIT {placeholder}" if limit is not None else "" + params: list[Any] = list(normalized_statuses) + if updated_before: + params.append(updated_before) + if limit is not None: + params.append(_limit(limit)) conn = self.database.connect() try: rows = conn.execute( @@ -184,11 +193,11 @@ class JobRepository: SELECT {TASK_COLUMNS} FROM generation_tasks WHERE status IN ({status_placeholders}) - AND updated_at <= {placeholder} + {age_clause} ORDER BY updated_at ASC, created_at ASC, task_id ASC - LIMIT {placeholder} + {limit_clause} """, - (*normalized_statuses, updated_before, _limit(limit)), + tuple(params), ).fetchall() finally: conn.close() diff --git a/database/repositories/wardrobe_repository.py b/database/repositories/wardrobe_repository.py index 529bf77..ec606ac 100644 --- a/database/repositories/wardrobe_repository.py +++ b/database/repositories/wardrobe_repository.py @@ -25,9 +25,22 @@ WARDROBE_COLUMNS = """ """ +WARDROBE_TABLES = frozenset({"wardrobe_items", "advanced_wardrobe_items"}) + + class WardrobeRepository: - def __init__(self, database: Database): + def __init__( + self, + database: Database, + *, + table_name: str = "wardrobe_items", + library_kind: str = "standard", + ): + if table_name not in WARDROBE_TABLES: + raise ValueError(f"unsupported wardrobe table: {table_name}") self.database = database + self.table_name = table_name + self.library_kind = library_kind @property def placeholder(self) -> str: @@ -39,7 +52,7 @@ class WardrobeRepository: try: conn.execute( f""" - INSERT INTO wardrobe_items ( + INSERT INTO {self.table_name} ( wardrobe_item_id, profile_id, material_id, @@ -77,12 +90,12 @@ class WardrobeRepository: conn = self.database.connect() try: row = conn.execute( - f"SELECT {WARDROBE_COLUMNS} FROM wardrobe_items WHERE wardrobe_item_id = {placeholder}", + f"SELECT {WARDROBE_COLUMNS} FROM {self.table_name} WHERE wardrobe_item_id = {placeholder}", (wardrobe_item_id,), ).fetchone() finally: conn.close() - return _row_to_item(row) if row else None + return _row_to_item(row, library_kind=self.library_kind) if row else None def list_by_profile(self, profile_id: str, wardrobe_category: str | None = None) -> list[WardrobeItem]: placeholder = self.placeholder @@ -96,7 +109,7 @@ class WardrobeRepository: rows = conn.execute( f""" SELECT {WARDROBE_COLUMNS} - FROM wardrobe_items + FROM {self.table_name} WHERE {" AND ".join(where)} ORDER BY is_favorite DESC, usage_count ASC, created_at ASC """, @@ -104,7 +117,7 @@ class WardrobeRepository: ).fetchall() finally: conn.close() - return [_row_to_item(row) for row in rows] + return [_row_to_item(row, library_kind=self.library_kind) for row in rows] def delete(self, wardrobe_item_id: str) -> WardrobeItem | None: before = self.get(wardrobe_item_id) @@ -113,7 +126,7 @@ class WardrobeRepository: placeholder = self.placeholder conn = self.database.connect() try: - conn.execute(f"DELETE FROM wardrobe_items WHERE wardrobe_item_id = {placeholder}", (wardrobe_item_id,)) + conn.execute(f"DELETE FROM {self.table_name} WHERE wardrobe_item_id = {placeholder}", (wardrobe_item_id,)) conn.commit() finally: conn.close() @@ -125,7 +138,7 @@ class WardrobeRepository: try: conn.execute( f""" - UPDATE wardrobe_items + UPDATE {self.table_name} SET usage_count = usage_count + 1, last_used_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP @@ -139,7 +152,18 @@ class WardrobeRepository: return self.get(wardrobe_item_id) -def _row_to_item(row) -> WardrobeItem: +class AdvancedWardrobeRepository(WardrobeRepository): + """Wardrobe storage whose material FK targets verified advanced assets.""" + + def __init__(self, database: Database): + super().__init__( + database, + table_name="advanced_wardrobe_items", + library_kind="advanced", + ) + + +def _row_to_item(row, *, library_kind: str = "standard") -> WardrobeItem: return WardrobeItem( wardrobe_item_id=row["wardrobe_item_id"], profile_id=row["profile_id"], @@ -153,6 +177,7 @@ def _row_to_item(row) -> WardrobeItem: last_used_at=str(row["last_used_at"]) if row["last_used_at"] else None, created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), + library_kind=library_kind, ) diff --git a/docs/advanced-material-workflow-1.0.21.md b/docs/advanced-material-workflow-1.0.21.md new file mode 100644 index 0000000..d99b2cf --- /dev/null +++ b/docs/advanced-material-workflow-1.0.21.md @@ -0,0 +1,70 @@ +# 进阶素材导入与还原验证工作流 + +## 目标 + +进阶素材用于保存经过“文字提示词可还原性”验证的高可信素材。普通素材流程保持不变;进阶素材拥有独立数据库表、独立文件目录和独立后台任务,不会把验证图写入普通图库或角色工作流候选池。 + +## 状态机 + +```text +上传源图 + -> recognition_queued + -> recognizing + -> ready_for_validation + -> validation_queued + -> validating + -> awaiting_review + |-- 接受 -> accepted -> advanced_materials(active) + `-- 不接受 -> adjustment_required + -> validation_queued(下一轮) +``` + +失败状态为 `recognition_failed` 和 `validation_failed`,均保留源图、识别结果和已完成轮次,并允许人工重试。验证生图任务不会在插件重启后自动重放,避免重复付费;识别任务可以安全恢复。 + +运行中取消使用导入与轮次双重 compare-and-set。提供方迟到返回时只保留脱敏后的计费归因,生成文件会被删除,导入和轮次不会被重新改回 `awaiting_review`。插件启动会处理旧进程留下的全部 `running/retrying` 进阶任务,不等待五分钟陈旧窗口。 + +## 隔离边界 + +- 普通素材表:`materials` +- 进阶导入会话:`advanced_material_imports` +- 进阶验证轮次:`advanced_material_validation_attempts` +- 已封存进阶素材:`advanced_materials` +- 普通素材目录:`storage://materials/...` +- 进阶素材目录:`storage://advanced_materials/...` +- 验证图不会创建 `generation_images` 记录,也不会进入普通图库。 +- 验证生图请求只携带识别提示词,不携带源图作为 `input_images`。 + +## 人工审核规则 + +- 只有当前 `awaiting_review` 且验证图存在的轮次可以封存。 +- 模型或主观评分只作为记录,不能自动封存。 +- “不还原”必须填写调整描述;描述会形成新的提示词修订和验证轮次,旧轮次永久保留。 +- 封存时保存原始素材作为角色引用图,验证图仅作为还原证据。 + +## 高优先级规则 + +统一素材目录通过服务端解析 `advmat_` 记录。只有 `advanced_materials.status=active` 的记录会获得可信的 `advanced_verified` 标记和优先级加成;普通素材即使伪造同名 metadata 也不会获得加成。用户明确锁定或设为必需的素材仍高于自动进阶加成。 + +## 内容安全、路由与预算 + +- 规则审核只检查正向需求;负向提示词中的 `nudity / gore / child` 等排除词不会被当成用户想生成的内容。 +- 恐怖主义、极端主义、现实高危暴力和极端血腥在调用生图提供方前直接禁止并记录高优先级审计。 +- 合法成人内容只有在入口开关、用户/群组白名单和 NSFW 路由同时满足时才会分流。 +- 普通模型只有返回明确的成人/NSFW 内容安全拒绝时才允许向 NSFW 路由回退一次;通用安全错误、未成年人、恐暴或未知原因不会盲目回退。 +- safe/sensitive 内容始终使用 `advanced_material_validation_generation` 专用模型,不被全局普通生图路由覆盖。 +- `advanced_materials.cost_budget` 可配置统计窗口、任务/图片/费用上限和请求/图片/Token 单价。自动回退按最坏两次提供方请求预检。 + +## 主要接口 + +- `POST /advanced-material-imports/upload` +- `GET /advanced-material-imports` +- `GET /advanced-material-imports/{import_id}` +- `POST /advanced-material-imports/{import_id}/retry` +- `POST /advanced-material-imports/{import_id}/validation-attempts` +- `GET /advanced-material-imports/{import_id}/validation-attempts` +- `POST /advanced-material-imports/{import_id}/attempts/{attempt_id}/reject` +- `POST /advanced-material-imports/{import_id}/attempts/{attempt_id}/accept` +- `GET /advanced-materials` +- `GET /material-catalog` + +上传、重试和创建验证轮次均立即返回任务信息;耗时识别和生图由持久 Worker 执行。 diff --git a/docs/advanced-style-set-workflow-1.0.22.md b/docs/advanced-style-set-workflow-1.0.22.md new file mode 100644 index 0000000..637297a --- /dev/null +++ b/docs/advanced-style-set-workflow-1.0.22.md @@ -0,0 +1,162 @@ +# 进阶画风样本组:多图交叉提取与纯文本迁移验证 + +## 目标与边界 + +本功能只对素材根分类“风格”开放。服装、鞋袜、配饰、构图等普通与进阶素材继续使用单图导入,不改变现有接口语义。 + +一个进阶画风样本组接收 2~8 张同画风图片(推荐 3~6 张),将每张图片拆成完全独立、同时执行的视觉识别任务;全部可用结果完成后,再由交叉分析任务同时读取原图与逐图报告,分离共同画风、可变特征和内容污染。验证阶段不向生图模型传递任何源图,只把统一画风胶囊应用到与源样本完全不同的角色、场景和构图,以验证画风的迁移能力,而不是源图复刻能力。 + +最终仍封存为一个 `advmat_...` 进阶素材目录项。现有素材目录、衣橱、详细角色工作流继续通过统一 Material 合约使用它;旧的单图进阶素材不需要迁移。 + +## 用户流程 + +```text +选择“风格” + -> 上传 2~8 张样本 + -> 每张样本创建独立识别任务并同时派发 + -> 成功样本达到至少 2 张 + -> 交叉模型同时读取全部有效原图与逐图报告 + -> 生成共同画风、可变项、内容污染与异常样本报告 + -> 自动规划三个与源样本语义显著不同的验证场景 + -> 三个纯文本生图任务同时派发(无 input_images / image) + -> 人工对照三项迁移结果 + |-- 接受 -> 封存一个高优先级进阶画风 + `-- 调整 -> 重建统一胶囊 -> 使用同一组场景重新并行验证 +``` + +## 并行任务与屏障 + +### 单图识别 + +- 每张源图拥有独立 `source_id`、`task_id`、状态、超时、重试次数、错误和识别结果。 +- 同一组内的 2~8 个识别任务一次性入队;Worker 不串行等待,调度并发上限默认等于组内图片数,硬上限为 8。 +- 任何一张失败都不得取消或超时其他任务,也不得共享计时器。 +- 失败样本可以单独重试或排除;成功样本不少于 2 张时允许用户继续。 +- 交叉分析通过数据库屏障触发:所有未排除任务进入终态,且成功数不少于 2;重复回调必须幂等,最多创建一个交叉分析任务。 + +### 验证生成 + +- 默认生成 `portrait`、`fullbody`、`novel_scene` 三个验证案例。 +- 三个案例分别创建任务并同时派发,每个案例拥有独立超时、重试、取消和错误。 +- 验证批次只在全部未排除案例进入终态后进入人工审核;单例失败可以单独重试。 +- 所有耗时接口立即返回“已入队”,前端通过导入详情轮询状态。 + +## 画风交叉分析 + +交叉模型输入: + +- 全部有效原图; +- 每张图片的结构化识别报告; +- 每张图片的内容摘要; +- 用户补充的画风要求; +- 明确的“只抽取可观察画风、不继承内容”约束。 + +交叉结果至少包含: + +- `consensus_style`:多图稳定共同特征; +- `variable_style_features`:部分样本存在的弱特征; +- `source_content_features`:人物、服装、姿势、道具、场景与构图内容; +- `content_leakage_exclusions`:正式提示词必须排除的内容污染; +- `outlier_source_ids`:疑似异画风样本; +- `representative_source_ids`:按风格强度、内容差异和污染风险选择的 1~3 张代表图; +- `consensus_confidence` 与逐特征证据; +- `compact / standard / detailed` 三档统一画风胶囊。 + +共同特征的默认分级: + +- 支持率不低于 60% 且置信度达标:核心画风; +- 支持率 40%~60%:可变或弱画风; +- 支持率低于 40%:不进入核心胶囊; +- 人物身份、服装、姿势、道具、文字、背景主体:进入内容污染或禁止继承项; +- 近重复图片降低证据权重,避免重复样本放大偶然特征。 + +## 纯文本异角色异场景验证 + +验证规划器先根据 `source_content_features` 生成三个语义距离显著的内容案例。案例必须改变尽可能多的内容维度:年龄、性别或物种、服装、姿势、镜头距离、室内外、背景、道具和构图。 + +每个案例分离保存: + +- `content_prompt`:只描述新角色与新场景; +- `style_prompt`:统一画风胶囊; +- `final_prompt`:由后端可追踪地合并两者; +- `negative_prompt`:画风禁止项与内容污染排除项; +- 路由、模型、seed、输出图、用量与错误。 + +生图请求必须满足: + +```json +{ + "input_images": [], + "image": [] +} +``` + +验证输出可以由 Vision 模型依据统一画风指纹进行辅助审核,但不得以人物是否像源图作为指标。审核维度包括线条、着色、阴影、色彩规律、边缘、高光、纹理、媒介感、细节密度和内容污染。自动评分只作参考,不能自动封存。 + +## 人工调整与版本一致性 + +- 调整说明不得只追加到顶层 prompt。 +- 每次调整必须生成新的共识版本,并同步重建三档胶囊、负向词与内容污染排除项。 +- 使用同一组三个验证案例重新生成,便于前后对比;旧版本和旧验证结果永久保留。 +- 封存时必须引用当前已审核的共识版本,杜绝“验证用新提示词、正式生图仍用旧胶囊”。 + +## 数据模型 + +在现有 `advanced_material_imports / advanced_material_validation_attempts / advanced_materials` 之外增加风格专用子表: + +- `advanced_style_sources`:源图、缩略图、排序、主参考、排除状态、独立任务与识别结果; +- `advanced_style_consensus_runs`:交叉分析输入摘要、共同画风、可变项、内容污染、代表图、统一胶囊和版本号; +- `advanced_style_validation_cases`:一个共识版本下的三个异场景案例、独立任务、输出图与审核结果。 + +导入主记录通过 metadata 保存 `workflow_kind=style_set`、当前共识版本和批次状态。`advanced_materials.source_image_uri` 继续保存主参考图以兼容旧消费者,完整源图与最多三张代表图通过关联数据和可信 metadata 暴露。 + +## 接口与兼容策略 + +保留所有现有单图接口,增加风格组接口: + +- `POST /advanced-material-imports/style-set/upload` +- `POST /advanced-material-imports/{import_id}/style-sources/{source_id}/retry` +- `POST /advanced-material-imports/{import_id}/style-sources/{source_id}/exclude` +- `POST /advanced-material-imports/{import_id}/style-consensus` +- `POST /advanced-material-imports/{import_id}/style-validation-cases/{case_id}/retry` +- `POST /advanced-material-imports/{import_id}/validation-attempts`(兼容入口;确保三场景批次存在) +- `POST /advanced-material-imports/{import_id}/attempts/{attempt_id}/reject`(携带调整说明并创建新共识版本) +- `POST /advanced-material-imports/{import_id}/attempts/{attempt_id}/accept`(封存当前已审核版本) + +服务端按 `material_categories` 的规范名称确认“风格”,不信任前端标签。非风格分类上传多图必须返回明确校验错误。旧单图进阶素材仍走原接口和原状态机。 + +## 下游应用 + +- 快速角色:使用统一画风胶囊,不自动发送源图,维持当前轻量路径。 +- 详细角色工作流:使用 detailed 胶囊;只有提供方明确支持参考图时才选择主参考及最多两张代表图。 +- 适配器不支持原生参考角色/权重时,优先只发送主参考图,避免人物、服装和构图污染。 +- 验证图永不进入普通图库、角色候选池或正式参考图集合。 + +## 开发队列与验收状态 + +- [x] P0:新增风格样本、共识版本和验证案例迁移、DTO 与仓储。 +- [x] P0:后端只允许“风格”使用 2~8 张,多图上传原子落盘,失败时清理新文件。 +- [x] P0:逐图任务独立入队、独立超时/重试/错误,批次同时派发并提供幂等屏障。 +- [x] P0:交叉分析同时读取全部有效原图和逐图报告,生成带证据的统一画风结构与三档胶囊。 +- [x] P0:验证规划生成三个与源内容显著不同的案例;生图请求不得携带任何源图。 +- [x] P0:三个验证案例独立并行、可单独重试,失败不影响其他案例。 +- [x] P1:人工调整创建新共识版本并同步重建胶囊;封存只能引用当前已审核版本。 +- [x] P1:统一目录继续输出一个 `advmat_`,可信 metadata 携带代表源图但不暴露伪造优先级。 +- [x] P1:前端仅在选择“风格”时启用多图上传、排序、主参考、排除和逐图状态。 +- [x] P1:前端展示当前共识版本、共同画风、可变项、内容污染、异常样本和三案例验证。 +- [x] P2:备份恢复、孤儿媒体、成本预算、统计与日志覆盖新增表和文件。 +- [x] P2:迁移、仓储、服务、Worker 恢复、权限、路由、契约、类型检查和深夜模式测试。 +- [x] P2:完整后端测试、前端契约、类型检查、生产构建和 `git diff --check` 全部通过。 + +## 验收标准 + +1. 非风格分类无法创建多图组;旧单图进阶流程无回归。 +2. 风格组支持 2~8 张,所有单图识别任务同时进入队列且无共享超时。 +3. 单图失败可单独重试、排除;至少两张成功后可以交叉分析。 +4. 交叉结果能追溯每个核心特征来自哪些图片,并分离源内容污染。 +5. 三个验证案例的角色、场景和构图与源样本显著不同,且 provider 请求没有源图。 +6. 三个案例独立并行,任一失败不会覆盖其他任务状态。 +7. 人工调整后统一胶囊版本发生变化,封存素材使用新胶囊。 +8. 最终只产生一个进阶画风素材,验证图保持隔离。 +9. 旧数据库可平滑迁移,插件重启可恢复识别任务但不会自动重复付费验证。 +10. 全量自动化测试与静态构建通过,测试过程不调用真实付费模型。 diff --git a/docs/project-migration-handoff-2026-07-18.md b/docs/project-migration-handoff-2026-07-18.md new file mode 100644 index 0000000..7938906 --- /dev/null +++ b/docs/project-migration-handoff-2026-07-18.md @@ -0,0 +1,1136 @@ +# AstrBot ImageStudio 项目迁移与 Codex 交接文档 + +> 更新时间:2026-07-18(Asia/Shanghai) +> 当前工作区:`C:\Users\Administrator\Documents\AstrBot ImageStudio` +> 当前开发版本:`1.0.32` +> 目标读者:迁移后的新 Codex 账号、新工作区维护者、后续开发者 +> 文档目的:只读取本文件即可恢复当前开发背景、代码状态、实机环境、最新问题和下一步修复任务。 + +--- + +## 0. 必须首先阅读的迁移警告 + +当前 Forgejo 远端、远端分支和 Git 提交历史只到 **v1.0.20**。 + +本地工作区中从 **1.0.21 到 1.0.32** 的大量核心代码尚未提交,其中很多文件仍是 `??` 未跟踪状态,包括: + +- 进阶素材主服务; +- 多图片画风工作流; +- 新数据库迁移; +- 新仓储层; +- 新前端页面; +- 新测试; +- 1.0.21~1.0.31 发布包; +- 1.0.32 最新算法修改。 + +因此迁移时: + +1. **不能只在新地址重新 `git clone` Forgejo 仓库。** +2. **不能执行 `git reset --hard`、`git clean -fdx` 或删除所有未跟踪文件。** +3. 必须复制当前项目完整目录,包括 `.git`、未跟踪文件和当前工作树。 +4. 迁移完成后先执行 `git status --short --branch`,确认下面列出的修改与未跟踪文件仍存在。 +5. 在完成备份、审查和提交前,不要把远端 v1.0.20 当作当前源码真相。 + +最安全的迁移方式是复制整个目录: + +```text +C:\Users\Administrator\Documents\AstrBot ImageStudio +``` + +包括隐藏的 `.git` 目录。复制完成后再切换 Codex 账号或更改项目地址。 + +--- + +## 1. 当前 Git 状态 + +### 1.1 分支和远端 + +- 当前分支:`codex/ui-navigation-s130-s145` +- 跟踪分支:`origin/codex/ui-navigation-s130-s145` +- 当前 HEAD:`176ee24` +- 当前 HEAD 标签:`v1.0.20` +- `origin/main` 也位于 `176ee24` +- Forgejo 远端: + +```text +ssh://git@forgejo-nas:18086/YokiiroBW/astrbot_plugin_imagestudio.git +``` + +### 1.2 最近提交 + +```text +176ee24 release: add ImageStudio 1.0.20 install package +7cfa01b docs: record ImageStudio 1.0.20 deployment verification +2212800 merge: synchronize Forgejo main before 1.0.20 +11b4cda release: complete ImageStudio 1.0.20 workflow audit +b5dd6c5 release: publish ImageStudio 1.0.8 +``` + +### 1.3 重要结论 + +- 当前本地代码版本是 `1.0.32`。 +- Git 历史仍停留在 `1.0.20`。 +- 1.0.21~1.0.32 尚未 commit/push。 +- 本轮没有执行 Git 暂存、提交、推送或发布。 +- 后续必须先审查并保存当前脏工作树,再决定如何整理提交历史。 + +### 1.4 当前主要修改文件 + +已有文件的修改包括但不限于: + +- `CHANGELOG.md` +- `_conf_schema.json` +- `config.yaml` +- `main.py` +- `metadata.yaml` +- `core/config_service.py` +- `core/astrbot_provider_bridge.py` +- `database/models.py` +- `engines/vision_provider.py` +- `engines/single_flow.py` +- 多个 `backend/routes/`、`backend/services/` 文件 +- 多个前端设置、工作流、素材页面 +- `pages/imagestudio/` 和 `web/` 的构建产物 +- AstrBot provider bridge 相关测试 + +### 1.5 当前关键未跟踪文件 + +这些文件绝对不能在迁移时丢失: + +```text +backend/dto/advanced_material_dto.py +backend/routes/advanced_material_routes.py +backend/services/advanced_material_service.py +backend/services/advanced_material_worker_runtime.py +backend/services/advanced_style_set_service.py +backend/services/material_catalog_resolver.py +core/model_route_chain.py +database/migrations/0016_advanced_materials.sql +database/migrations/0017_advanced_wardrobe_items.sql +database/migrations/0018_advanced_style_sets.sql +database/repositories/advanced_material_repository.py +frontend/shared/types/advanced-material.ts +frontend/standalone-web/src/features/materials/ +frontend/standalone-web/src/features/settings/model-route-chain.ts +frontend/tests/advanced-material-upload.test.mjs +tests/test_advanced_material_boundary_services.py +tests/test_advanced_material_migrations.py +tests/test_advanced_material_repository.py +tests/test_advanced_material_worker_recovery.py +tests/test_advanced_material_workflow.py +tests/test_advanced_style_set_workflow.py +tests/test_advanced_style_vision.py +tests/test_material_catalog_resolver.py +tests/test_model_route_chain.py +``` + +发布包 `release/astrbot_plugin_imagestudio-1.0.21.zip` 至 `1.0.31.zip` 也仍是未跟踪文件。 + +目前没有正式生成 `release/astrbot_plugin_imagestudio-1.0.32.zip`;1.0.32 是通过临时 tar 包直接部署到 NAS,NAS 临时包已删除。 + +--- + +## 2. 当前版本状态 + +版本已经统一为 `1.0.32`: + +```text +metadata.yaml: version: 1.0.32 +core/config_service.py: PLUGIN_VERSION = "1.0.32" +config.yaml: plugin.version = 1.0.32 +frontend/package.json: version = 1.0.32 +frontend/package-lock.json: version = 1.0.32 +``` + +`CHANGELOG.md` 已新增 1.0.21~1.0.32 的开发记录,但这些记录仍未提交到 Git。 + +--- + +## 3. 实机环境与部署方式 + +### 3.1 AstrBot 测试环境 + +- NAS 地址:`192.168.31.210` +- AstrBot WebUI:`http://192.168.31.210:26385` +- 容器名:`astrbot-ops-pro` +- NAS 共享目录:`\\YokiiroNAS\Dockers\qqbot\astrbot-ops-pro` +- NAS 插件目录: + +```text +/volume2/Dockers/qqbot/astrbot-ops-pro/data/plugins/astrbot_plugin_imagestudio +``` + +- 插件数据目录: + +```text +/volume2/Dockers/qqbot/astrbot-ops-pro/data/plugin_data/astrbot_plugin_imagestudio +``` + +- SQLite 数据库: + +```text +/volume2/Dockers/qqbot/astrbot-ops-pro/data/plugin_data/astrbot_plugin_imagestudio/db/imagestudio.db +``` + +- 进阶素材文件根: + +```text +/volume2/Dockers/qqbot/astrbot-ops-pro/data/plugin_data/astrbot_plugin_imagestudio/advanced_materials +``` + +### 3.2 SSH + +- SSH 用户:`agent` +- SSH 端口:`77` +- SSH 私钥路径: + +```text +C:\Users\Administrator\.ssh\codex_yokiiro_nas_ed25519 +``` + +- 当前使用的 SSH 客户端: + +```text +C:\Program Files\Git\usr\bin\ssh.exe +``` + +基本连接命令: + +```powershell +& 'C:\Program Files\Git\usr\bin\ssh.exe' ` + -i 'C:\Users\Administrator\.ssh\codex_yokiiro_nas_ed25519' ` + -p 77 ` + -o BatchMode=yes ` + agent@192.168.31.210 +``` + +公钥已经加入 NAS。不要在文档或提交中写入私钥内容、API Key、Forgejo Token 或 AstrBot API Key。 + +### 3.3 部署约定 + +用户明确要求: + +- 不使用 AstrBot 浏览器插件安装 UI; +- 直接覆盖 NAS 插件文件; +- 通过 SSH 重启 Docker 容器; +- 修改后在 `astrbot-ops-pro` 实机验证; +- 没有明确授权时,不触发真实付费生图。 + +部署时要注意: + +1. 备份目录不能放在 `data/plugins/` 内,即使目录以 `.` 开头,AstrBot 仍会把它当插件扫描。 +2. 备份应放在: + +```text +/volume2/Dockers/qqbot/astrbot-ops-pro/data/plugin_backups +``` + +3. 当前 1.0.31 备份位置: + +```text +/volume2/Dockers/qqbot/astrbot-ops-pro/data/plugin_backups/astrbot_plugin_imagestudio-1.0.31-pre-1.0.32 +``` + +4. 插件源码目录可以整体替换,但绝对不要删除 `plugin_data/astrbot_plugin_imagestudio`,数据库、用户设置、进阶素材和生成图片都在那里。 + +### 3.4 当前实机状态 + +- 实际插件目录版本:`1.0.32` +- 日志确认: + +```text +Plugin astrbot_plugin_imagestudio (1.0.32) by YokiiroBW +``` + +- AstrBot 主页面返回 HTTP 200。 +- 插件 Web 路径直接无认证访问会返回 `Missing API key`,这是正常鉴权行为。 +- 本轮部署没有触发真实生图。 + +### 3.5 Docker Health 已知问题 + +容器进程正常运行,WebUI、OneBot、MCP 和插件均已启动,但 Docker 状态显示 `unhealthy`。 + +原因是容器自带 `/usr/local/bin/healthcheck.py` 固定探测: + +```python +PORTS = [6185, 6195, 6199] +``` + +实际监听端口为: + +```text +6185 AstrBot WebUI +6190 desktop assistant WebSocket +6199 另一个 AstrBot HTTP 服务 +``` + +`6195` 未监听,导致健康探针失败。此问题不是 ImageStudio 1.0.32 导致,目前没有修改容器 Healthcheck。 + +另外,启动日志有 `faiss.swigfaiss_avx2` 加载失败后自动回退到普通 faiss,并最终加载成功;这是 LivingMemory/FAISS 环境日志,也不是 ImageStudio 错误。 + +--- + +## 4. 项目开发历史总览 + +以下内容是当前长对话中已经完成或反复修复的主要功能线。 + +### 4.1 UI 与设置页早期建设 + +- 建立设置页和日志页大框架。 +- 适配器卡片改为两列摘要卡,展开后使用独立悬浮配置卡。 +- 适配器卡片边角颜色表示连接状态。 +- 增加 API 地址、Key、模型和生成 endpoint 配置。 +- 增加连接测试、模型发现和 1K/2K/4K 能力测试。 +- 分辨率测试定义: + - 1K:1920×1080 + - 2K:2560×1440 + - 4K:3840×2160 +- V1 地址测试支持自动寻找模型/生图 endpoint。 +- 增加数据备份、导入和导出。 +- 增加模型分工设置、推荐说明和多路交叉审核路由。 +- 增加素材识别提示词选择集和分类下拉限制。 +- 增加群聊白名单、用户白名单与命中规则。 +- 适配器模型选择支持输入和下拉选择。 +- 增加适配器复制能力。 +- 多次修复暗色主题、模态框、下拉框和图标布局。 +- 多次修复鼠标拖选文本越过模态框边界时误关闭的问题。 + +### 4.2 AstrBot 命令工作流 + +- 设计并实现 `/影棚` 和 `/yp` 命令框架。 +- 帮助和状态支持图片化返回。 +- 单图、快速角色、角色工作流接入白名单策略。 +- 完成命令开发队列,并曾发布/推送早期版本。 + +### 4.3 适配器、安装与持久化修复 + +- 修复 AstrBot 插件环境中的绝对 import 路径问题。 +- 修复初次安装数据库表不存在,例如 `material_categories`。 +- 修复插件启动后前端需要手动点击连接的问题。 +- 将测试改为“保存并测试”,确保使用服务端已持久化配置。 +- 修复适配器名称、endpoint 自动回填以及 API Key 无法输入/保存。 +- 修复 401 授权头、endpoint 探测和模型发现兼容性。 +- 修复设置保存后弹回设置页、信息消失等问题。 + +### 4.4 生成页、队列和快速角色 + +- 图片生成支持直接提示词和可选 LLM 扩写。 +- 模型选择统一显示“适配器名称/模型”。 +- 深色主题模型下拉背景修复。 +- 生成后增加素材选择、上传/粘贴和识别入口。 +- 修复队列失败任务不能重试、删除或清理的问题。 +- 快速角色四张图拆成独立并发任务,避免共享超时。 +- 队列标题从裸 UUID 优化为任务概览,例如“快速角色/名字/头像”。 +- 修复快速角色、角色档案和角色工作流之间的数据串线。 +- 修复工作流头像池混入普通单图的问题。 +- 增加快速角色统一度和性别一致性检查。 + +### 4.5 角色工作流二次审计 + +- 依据 `对工作流的二次审计.md` 对现有 `character_gradual` 主线做增量优化。 +- 没有新建平行工作流。 +- 工作流允许进入查看,但仅第一个节点可用。 +- 完成人设导入后依次解锁后续节点。 +- 相关文件: + +```text +docs/workflow-secondary-audit-2026-07-15.md +docs/workflow-secondary-audit-development-queue.md +``` + +### 4.6 进阶素材与多图画风工作流 + +从 1.0.21 开始新增: + +- 普通素材和进阶素材数据库/文件库隔离。 +- 进阶素材先识别,再使用文字提示词生成验证图。 +- 用户确认还原度后才入库。 +- 不还原时可以追加文字调整并生成新轮次。 +- 进阶素材具有更高使用优先级。 +- 画风分类允许 2~8 张图片并发识别。 +- 各图片独立任务、超时、错误和重试。 +- 多图交叉共识区分: + - 核心共同画风 + - 可变特征 + - 内容污染 + - 离群样本 + - 代表样本 +- 生成 compact/standard/detailed 三档胶囊。 +- 使用头像、全身、跨场景三张纯文字验证图。 +- 验证生图不携带源图,专门测试文字胶囊的迁移能力。 +- 三张验证图独立并发、独立队列、独立重试。 +- 历史轮次保留完整三张图。 +- 图片支持点击放大。 +- 删除队列记录后父导入会自动对账为可重试失败。 + +详细设计文档: + +```text +docs/advanced-material-workflow-1.0.21.md +docs/advanced-style-set-workflow-1.0.22.md +``` + +--- + +## 5. 1.0.30~1.0.32 画风算法演进 + +### 5.1 1.0.30 + +- 复验时同时提交代表源图和上一轮三张验证图。 +- 用户文字反馈解析成 increase/decrease/remove/preserve。 +- 增加方向防反转,例如“对比太强”不能被 LLM 改成更高对比。 +- 三张图使用 detailed 胶囊,而不是短共识提示词。 + +### 5.2 1.0.31 + +- 识别维度增加脸型、眼睛、鼻口、头身比、发束、线条拓扑、阴影色相、高光形状和色彩关系。 +- 归一化层保留 attributes,并自动生成 `must_preserve`。 +- 内容污染清单不再原样加入负面提示词。 +- 修复 detailed 胶囊被逗号拆碎和重复拼接。 +- 每张验证图生成后自动使用代表源图进行画风审核。 +- 前端显示自动还原度和主要偏差。 + +### 5.3 1.0.32 已完成内容 + +核心实现: + +```text +backend/services/advanced_style_set_service.py +``` + +已经增加: + +- 固定审核协议 `STYLE_REVIEW_SCHEMA_VERSION = 2`。 +- 固定维度: + - face_structure + - eye_design + - hair_rendering + - linework + - palette_global + - palette_local + - shading + - highlights + - anatomy_scale + - texture_detail + - background_rendering +- 头像、全身和跨场景使用不同维度权重。 +- 复验聚合上一轮自动审核结果。 +- 至少两个场景重复的问题归类为公共画风问题。 +- 单场景问题归类为尺度特定问题。 +- 共识请求新增: + - `prompt_priority_groups` + - `scale_capsules` + - `semantic_risk_audit` +- detailed 胶囊按核心、结构、渲染优先级编译。 +- 公共胶囊限制为 14 条,尺度附加限制为 5 条。 +- 近义提示词尝试去重。 +- 语义风险可以将危险短语替换为安全改写并追加负面保护。 +- 当前轮与上一轮计算总分和场景差值,给出 adopt/keep previous/human review 建议。 + +专项测试位置: + +```text +tests/test_advanced_style_set_workflow.py +``` + +新增测试包括: + +- 固定维度映射与服务端加权。 +- 语义风险改写和尺度胶囊。 +- 公共问题与尺度问题聚合。 + +--- + +## 6. 最近一次本地测试结果 + +使用 Codex 内置 Python: + +```text +C:\Users\Administrator\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe +``` + +完整测试命令: + +```powershell +& 'C:\Users\Administrator\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe' ` + -m pytest tests -q ` + --basetemp '.tmp\pytest-full-1032' +``` + +结果: + +```text +211 passed in 158.00s +``` + +Windows 默认 `%TEMP%\pytest-of-Administrator` 可能遇到权限错误,因此必须把 `--basetemp` 指向工作区 `.tmp`。 + +前端脚本: + +```text +cd frontend +npm run build +npm run typecheck +npm run test:contracts +``` + +当前前端构建产物已经存在: + +```text +pages/imagestudio/assets/index-1rjaQ0Bx.css +pages/imagestudio/assets/index-Dmf_ucVG.js +web/assets/index-Cj5Y2axI.css +web/assets/index-D_8_bZ04.js +``` + +--- + +## 7. 最新实机画风测试记录 + +这是切换账号前最后一次完成的真实导入审计。 + +### 7.1 导入基本信息 + +- 名称:`鹰乃` +- import ID: + +```text +advimp_08c2bfec70f946c79c3012eed683ff39 +``` + +- 状态:`awaiting_review` +- 当前 attempt: + +```text +advattempt_2982f5af0e984d9d83b1315d461ad153 +``` + +- 当前 consensus: + +```text +advconsensus_6aa557c4d53447b8a8adc0fc708fb818 +``` + +- 共识 revision:`1` +- 源图数量:`8` +- 视觉识别/审核路由:`BD 1X/c-gemini-3.5-flash-low` +- 生图路由:`wy-gpt-image-2` + +### 7.2 八张源图 ID + +```text +advsrc_316d0b444c6246488b2b835d6a7c4ccf +advsrc_22b9554920ac4ca68a37ab94d0c520e7 +advsrc_aa10adbb8f134148b6ada680beb51c53 +advsrc_cddc0cc93f544acfadb1899185faf5b0 +advsrc_591d29f0eb664e6e8f8881bd47e35a0a +advsrc_eed35e846abe453b8a18aceec6711b44 +advsrc_b23ebff9d23d4545a23cd7f8e69f3e3e +advsrc_c173ad81306c48b4a765cb3d07f0e4ea +``` + +自动审核使用的三张代表源图: + +```text +advsrc_cddc0cc93f544acfadb1899185faf5b0 +advsrc_eed35e846abe453b8a18aceec6711b44 +advsrc_c173ad81306c48b4a765cb3d07f0e4ea +``` + +### 7.3 三张验证图 + +头像: + +```text +advcase_be6613f946144cc99250e5730229c319 +storage://advanced_materials/style-validations/advimp_08c2bfec70f946c79c3012eed683ff39/advattempt_2982f5af0e984d9d83b1315d461ad153/advcase_be6613f946144cc99250e5730229c319/portrait__advcase_be6613f946144cc99250e5730229c319__task_8270b54fe0f04d0cbfb549c0be943bac_01.png +``` + +全身: + +```text +advcase_077d7c955c094d148a389cc6dd699f74 +storage://advanced_materials/style-validations/advimp_08c2bfec70f946c79c3012eed683ff39/advattempt_2982f5af0e984d9d83b1315d461ad153/advcase_077d7c955c094d148a389cc6dd699f74/fullbody__advcase_077d7c955c094d148a389cc6dd699f74__task_0acaa58ebb434786ad5e060114d5a719_01.png +``` + +跨场景: + +```text +advcase_489905c4d5914a649ae4645945370874 +storage://advanced_materials/style-validations/advimp_08c2bfec70f946c79c3012eed683ff39/advattempt_2982f5af0e984d9d83b1315d461ad153/advcase_489905c4d5914a649ae4645945370874/novel_scene__advcase_489905c4d5914a649ae4645945370874__task_7142736df675413488910fd49bd82259_01.png +``` + +临时只读审计副本位于: + +```text +.tmp/latest_style_audit +``` + +迁移时该目录不是源码必需项;真实数据以 NAS `plugin_data` 为准。 + +### 7.4 肉眼评价 + +这一轮比 1.0.31 前的结果明显更好: + +- 脸型、眼睛、多层虹膜、彩色线稿和腮红已经接近目标风格。 +- 角色与背景的整体完成度提高。 +- 仍未达到系统所显示的 100% 还原度。 +- 肉眼综合约为 72%~78%。 + +主要残留问题: + +1. 头像发顶出现明显粗白色锯齿光带,用户称为“头发光环”。 +2. 跨场景背景蓝粉饱和过强,出现 HDR、镜头光晕和体积光倾向。 +3. 全身角色身体过于娇小、幼态,头身比不足。 +4. 自动审核三张全部给出 `1.0`,但审核文字又承认多项 mismatch,评分自相矛盾。 + +--- + +## 8. 最新问题的精确根因 + +### 8.1 头发光环/白色发带 + +共识提示词反复写入: + +```text +bright horizontal band highlight across the hair crown +prominent bright horizontal band highlight across the crown +bright horizontal highlight across the crown +``` + +该特征同时出现在: + +- 公共共识提示词; +- detailed 胶囊; +- `must_preserve`; +- `prompt_priority_groups.rendering`; +- portrait/fullbody/novel_scene 三个尺度胶囊。 + +负面提示词已经包含: + +```text +floating halo +crown above head +literal ring floating in the air +``` + +所以模型没有生成悬浮在头顶上的圆环,而是生成贴在头发表面的实体粗白条。当前负面保护没有覆盖: + +```text +solid white stripe +continuous luminous band +geometric zigzag bar +uniform horizontal block +``` + +共识的 `semantic_risk_audit` 已把 `angel ring highlight` 改成 `bright horizontal band highlight`,但安全改写本身仍含有强烈的物体化几何词 `band`。 + +这说明 1.0.32 缺少“安全改写的二次审计”。 + +正确方向不是针对某张图硬编码,而是建立通用规则: + +- 如果 safe rewrite 仍包含 ring/band/bar/stripe/halo/crown 等物体或几何实体词,则必须二次改写。 +- 改写必须包含: + - 附着面; + - 材质; + - 透明度; + - 曲率关系; + - 非均匀边缘; + - 不连续性。 + +建议表达: + +```text +broken, semi-transparent satin sheen painted directly across selected hair strands, +following the curved hair volume, with irregular tapered edges and variable opacity +``` + +### 8.2 背景高饱和和强光效 + +当前算法错误地把以下内容提升为核心画风: + +```text +high-key pastel-dominated color palette +soft-focus background with circular bokeh +bright diffused lighting +warm rim lighting +``` + +并且又在尺度胶囊中重复。 + +跨场景内容本身还指定: + +```text +rooftop garden at dawn +atmospheric scene composition +soft-focus depth of field background with circular bokeh light particles +``` + +这些词叠加后,生图模型自然产生: + +- 蓝粉高饱和天空; +- HDR 逆光; +- 镜头光晕; +- 体积光; +- 大量花瓣/光粒子; +- 背景过度写实和复杂。 + +真实源图更加准确的共性应该是: + +- 全局高明度; +- 饱和度随场景变化; +- 人物局部色差清晰; +- 紫、粉、桃色阴影关系; +- 背景通常柔化,但不是固定圆形散景; +- 明亮区域和深色服装仍保留层次。 + +`soft-focus background with circular bokeh` 更接近可变的构图/光效,不应进入核心 `must_preserve`。 + +### 8.3 全身角色体型过于娇小 + +这不是主要由随机种子造成,实际提示词明确包含: + +```text +highly stylized youthful moe aesthetic +pre-adolescent to early adolescent bishoujo style +youthful bishoujo proportions +extremely large eyes +wide face, short vertical length, rounded cheeks +``` + +又要求保持: + +```text +head-to-body ratio +anatomy abstraction +``` + +组合结果是: + +- 头部偏大; +- 四肢偏短; +- 肩胯偏窄; +- 约 4.5~5.5 头身; +- 身体明显幼态。 + +根因是视觉模型把“萌系幼态脸部画法”错误地等同为“实际年龄较小”,再把 `apparent_age` 写入可迁移画风。 + +源图实际是幼态萌系脸,但身体比例、胸腰胯、四肢长度更加成熟。 + +此问题还涉及安全风险:参考图存在内衣/性感服装时,绝不能生成 `pre-adolescent` 或 `early adolescent` 之类未成年年龄词。 + +正确算法应该: + +- 分离 facial age stylization 和 actual subject age; +- `apparent_age` 默认不能进入画风核心胶囊; +- 移除所有未成年年龄词; +- 验证角色明确为 adult heroine/adult character; +- 全身胶囊明确 6.5~7.5 头身和成年四肢比例; +- 允许保留萌系脸型,但不得因此缩短身体。 + +### 8.4 自动审核评分虚高 + +三张验证图当前所有维度都被记录为 `1.0`。 + +但同一份审核结果又明确写出: + +- 头像眼睛青色过饱和; +- 全身发顶高光形状不正确; +- 全身虹膜细节不足; +- 跨场景存在过度体积光、镜头光晕和大气散射。 + +当前服务端在维度覆盖完整时直接采用加权维度总分,模型把所有维度写成 1.0 后就得到 1.0;没有检查分数与文字、delta、prompt patch 是否矛盾。 + +另外: + +- `style_deltas.severity` 如果视觉模型返回 `low/moderate/high` 字符串,当前 `_score()` 无法解析,结果可能变成 `null`。 +- 视觉模型 `provider_fidelity_score` 可能为 0.94,但服务端维度加权会提高到 1.0。 + +--- + +## 9. 后续修复队列(建议版本 1.0.33) + +以下内容尚未实现,是迁移后应优先完成的任务。 + +### P0-1:年龄、脸部幼态和身体比例解耦 + +涉及: + +```text +backend/services/advanced_style_set_service.py +backend/services/material_normalization_service.py +engines/vision_provider.py +tests/test_advanced_style_set_workflow.py +``` + +需要实现: + +1. 视觉识别协议明确输出: + - facial_age_stylization + - actual_age_evidence + - body_maturity_proportions +2. 画风胶囊禁止直接使用 `pre-adolescent`、`early adolescent`、`child` 等年龄词。 +3. 对性感/内衣/成人身体内容增加硬性安全约束:不得与未成年年龄描述共同进入提示词。 +4. 默认验证人物明确为成年角色。 +5. fullbody 尺度指令明确: + - adult proportions + - 6.5–7.5 heads tall + - adult limb length + - youthful stylized face without childlike body proportions +6. 增加测试,确保萌系脸不会把全身缩成幼女比例。 + +### P0-2:评分、文字结论和修正补丁一致性校验 + +当前函数: + +```text +_weighted_style_fidelity_score +_normalize_style_deltas +_review_validation_image +``` + +需要增加: + +1. 如果存在 `mismatches`,总分不能为 1.0。 +2. 如果存在 `prompt_patch`,对应维度不能为 1.0。 +3. 如果存在 `semantic_risks`,对应维度必须封顶。 +4. 服务端最终分数不得高于 provider 总分,建议: + +```text +final_score <= min(weighted_dimension_score, provider_fidelity_score) +``` + +5. 根据 delta severity 扣分。 +6. 支持 severity: + +```text +low -> 0.2 +minor -> 0.25 +moderate -> 0.5 +high -> 0.75 +critical -> 1.0 +``` + +7. 若模型返回全部维度 1.0,但文字存在修正要求,自动标记 `review_inconsistent`。 +8. 不一致审核需要降权或发起一次低成本复核,而不是展示 100%。 + +### P0-3:核心特征证据门控 + +当前服务端保存 `feature_evidence`,但没有用证据约束 `must_preserve`、优先级组和尺度胶囊。 + +需要实现: + +1. 核心特征必须有 `feature_evidence` 支持。 +2. 建议阈值: + - `support_ratio >= 0.6` + - `confidence >= 0.7` +3. 除了样本数量,还要验证跨角色、跨场景和跨色盘支持,防止“所有樱花图都有粉色”被误认为画风。 +4. 没有证据的 `prompt_priority_groups.core` 项目降级到 variable 或删除。 +5. 背景、散景、黎明、花瓣、具体色盘默认视为可变项。 +6. `consensus_style` 为空、`variable_style_features` 为空但仍输出大量核心词时,应判定结构不完整,而不是直接接受。 + +### P0-4:语义风险安全改写的二次审查 + +当前只把 `original_phrase` 替换为 `safe_rewrite`。 + +需要实现: + +1. 对 safe rewrite 再运行一次规则检查。 +2. 对以下词组建立通用物体化风险检测: + +```text +ring +halo +band +bar +stripe +crown +orb +ribbon +frame +glow line +``` + +3. 如果描述的是渲染特征,必须说明附着关系和非实体性。 +4. 自动追加针对改写后剩余风险的负面约束。 +5. 测试应覆盖“悬浮光环已消失但头发变成实体白条”的情况。 + +### P0-5:公共胶囊与尺度胶囊真正去重 + +当前公共提示词与 scale capsule 仍重复: + +```text +high-key pastel +bright horizontal highlight +soft-focus background +circular bokeh +large detailed irises +``` + +需要实现: + +1. 编译尺度胶囊前,以公共胶囊为基准做近义消重。 +2. 尺度胶囊只写该尺度容易丢失的内容。 +3. 头像重点:脸部比例、虹膜、睫毛、鼻口、局部发丝。 +4. 全身重点:身体成熟度、头身比、四肢、轮廓线、服装阴影。 +5. 跨场景重点:人物线稿与背景层次的分离,不重复指定整体色盘和散景。 + +### P0-6:中性验证场景 + +当前 `novel_scene` 使用 `at dawn`,天然诱导蓝粉天空、逆光和高饱和。 + +建议: + +- 头像:中性灰/米色漫射背景。 +- 全身:普通白天或柔和室内光。 +- 跨场景:阴天屋顶、普通街道或室内公共空间,避免 sunrise/sunset/dawn/neon/festival。 +- 验证内容不得自带强烈风格词、镜头光效词和情绪色盘。 + +### P1-1:层级色彩模型 + +不要再用单一 `high saturation` 或 `pastel` 描述全部色彩。 + +建议拆成: + +- global_value_range +- global_saturation_range +- local_color_separation +- shadow_hue_relationship +- highlight_temperature +- character_background_contrast + +审核时不能因为局部眼睛颜色过饱和,就要求整个画面降饱和。 + +### P1-2:背景与人物渲染分别审核 + +当前 `background_rendering` 可能被模型随意给 1.0。 + +建议分别审核: + +- 人物线稿; +- 人物上色; +- 背景线稿/细节; +- 背景色彩; +- 人物与背景的风格统一度; +- 光效是否掩盖风格。 + +### P1-3:前端展示评分可信度 + +前端当前主要显示自动还原度和摘要。 + +建议增加: + +- 分数是否经过一致性校验; +- 维度覆盖率; +- 是否存在 mismatch; +- 是否存在语义风险; +- 当前分数是 provider、服务端加权还是降权结果; +- “100% 但仍有修正项”时显示警告,不显示绿色满分。 + +### P2:自动回归和候选采用策略 + +当前已经计算新旧轮次差值,但没有完全阻止退步版本成为当前候选。 + +可以增加: + +- 新版平均分下降超过 0.02 时默认保留上一候选; +- 任一关键维度明显下降时禁止自动推荐采用; +- 只有公共维度提升且没有新增安全风险时才标记 adopt candidate; +- 用户仍保留最终人工确认权。 + +--- + +## 10. 推荐的 1.0.33 实现顺序 + +建议严格按以下顺序,避免再次只修表象: + +1. 写失败测试:未成年年龄词、全身娇小、满分矛盾、safe rewrite 二次物体化、核心特征无证据、尺度重复。 +2. 修改识别/共识协议,拆分脸部年龄风格和实际年龄。 +3. 增加核心特征证据过滤器。 +4. 修改提示词编译器,增加二次风险审查和跨层消重。 +5. 修改验证默认场景,去除 dawn 等强诱导词。 +6. 修改评分器,加入一致性惩罚和 provider 上限。 +7. 补充前端可信度提示。 +8. 跑专项测试。 +9. 跑完整 211+ 测试。 +10. 版本提升到 `1.0.33`。 +11. 通过 SSH 部署 NAS,重启容器。 +12. 只检查加载和 HTTP,不主动触发付费生成。 +13. 用户重新导入同一批源图后,再读取新旧图片和数据库进行对照。 + +--- + +## 11. 关键代码导航 + +### 11.1 后端主流程 + +```text +backend/services/advanced_style_set_service.py +``` + +重点位置/符号: + +```text +STYLE_REVIEW_SCHEMA_VERSION +STYLE_REVIEW_DIMENSIONS +STYLE_REVIEW_WEIGHTS +AdvancedStyleSetService._review_validation_image +_consensus_instruction +_style_fidelity_review_instruction +_normalize_style_dimension_scores +_weighted_style_fidelity_score +_normalize_style_deltas +_normalize_style_prompt_patch +_normalize_semantic_risks +_aggregate_style_review_feedback +_style_attempt_comparison +_detailed_style_prompt +_detailed_style_negative_prompt +_scale_specific_style_prompt +_scale_transfer_instruction +_apply_semantic_risk_rewrites +_compact_style_prompt_parts +``` + +### 11.2 其他相关后端 + +```text +backend/services/advanced_material_service.py +backend/services/advanced_material_worker_runtime.py +backend/services/material_normalization_service.py +backend/services/model_provider_runtime.py +backend/services/prompt_governance_service.py +database/repositories/advanced_material_repository.py +database/models.py +engines/vision_provider.py +engines/single_flow.py +``` + +### 11.3 数据库迁移 + +```text +database/migrations/0016_advanced_materials.sql +database/migrations/0017_advanced_wardrobe_items.sql +database/migrations/0018_advanced_style_sets.sql +``` + +### 11.4 前端 + +```text +frontend/standalone-web/src/features/materials/AdvancedMaterialImportPage.vue +frontend/standalone-web/src/features/materials/advanced-material-state.ts +frontend/shared/types/advanced-material.ts +frontend/shared/api/endpoints.ts +``` + +### 11.5 测试 + +```text +tests/test_advanced_style_set_workflow.py +tests/test_advanced_style_vision.py +tests/test_advanced_material_workflow.py +tests/test_advanced_material_repository.py +tests/test_advanced_material_boundary_services.py +tests/test_advanced_material_worker_recovery.py +tests/test_advanced_material_migrations.py +tests/test_material_catalog_resolver.py +tests/test_model_route_chain.py +``` + +--- + +## 12. 新 Codex 会话启动提示词 + +迁移完成后,可以直接把以下内容发给新 Codex: + +```text +请先完整读取 docs/project-migration-handoff-2026-07-18.md。 + +这是 AstrBot ImageStudio 的当前开发交接文档。当前工作树从远端 v1.0.20 +继续开发到了本地 1.0.32,但 1.0.21~1.0.32 仍有大量未提交和未跟踪文件。 +禁止 git reset --hard、git clean 或用远端重新覆盖本地。 + +先执行只读检查: +1. git status --short --branch +2. 确认 backend/services/advanced_style_set_service.py 存在 +3. 确认 metadata.yaml 和 core/config_service.py 均为 1.0.32 +4. 阅读交接文档第 7~10 节 + +下一项开发目标是完成文档中的 1.0.33 修复队列: +- 年龄与身体比例解耦 +- 审核分数一致性 +- 核心特征证据门控 +- safe rewrite 二次语义审查 +- 公共与尺度胶囊去重 +- 中性验证场景 + +要求先写测试,再增量修改现有工作流;不要创建平行工作流,不破坏现有前端结构, +不要触发真实付费生图。完成全部本地测试后,再通过 SSH 部署到 astrbot-ops-pro。 +``` + +--- + +## 13. 迁移后验收清单 + +### 文件完整性 + +- [ ] `.git` 已复制。 +- [ ] `backend/services/advanced_style_set_service.py` 存在。 +- [ ] `database/migrations/0016_advanced_materials.sql` 存在。 +- [ ] `database/migrations/0018_advanced_style_sets.sql` 存在。 +- [ ] `frontend/standalone-web/src/features/materials/` 存在。 +- [ ] 所有进阶素材测试文件存在。 +- [ ] release 1.0.21~1.0.31 文件未丢失。 + +### Git 状态 + +- [ ] 当前分支仍为 `codex/ui-navigation-s130-s145`,或已明确创建新的 `codex/` 分支。 +- [ ] 未跟踪的进阶素材文件仍显示在 `git status` 中。 +- [ ] 没有执行 destructive reset/clean。 + +### 版本 + +- [ ] `metadata.yaml` 为 1.0.32。 +- [ ] `core/config_service.py` 为 1.0.32。 +- [ ] `frontend/package.json` 为 1.0.32。 + +### 测试 + +- [ ] 使用工作区 `.tmp` 作为 pytest basetemp。 +- [ ] 完整测试通过。 +- [ ] 前端 typecheck、contracts 和 build 通过。 + +### 实机 + +- [ ] SSH 能连接 `agent@192.168.31.210:77`。 +- [ ] 不使用浏览器安装插件。 +- [ ] 备份放在 `data/plugin_backups`,不放在 `data/plugins`。 +- [ ] 重启 `astrbot-ops-pro` 后日志显示正确版本。 +- [ ] 不删除 `plugin_data/astrbot_plugin_imagestudio`。 +- [ ] 未经授权不触发付费生图。 + +--- + +## 14. 当前任务停止点 + +当前代码和实机均停在 `1.0.32`。 + +已经完成: + +- 画风固定维度评分框架; +- 多场景问题聚合; +- 提示词优先级与尺度胶囊; +- 初版语义风险改写; +- 提示词压缩; +- 新旧轮次比较; +- 211 项测试; +- NAS 实机部署与加载确认; +- 最新导入图片、提示词和数据库的只读审计。 + +尚未完成: + +- 1.0.33 修复队列中的年龄/身体、安全、证据门控、评分一致性、二次语义审查、跨层消重和中性验证场景。 +- 1.0.32 正式 release zip。 +- 1.0.21~1.0.32 的 Git 整理、commit、push 和 Forgejo 发布。 + +不要把“插件已部署到实机”等同于“代码已保存到 Forgejo”。当前最重要的迁移动作仍然是完整保存本地工作树。 diff --git a/engines/single_flow.py b/engines/single_flow.py index f82d58a..5196a80 100644 --- a/engines/single_flow.py +++ b/engines/single_flow.py @@ -270,6 +270,34 @@ def _output_uris( normalized_extension = extension if str(extension).startswith(".") else f".{extension}" scope = request.get("output_scope") if isinstance(request.get("output_scope"), dict) else None task_stem = _safe_file_stem(task.task_id) + if scope and scope.get("kind") == "advanced_material_validation": + import_id = _safe_file_stem(str(scope.get("import_id") or "import")) + attempt_id = _safe_file_stem(str(scope.get("attempt_id") or "attempt")) + attempt_number = _safe_file_stem(str(scope.get("attempt_number") or "1")) + filename = ( + f"validation_{attempt_number}__{attempt_id}__{task_stem}_{index + 1:02d}" + f"{normalized_extension}" + ) + relative = f"attempts/{import_id}/{attempt_id}/{filename}" + thumbnail_relative = f"attempts/{import_id}/{attempt_id}/thumbnail__{filename}" + return ( + f"storage://advanced_materials/{relative}", + f"storage://advanced_materials/{thumbnail_relative}", + ) + + if scope and scope.get("kind") == "advanced_style_validation": + import_id = _safe_file_stem(str(scope.get("import_id") or "import")) + attempt_id = _safe_file_stem(str(scope.get("attempt_id") or "attempt")) + case_id = _safe_file_stem(str(scope.get("case_id") or "case")) + case_key = _safe_file_stem(str(scope.get("case_key") or "validation")) + filename = f"{case_key}__{case_id}__{task_stem}_{index + 1:02d}{normalized_extension}" + relative = f"style-validations/{import_id}/{attempt_id}/{case_id}/{filename}" + thumbnail_relative = f"style-validations/{import_id}/{attempt_id}/{case_id}/thumbnail__{filename}" + return ( + f"storage://advanced_materials/{relative}", + f"storage://advanced_materials/{thumbnail_relative}", + ) + if not scope or not scope.get("round_id") or not scope.get("candidate_id"): filename = f"{task_stem}_{index + 1}{normalized_extension}" return ( @@ -295,6 +323,26 @@ def _output_uris( def _output_scope_metadata(request: dict[str, Any]) -> dict[str, Any]: scope = request.get("output_scope") if isinstance(request.get("output_scope"), dict) else None + if scope and scope.get("kind") == "advanced_material_validation": + allowed = ("kind", "import_id", "attempt_id", "attempt_number") + return { + "scoped_output": True, + "output_scope": { + key: str(scope[key]) + for key in allowed + if scope.get(key) is not None and str(scope.get(key)).strip() + }, + } + if scope and scope.get("kind") == "advanced_style_validation": + allowed = ("kind", "import_id", "attempt_id", "case_id", "case_key") + return { + "scoped_output": True, + "output_scope": { + key: str(scope[key]) + for key in allowed + if scope.get(key) is not None and str(scope.get(key)).strip() + }, + } if not scope or not scope.get("round_id") or not scope.get("candidate_id"): return {} allowed = ( diff --git a/engines/vision_provider.py b/engines/vision_provider.py index 5346935..5ea23fd 100644 --- a/engines/vision_provider.py +++ b/engines/vision_provider.py @@ -16,6 +16,7 @@ JsonDict = dict[str, Any] HttpTransport = Callable[[str, JsonDict, dict[str, str], int], JsonDict] MAX_PROVIDER_JSON_BYTES = 4 * 1024 * 1024 MAX_PROVIDER_ERROR_BYTES = 64 * 1024 +MAX_VISION_IMAGES = 8 class VisionProvider(Protocol): @@ -52,6 +53,7 @@ class VisionRecognitionRequest: tags: tuple[str, ...] = () model: str | None = None metadata: dict[str, Any] = field(default_factory=dict) + image_uris: tuple[str, ...] = () @dataclass(frozen=True) @@ -98,7 +100,7 @@ class OpenAIVisionProvider: provider_id=self.provider_id, error_type="configuration_error", ) - if not (_remote_image_url(request.image_uri) or _remote_image_url(request.thumbnail_uri)): + if not vision_image_urls(request): raise VisionProviderError( "vision image must be supplied as an HTTP(S) URL or data:image URL", provider_id=self.provider_id, @@ -136,6 +138,52 @@ class OpenAIVisionProvider: return _parse_vision_response(self.provider_id, model, response) +class FallbackVisionProvider: + """Try vision providers in priority order and preserve failure context.""" + + def __init__(self, providers: list[VisionProvider]): + if not providers: + raise ValueError("at least one vision provider is required") + self.providers = providers + self.provider_id = providers[0].provider_id + + def recognize_material(self, request: VisionRecognitionRequest) -> VisionRecognitionResult: + failures: list[dict[str, Any]] = [] + for provider in self.providers: + try: + result = provider.recognize_material(request) + if failures: + return VisionRecognitionResult( + provider_id=result.provider_id, + model=result.model, + prompt=result.prompt, + negative_prompt=result.negative_prompt, + tags=result.tags, + confidence=result.confidence, + description=result.description, + structured_data=result.structured_data, + raw_metadata={**result.raw_metadata, "route_fallback_failures": failures}, + ) + return result + except VisionProviderError as exc: + failures.append( + { + "provider_id": exc.provider_id, + "status_code": exc.status_code, + "error_type": exc.error_type, + "message": str(exc), + } + ) + last = failures[-1] + raise VisionProviderError( + "all configured vision routes failed", + provider_id=str(last["provider_id"]), + status_code=last["status_code"], + error_type="fallback_exhausted", + details={"failures": failures}, + ) + + class MockVisionProvider: provider_id = "mock" @@ -180,12 +228,36 @@ def _user_content(request: VisionRecognitionRequest) -> list[dict[str, Any]]: ), } ] - image_url = _remote_image_url(request.image_uri) or _remote_image_url(request.thumbnail_uri) - if image_url: + for image_url in vision_image_urls(request): content.append({"type": "image_url", "image_url": {"url": image_url}}) return content +def vision_image_urls(request: VisionRecognitionRequest) -> tuple[str, ...]: + """Return ordered, deduplicated multimodal inputs for one vision request. + + ``image_uri`` remains the primary-image compatibility field. New callers + may add a bounded group through ``image_uris``. The thumbnail preserves + the legacy fallback behavior and is used only when no source image is + valid, so it never becomes an accidental extra style sample. + """ + + resolved: list[str] = [] + seen: set[str] = set() + for value in (request.image_uri, *request.image_uris): + image_url = _remote_image_url(value) + if image_url is None or image_url in seen: + continue + seen.add(image_url) + resolved.append(image_url) + if len(resolved) >= MAX_VISION_IMAGES: + return tuple(resolved) + if resolved: + return tuple(resolved) + thumbnail_url = _remote_image_url(request.thumbnail_uri) + return (thumbnail_url,) if thumbnail_url else () + + def _system_instruction(request: VisionRecognitionRequest) -> str: configured = str(request.metadata.get("recognition_instruction") or "").strip() fallback = ( diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 8cfdb6a..6560a00 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -1,12 +1,12 @@ { "name": "astrbot-plugin-imagestudio-frontend", - "version": "1.0.20", + "version": "1.0.32", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "astrbot-plugin-imagestudio-frontend", - "version": "1.0.20", + "version": "1.0.32", "dependencies": { "@vitejs/plugin-vue": "^5.2.0", "pinia": "^2.3.0", diff --git a/frontend/package.json b/frontend/package.json index d5d4a50..aa51837 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,6 +1,6 @@ { "name": "astrbot-plugin-imagestudio-frontend", - "version": "1.0.20", + "version": "1.0.32", "private": true, "type": "module", "scripts": { diff --git a/frontend/shared/api/endpoints.ts b/frontend/shared/api/endpoints.ts index f9ab153..096d910 100644 --- a/frontend/shared/api/endpoints.ts +++ b/frontend/shared/api/endpoints.ts @@ -98,6 +98,29 @@ export const endpoints = { materialRecognize: (materialId: string) => `materials/${materialId}/recognize`, materialReRecognize: (materialId: string) => `materials/${materialId}/re-recognize`, materialConfirm: (materialId: string) => `materials/${materialId}/confirm`, + advancedMaterialImports: "advanced-material-imports", + advancedMaterialImportUpload: "advanced-material-imports/upload", + advancedMaterialStyleSetUpload: "advanced-material-imports/style-set/upload", + advancedMaterialImport: (importId: string) => `advanced-material-imports/${importId}`, + advancedMaterialImportDelete: (importId: string) => `advanced-material-imports/${importId}`, + advancedMaterialImportRetry: (importId: string) => `advanced-material-imports/${importId}/retry`, + advancedMaterialStyleSourceRetry: (importId: string, sourceId: string) => + `advanced-material-imports/${importId}/style-sources/${sourceId}/retry`, + advancedMaterialStyleSourceExclude: (importId: string, sourceId: string) => + `advanced-material-imports/${importId}/style-sources/${sourceId}/exclude`, + advancedMaterialStyleConsensus: (importId: string) => + `advanced-material-imports/${importId}/style-consensus`, + advancedMaterialStyleValidationCaseRetry: (importId: string, caseId: string) => + `advanced-material-imports/${importId}/style-validation-cases/${caseId}/retry`, + advancedMaterialValidationAttempts: (importId: string) => + `advanced-material-imports/${importId}/validation-attempts`, + advancedMaterialAttemptAccept: (importId: string, attemptId: string) => + `advanced-material-imports/${importId}/attempts/${attemptId}/accept`, + advancedMaterialAttemptReject: (importId: string, attemptId: string) => + `advanced-material-imports/${importId}/attempts/${attemptId}/reject`, + advancedMaterials: "advanced-materials", + advancedMaterial: (materialId: string) => `advanced-materials/${materialId}`, + materialCatalog: "material-catalog", assetImportPack: "assets/import-pack", wardrobe: (profileId: string) => `profiles/${profileId}/wardrobe`, wardrobeImportMaterial: (profileId: string) => `profiles/${profileId}/wardrobe/import-material`, diff --git a/frontend/shared/types/advanced-material.ts b/frontend/shared/types/advanced-material.ts new file mode 100644 index 0000000..68de00f --- /dev/null +++ b/frontend/shared/types/advanced-material.ts @@ -0,0 +1,342 @@ +export type AdvancedMaterialImportStatus = + | "recognition_queued" + | "pending_recognition" + | "recognizing" + | "pending_validation" + | "ready_for_validation" + | "validation_queued" + | "validating" + | "validation_failed" + | "recognition_failed" + | "pending_review" + | "awaiting_review" + | "adjustment_required" + | "accepted" + | "rejected" + | "failed" + | "cancelled" + | "archived" + +export type AdvancedMaterialValidationAttemptStatus = + | "queued" + | "running" + | "succeeded" + | "completed" + | "awaiting_review" + | "failed" + | "accepted" + | "rejected" + | "cancelled" + +export type AdvancedMaterialStatus = "active" | "archived" + +export type AdvancedStyleSourceStatus = + | "uploaded" + | "recognition_queued" + | "recognizing" + | "recognized" + | "completed" + | "failed" + | "excluded" + | "cancelled" + +export type AdvancedStyleConsensusStatus = + | "queued" + | "running" + | "completed" + | "failed" + +export type AdvancedStyleValidationScenario = "portrait" | "fullbody" | "novel_scene" | string + +export interface AdvancedMaterialError { + code?: string + message?: string + details?: Record + [key: string]: unknown +} + +export interface AdvancedStyleSource { + source_id: string + import_id?: string + sort_order: number + is_primary: boolean + excluded: boolean + status: AdvancedStyleSourceStatus | string + filename?: string | null + source_image_uri?: string | null + source_thumbnail_uri?: string | null + source_image_url?: string | null + source_thumbnail_url?: string | null + image_uri?: string | null + thumbnail_uri?: string | null + image_url?: string | null + thumbnail_url?: string | null + task_id?: string | null + recognition_prompt?: string | null + recognition_negative_prompt?: string | null + recognition_tags: string[] + recognition_result: Record + retry_count?: number + error: AdvancedMaterialError + metadata: Record + created_at?: string + updated_at?: string + completed_at?: string | null + excluded_at?: string | null +} + +export interface AdvancedStyleConsensusFeature { + trait?: string + label?: string + description?: string + supporting_source_ids?: string[] + supporting_images?: string[] + support_ratio?: number + confidence?: number + [key: string]: unknown +} + +export interface AdvancedStyleConsensus { + consensus_id?: string | null + version_id?: string | null + revision?: number | null + version_number?: number | null + status: AdvancedStyleConsensusStatus | string + consensus_style: AdvancedStyleConsensusFeature[] | Record + variable_style_features: AdvancedStyleConsensusFeature[] + source_content_features: AdvancedStyleConsensusFeature[] | string[] + content_leakage_exclusions: string[] + outlier_source_ids: string[] + representative_source_ids: string[] + consensus_confidence?: number | null + generation_capsules: Record + source_ids?: string[] + tags?: string[] + result?: Record + prompt?: string | null + negative_prompt?: string | null + task_id?: string | null + error: AdvancedMaterialError + metadata: Record + created_at?: string + updated_at?: string +} + +export interface AdvancedStyleValidationCase { + case_id: string + import_id?: string + attempt_id?: string | null + scenario: AdvancedStyleValidationScenario + case_key?: string + sort_order?: number + title?: string | null + status: AdvancedMaterialValidationAttemptStatus | string + content_prompt?: string | null + style_prompt?: string | null + final_prompt?: string | null + negative_prompt?: string | null + validation_image_uri?: string | null + validation_thumbnail_uri?: string | null + validation_image_url?: string | null + validation_thumbnail_url?: string | null + task_id?: string | null + provider_id?: string | null + provider_model?: string | null + model_route?: string | null + seed?: number | null + input_image_count?: number + style_scores: Record + style_review?: Record + content_novelty: Record + usage?: Record + fidelity_score?: number | null + error: AdvancedMaterialError + metadata: Record + created_at?: string + updated_at?: string +} + +export interface AdvancedMaterialImport { + import_id: string + category_id?: string | null + display_name: string + source_image_uri?: string | null + source_thumbnail_uri?: string | null + source_image_url?: string | null + source_thumbnail_url?: string | null + status: AdvancedMaterialImportStatus | string + recognition_prompt?: string | null + recognition_negative_prompt?: string | null + recognition_tags: string[] + recognition_result: Record + recognition_model_route?: string | null + prompt_revision?: number | null + current_attempt_id?: string | null + accepted_material_id?: string | null + task_id?: string | null + workflow_kind?: "single" | "style_set" | string + sources?: AdvancedStyleSource[] + consensus?: AdvancedStyleConsensus | null + validation_cases?: AdvancedStyleValidationCase[] + error: AdvancedMaterialError + metadata: Record + created_by?: string | null + created_at: string + updated_at: string +} + +export interface AdvancedMaterialValidationAttempt { + attempt_id: string + import_id: string + attempt_number: number + status: AdvancedMaterialValidationAttemptStatus | string + adjustment_text?: string | null + prompt?: string | null + negative_prompt?: string | null + model_route?: string | null + provider_id?: string | null + provider_model?: string | null + task_id?: string | null + validation_image_uri?: string | null + validation_thumbnail_uri?: string | null + validation_image_url?: string | null + validation_thumbnail_url?: string | null + seed?: number | null + width?: number | null + height?: number | null + usage: Record + fidelity_score?: number | null + decision?: string | null + decision_notes?: string | null + error: AdvancedMaterialError + metadata: Record + validation_mode?: "single" | "style_cross_scene" | string + validation_cases?: AdvancedStyleValidationCase[] + created_at: string + updated_at: string + completed_at?: string | null + decided_at?: string | null +} + +export interface AdvancedMaterial { + material_id: string + import_id: string + accepted_attempt_id: string + category_id?: string | null + display_name: string + source_image_uri?: string | null + source_thumbnail_uri?: string | null + source_image_url?: string | null + source_thumbnail_url?: string | null + validation_image_uri?: string | null + validation_thumbnail_uri?: string | null + validation_image_url?: string | null + validation_thumbnail_url?: string | null + prompt?: string | null + negative_prompt?: string | null + tags: string[] + priority: number + status: AdvancedMaterialStatus | string + capsule: Record + metadata: Record + accepted_at?: string | null + archived_at?: string | null + created_at: string + updated_at: string +} + +export interface AdvancedMaterialImportListResult { + items: AdvancedMaterialImport[] + total: number + page: number + page_size: number +} + +export interface AdvancedMaterialValidationAttemptListResult { + items: AdvancedMaterialValidationAttempt[] + total: number +} + +export interface AdvancedMaterialListResult { + items: AdvancedMaterial[] + total: number + page: number + page_size: number +} + +export interface MaterialCatalogEntry { + material_id: string + material_type?: "advanced" | "standard" | string + library_kind?: "advanced" | "standard" | string + display_name: string + category_id?: string | null + image_uri?: string | null + image_url?: string | null + thumbnail_uri?: string | null + thumbnail_url?: string | null + prompt?: string | null + negative_prompt?: string | null + tags: string[] + priority?: number + status: string + recognition_status?: string + metadata: Record + created_at?: string + updated_at?: string +} + +export interface MaterialCatalogResult { + items: MaterialCatalogEntry[] + total: number + page: number + page_size: number +} + +export interface AdvancedMaterialUploadRequest { + image_data_url: string + display_name: string + category_id: string + filename: string + content_type?: string + size_bytes: number + upload_source: "file" | "paste" | "drop" + metadata: Record +} + +export interface AdvancedMaterialUploadResult { + import: AdvancedMaterialImport + task?: Record | null + task_id?: string | null + queued?: boolean +} + +export interface AdvancedStyleSetUploadImage { + client_source_id?: string + image_data_url: string + filename: string + content_type?: string + size_bytes: number + upload_source: "file" | "paste" | "drop" + sort_order: number + is_primary: boolean +} + +export interface AdvancedStyleSetUploadRequest { + display_name: string + category_id: string + images: AdvancedStyleSetUploadImage[] + metadata: Record +} + +export interface AdvancedMaterialValidationAttemptRequest { + adjustment_text?: string +} + +export interface AdvancedMaterialDecisionRequest { + adjustment_text?: string + style_adjustment_text?: string + validation_instruction?: string + reuse_validation_scenarios?: boolean + decision_notes?: string + fidelity_score?: number +} diff --git a/frontend/shared/types/wardrobe.ts b/frontend/shared/types/wardrobe.ts index 360887d..7fa6180 100644 --- a/frontend/shared/types/wardrobe.ts +++ b/frontend/shared/types/wardrobe.ts @@ -11,6 +11,7 @@ export interface WardrobeItem { last_used_at?: string | null created_at: string updated_at: string + library_kind?: "standard" | "advanced" | string } export interface WardrobeMatchResult { @@ -26,6 +27,7 @@ export interface WardrobeMatchResult { style?: string | null is_favorite: boolean usage_count: number + library_kind?: "standard" | "advanced" | string score: number score_breakdown: Record }> diff --git a/frontend/standalone-web/src/App.vue b/frontend/standalone-web/src/App.vue index b59848d..9b47f9d 100644 --- a/frontend/standalone-web/src/App.vue +++ b/frontend/standalone-web/src/App.vue @@ -10,6 +10,11 @@ import MaterialOperationDialog from "./components/MaterialOperationDialog.vue" import { MATERIAL_BODY_SLOT_OPTIONS } from "./material-labels" import MetricCardGrid from "./components/MetricCardGrid.vue" import StateCard from "./components/StateCard.vue" +import AdvancedMaterialImportPage from "./features/materials/AdvancedMaterialImportPage.vue" +import { + parseMaterialLibraryView, + type MaterialLibraryView, +} from "./features/materials/advanced-material-state" import GalleryPage from "./features/gallery/GalleryPage.vue" import type { GalleryImage } from "./features/gallery/types" import LogsPage from "./features/logs/LogsPage.vue" @@ -125,6 +130,7 @@ import type { WorkflowNodeMaterialBindingsSaveRequest, } from "../../shared/types/workflow-material" import type { WardrobeItem } from "../../shared/types/wardrobe" +import type { MaterialCatalogEntry } from "../../shared/types/advanced-material" import type { UiActionCard, UiDetailRow, UiMetricCard } from "../../shared/types/ui" import { uniqueBy, uniqueStrings } from "../../shared/utils/collections" import { @@ -377,6 +383,8 @@ interface QuickProfileMaterialOption { colors: [string, string, string] imageUrl?: string source?: "backend" + advanced?: boolean + priority?: number } interface QuickProfileMaterialCategorySpec { @@ -650,6 +658,7 @@ const capabilityProfiles = ref([]) const runtimeModelOptions = ref([]) const materialCategories = ref([]) const materials = ref(null) +const materialCatalog = ref([]) const profileWardrobeItemsByProfileId = ref>({}) const profileWardrobeErrorsByProfileId = ref>({}) const profileWardrobeLoadingByProfileId = ref>({}) @@ -659,6 +668,7 @@ const profileGenerationBusyByProfileId = ref>({}) const activeNav = ref(initialNav()) +const materialLibraryView = ref(initialMaterialLibraryView()) const activeGenerateMode = ref("image") const workflowEntryConfirmed = ref(false) const workflowEntryFromProfile = ref(false) @@ -1100,14 +1110,46 @@ const materialCategoryNameById = computed(() => { const entries = materialCategories.value.map((category) => [category.category_id, category.name] as const) return new Map(entries) }) +const materialHeroTitle = computed(() => + materialLibraryView.value === "standard" + ? "角色参考素材工作台" + : materialLibraryView.value === "advanced" + ? "高还原度进阶素材库" + : "进阶素材识别与验证", +) +const materialHeroDetail = computed(() => + materialLibraryView.value === "standard" + ? "集中管理参考图、识别结果、分类、素材包导入和角色衣橱绑定,后续角色工作流会从这里读取可确认素材。" + : materialLibraryView.value === "advanced" + ? "只展示经过源图与验证图人工对照、明确封存的高优先级素材;数据和图片与普通素材严格隔离。" + : "导入源图后自动识别并生成验证图,可根据还原度多轮调整描述,确认满意后再封存入库。", +) +const advancedCatalogMaterials = computed(() => + materialCatalog.value + .filter((entry) => catalogEntryKind(entry) === "advanced" && normalizeStatus(entry.status) !== "archived") + .map(materialFromCatalogEntry), +) +const combinedConfirmedMaterials = computed(() => + uniqueBy( + [ + ...advancedCatalogMaterials.value, + ...(materials.value?.items ?? []).filter( + (material) => normalizeStatus(material.recognition_status) === "confirmed", + ), + ], + (material) => material.material_id, + ), +) const backendQuickProfileMaterialOptions = computed(() => - (materials.value?.items ?? []) - .filter((material) => normalizeStatus(material.recognition_status) === "confirmed") + combinedConfirmedMaterials.value .map(quickProfileMaterialOptionFromBackend) .filter((material): material is QuickProfileMaterialOption => Boolean(material)), ) const quickProfileSelectableMaterials = computed(() => { - return backendQuickProfileMaterialOptions.value + return [...backendQuickProfileMaterialOptions.value].sort((left, right) => { + const advancedDelta = Number(Boolean(right.advanced)) - Number(Boolean(left.advanced)) + return advancedDelta || Number(right.priority || 0) - Number(left.priority || 0) + }) }) const rawMaterialLibraryCards = computed(() => { const backendItems = materials.value?.items ?? [] @@ -1560,7 +1602,11 @@ const selectedProfileWardrobeLoading = computed( ) const profileWardrobeMaterials = computed(() => uniqueBy( - [...(materials.value?.items ?? []), ...Object.values(wardrobeMaterialRecords.value)], + [ + ...advancedCatalogMaterials.value, + ...(materials.value?.items ?? []), + ...Object.values(wardrobeMaterialRecords.value), + ], (material) => material.material_id, ), ) @@ -2387,11 +2433,7 @@ const selectedWorkflowRoundCreateHint = computed(() => { ? `将以 ${likedCount} 张成功且喜欢的候选创建下一轮。` : "请先把 1–3 张生成成功的候选标记为“喜欢”,再开始下一轮。" }) -const confirmedWorkflowMaterials = computed(() => - (materials.value?.items ?? []).filter( - (material) => normalizeStatus(material.recognition_status) === "confirmed", - ), -) +const confirmedWorkflowMaterials = computed(() => combinedConfirmedMaterials.value) const selectedWorkflowNodeMaterialIds = computed( () => workflowNodeMaterialDetail.value?.material_bindings.selected_material_ids ?? [], ) @@ -4305,6 +4347,10 @@ async function loadAll() { lastUpdated.value = new Date().toISOString() } +function initialMaterialLibraryView(): MaterialLibraryView { + return parseMaterialLibraryView(new URLSearchParams(window.location.search).get("materialView")) +} + function initialProfilePageId() { return new URLSearchParams(window.location.search).get("profile")?.trim() ?? "" } @@ -4691,16 +4737,18 @@ async function loadMaterials() { materialActionMessage.value = "" } try { - const [categories, firstMaterialPage] = await Promise.all([ + const [categories, firstMaterialPage, catalogItems] = await Promise.all([ getJson(endpoints.materialCategories), getJson(endpoints.materials, { page: 1, page_size: 100, }), + loadMaterialCatalog(), ]) const materialList = await loadRemainingMaterialPages(firstMaterialPage) materialCategories.value = categories materials.value = materialList + materialCatalog.value = catalogItems if (!materialCategorySyncAttempted.value && bootstrap.value?.permissions.can_manage_materials) { materialCategorySyncAttempted.value = true void ensureDefaultMaterialCategories(categories) @@ -4708,12 +4756,33 @@ async function loadMaterials() { } catch (err) { materialCategories.value = [] materials.value = null + materialCatalog.value = [] materialsError.value = errorMessage(err) } finally { loadingMaterials.value = false } } +async function loadMaterialCatalog(): Promise { + try { + const payload = await getJson<{ items?: MaterialCatalogEntry[] } | MaterialCatalogEntry[]>(endpoints.materialCatalog, { + page: 1, + page_size: 200, + }) + const items = Array.isArray(payload) ? payload : payload.items ?? [] + return items + .filter((item) => normalizeStatus(item.status) !== "archived") + .sort((left, right) => { + const advancedDelta = Number(catalogEntryKind(right) === "advanced") - Number(catalogEntryKind(left) === "advanced") + return advancedDelta || Number(right.priority || 0) - Number(left.priority || 0) + }) + } catch { + // Older backends do not expose the unified catalog. Ordinary materials + // remain usable while the advanced-material migration is unavailable. + return [] + } +} + async function loadRemainingMaterialPages(firstPage: MaterialListResult): Promise { const pageSize = Math.max(1, firstPage.page_size) const pageCount = Math.ceil(firstPage.total / pageSize) @@ -4951,13 +5020,20 @@ function setProfileWardrobeLoading(profileId: string, loading: boolean) { async function hydrateWardrobeMaterials(items: WardrobeItem[]) { const knownIds = new Set([ + ...advancedCatalogMaterials.value.map((material) => material.material_id), ...(materials.value?.items ?? []).map((material) => material.material_id), ...Object.keys(wardrobeMaterialRecords.value), ]) const missingIds = uniqueStrings(items.map((item) => item.material_id).filter((materialId) => !knownIds.has(materialId))) if (!missingIds.length) return const loaded = await Promise.allSettled( - missingIds.map((materialId) => getJson(endpoints.material(materialId))), + missingIds.map((materialId) => + getJson( + materialId.startsWith("advmat_") + ? endpoints.advancedMaterial(materialId) + : endpoints.material(materialId), + ), + ), ) const records = loaded .filter((result): result is PromiseFulfilledResult => result.status === "fulfilled") @@ -4981,6 +5057,19 @@ function selectRailItem(item: NavItem) { setActiveNav(item.key, item.module) } +function setMaterialLibraryView(view: MaterialLibraryView) { + materialLibraryView.value = view + const url = new URL(window.location.href) + url.searchParams.set("view", "materials") + url.searchParams.set("materialView", view) + window.history.replaceState({}, "", `${url.pathname}${url.search}`) +} + +async function handleAdvancedMaterialChanged() { + lastUpdated.value = new Date().toISOString() + materialCatalog.value = await loadMaterialCatalog() +} + function reuseGalleryImage(image: GalleryImage) { selectedGalleryImageId.value = image.image_id selectedGenerateImageId.value = image.image_id @@ -5171,6 +5260,38 @@ function materialCategoryCanonicalName(name: string) { return labels[name] ?? name } +function materialFromCatalogEntry(entry: MaterialCatalogEntry): Material { + const now = new Date().toISOString() + const kind = catalogEntryKind(entry) + const priority = Number(entry.priority || entry.metadata?.material_priority || 0) + return { + material_id: entry.material_id, + category_id: entry.category_id ?? null, + display_name: entry.display_name, + image_uri: entry.image_uri ?? null, + thumbnail_uri: entry.thumbnail_uri ?? null, + image_url: entry.image_url || entry.image_uri || null, + thumbnail_url: entry.thumbnail_url || entry.thumbnail_uri || null, + prompt: entry.prompt ?? null, + negative_prompt: entry.negative_prompt ?? null, + tags: Array.isArray(entry.tags) ? entry.tags : [], + recognition_status: "confirmed", + metadata: { + ...entry.metadata, + material_type: kind, + advanced_material: kind === "advanced", + catalog_priority: priority, + source_image_uri: entry.image_uri ?? null, + }, + created_at: String(entry.created_at || now), + updated_at: String(entry.updated_at || entry.created_at || now), + } +} + +function catalogEntryKind(entry: MaterialCatalogEntry) { + return String(entry.library_kind || entry.material_type || entry.metadata?.library_kind || "standard") +} + function quickProfileMaterialOptionFromBackend(material: Material, index: number): QuickProfileMaterialOption | null { const categoryRecord = materialCategories.value.find((category) => category.category_id === material.category_id) const parentCategory = categoryRecord?.parent_id @@ -5196,6 +5317,8 @@ function quickProfileMaterialOptionFromBackend(material: Material, index: number displayMediaUrl(material.thumbnail_url) || displayMediaUrl(material.image_url), source: "backend", + advanced: material.metadata?.advanced_material === true || material.metadata?.material_type === "advanced", + priority: Number(material.metadata?.catalog_priority || 0), } } @@ -12247,7 +12370,8 @@ function errorMessage(err: unknown) { 无缩略图 - + 进阶素材 · 高优先级 + {{ quickProfileMaterialGroupLabel(reference) }} {{ reference.label }} @@ -12916,18 +13040,53 @@ function errorMessage(err: unknown) {
素材库 -

角色参考素材工作台

-

集中管理参考图、识别结果、分类、素材包导入和角色衣橱绑定,后续角色工作流会从这里读取可确认素材。

+

{{ materialHeroTitle }}

+

{{ materialHeroDetail }}

-
+
+
+ + +
- + + + + + @@ -15006,7 +15175,8 @@ body { } .queue-task-list { - display: grid; + display: flex; + flex-direction: column; gap: 10px; max-height: min(70vh, 760px); overflow-y: auto; @@ -15019,8 +15189,12 @@ body { grid-template-columns: 88px minmax(0, 1fr) 70px; gap: 12px; align-items: center; + flex: 0 0 auto; width: 100%; + height: auto; min-height: 88px; + box-sizing: border-box; + overflow: hidden; border: 1px solid var(--border); border-radius: 8px; padding: 12px; @@ -15038,6 +15212,7 @@ body { .queue-task-status { display: inline-grid; place-items: center; + align-self: center; min-height: 32px; border-radius: 8px; padding: 0 10px; @@ -15117,6 +15292,7 @@ body { .queue-task-meta { display: grid; gap: 4px; + align-self: center; justify-items: end; min-width: 0; } @@ -15230,6 +15406,48 @@ body { gap: 10px; } +.materials-view-tabs { + display: grid; + grid-template-columns: repeat(3, minmax(0, 1fr)); + gap: 8px; + border: 1px solid var(--border); + border-radius: 10px; + padding: 7px; + background: var(--panel); +} + +.materials-view-tabs button { + display: grid; + gap: 3px; + min-width: 0; + min-height: 54px; + border: 1px solid transparent; + border-radius: 8px; + padding: 8px 11px; + color: var(--text); + text-align: left; + background: transparent; +} + +.materials-view-tabs button:hover, +.materials-view-tabs button.active { + border-color: var(--primary); + background: var(--primary-soft); +} + +.materials-view-tabs strong, +.materials-view-tabs small { + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.materials-view-tabs small { + color: var(--text-soft); + font-size: 11px; +} + .materials-hero { display: flex; align-items: center; @@ -21196,6 +21414,10 @@ body { } @media (max-width: 900px) { + .materials-view-tabs { + grid-template-columns: 1fr; + } + .navigation-shell { grid-template-columns: 1fr; padding-bottom: 88px; diff --git a/frontend/standalone-web/src/components/MaterialOperationDialog.vue b/frontend/standalone-web/src/components/MaterialOperationDialog.vue index 72cfd8d..ec91e17 100644 --- a/frontend/standalone-web/src/components/MaterialOperationDialog.vue +++ b/frontend/standalone-web/src/components/MaterialOperationDialog.vue @@ -11,7 +11,7 @@ import type { } from "../../../shared/types/material-operations" import { formatBytes } from "../../../shared/utils/presentation" import { isStorageUri, isSupportedImageStorageUri, storageFilename } from "../../../shared/utils/storage-uri" -import { MATERIAL_BODY_SLOT_OPTIONS } from "../material-labels" +import { MATERIAL_BODY_SLOT_OPTIONS, materialCategoryLabel } from "../material-labels" import { createSafeBackdropClose } from "../safe-backdrop-close" const props = defineProps<{ @@ -60,8 +60,8 @@ const categoryOptions = computed(() => { .map((category) => ({ value: category.category_id, label: category.parent_id - ? `${categoriesById.get(category.parent_id)?.name ?? "未分类"} / ${category.name}` - : category.name, + ? `${materialCategoryLabel(categoriesById.get(category.parent_id)?.name ?? "未分类")} / ${materialCategoryLabel(category.name)}` + : materialCategoryLabel(category.name), })) }) diff --git a/frontend/standalone-web/src/features/materials/AdvancedMaterialImportPage.vue b/frontend/standalone-web/src/features/materials/AdvancedMaterialImportPage.vue new file mode 100644 index 0000000..ac78df9 --- /dev/null +++ b/frontend/standalone-web/src/features/materials/AdvancedMaterialImportPage.vue @@ -0,0 +1,1862 @@ + + +