From b30b0f4834e8c21c3b13e99efd4d1bc65e59665d Mon Sep 17 00:00:00 2001 From: Yuuuu <1569752928@qq.com> Date: Fri, 27 Mar 2026 20:43:07 +0800 Subject: [PATCH] Add reply iteration and training pipeline foundations --- .github/workflows/contract-check.yml | 7 + .openclaw/workspace-state.json | 2 +- AGENTS.md | 15 + CLAUDE.md | 33 +- MEMORY.md | 37 + ...20260327_add_external_qa_followup_state.py | 135 ++++ ...27_add_qa_record_followup_anchor_fields.py | 116 +++ ...327_add_reply_iteration_training_tables.py | 587 ++++++++++++++ backend/app/api/ai_steward_api/__init__.py | 4 + .../ai_steward_api/routes_reply_iteration.py | 263 ++++++ .../routes_training_pipeline.py | 180 +++++ backend/app/models/__init__.py | 22 + backend/app/models/experiment.py | 14 +- backend/app/models/qa_record.py | 9 + backend/app/models/qa_session.py | 10 +- backend/app/models/qa_session_state.py | 4 +- backend/app/models/reply_iteration.py | 152 ++++ backend/app/models/training_pipeline.py | 154 ++++ backend/app/schemas/reply_iteration.py | 56 ++ backend/app/schemas/training_pipeline.py | 33 + .../mixin_answer_entry.py | 9 + .../mixin_answer_mainline.py | 76 +- .../mixin_answer_payload.py | 17 +- .../mixin_answer_precheck.py | 164 +++- .../mixin_answer_retrieval.py | 7 + .../adaptive_rag_service/mixin_core_intent.py | 100 ++- .../mixin_deep_guard_answer.py | 73 +- .../mixin_fast_answer_semantic_p1.py | 9 +- .../mixin_fast_answer_semantic_p2.py | 2 +- .../mixin_followup_anchor.py | 742 +++++++++++++++++ .../mixin_qa_session_core.py | 30 +- .../mixin_requirement_ack_flow.py | 5 +- .../mixin_session_state.py | 55 +- .../services/adaptive_rag_service/service.py | 2 + .../adaptive_rag_service/shared_imports.py | 4 + .../ai_pmo/ai_pmo_intent/intent_resolver.py | 168 ++-- .../ai_pmo/ai_pmo_intent/route_resolver.py | 30 +- .../services/ai_pmo/ai_pmo_intent/shared.py | 125 +-- .../ai_pmo/ai_pmo_kernel/ai_agent_kernel.py | 23 +- .../ai_pmo_typed_executor_common.py | 21 +- .../ai_pmo_kernel_mixins_ingress_render.py | 19 + .../intent/ai_pmo_kernel_mixins_intent_llm.py | 21 + .../ai_pmo_kernel_mixins_intent_rules.py | 51 +- .../ai_pmo_kernel_common_core/constants.py | 37 +- .../ai_pmo_kernel_ingress_flow/mixin_entry.py | 17 +- .../mixin_execute_query_project.py | 15 +- .../services/ai_pmo/draft_confirm_handler.py | 26 +- .../workflow_semantic_planner/__init__.py | 12 + .../workflow_semantic_planner/constants.py | 319 ++++++++ .../workflow_semantic_planner/models.py | 74 ++ .../workflow_semantic_planner/service.py | 747 ++++++++++++++++++ .../mixin_receive_capture_flow.py | 3 + .../mixin_receive_routing.py | 46 +- .../mixin_reply_llm_core.py | 34 +- .../mixin_context_prefill_a.py | 2 +- .../feishu_signal_pipeline/mixin_core_base.py | 33 +- .../mixin_followup_a.py | 3 +- .../mixin_gate_dispatch.py | 3 + .../mixin_intent_gate_core.py | 2 +- .../mixin_lookup_and_block.py | 48 +- .../mixin_message_utils_a.py | 6 +- .../mixin_process_message_default.py | 15 + .../mixin_process_message_helpers_a.py | 29 +- .../mixin_process_message_helpers_b.py | 20 +- .../mixin_prompt_profile_runtime.py | 9 + .../app/services/prompt_release/__init__.py | 3 + .../app/services/prompt_release/service.py | 156 ++++ .../app/services/reply_iteration/__init__.py | 3 + .../app/services/reply_iteration/service.py | 511 ++++++++++++ .../mixin_capture_entry.py | 16 +- .../mixin_pipeline_cache.py | 3 +- .../mixin_entry_orchestrate.py | 14 +- .../signal_source_orchestration/shared.py | 6 +- .../services/training_pipeline/__init__.py | 3 + .../app/services/training_pipeline/service.py | 422 ++++++++++ backend/app/utils/thread_context.py | 18 + ...adaptive_rag_external_followup_contract.py | 484 ++++++++++++ backend/tests/test_ai_pmo_ingress_mainline.py | 22 +- .../tests/test_ai_pmo_task_intent_contract.py | 12 +- backend/tests/test_draft_confirm_handler.py | 48 ++ .../test_external_qa_followup_migration.py | 96 +++ .../test_feishu_pipeline_queue_contract.py | 55 ++ ...t_feishu_receive_orchestration_contract.py | 4 +- ...est_qa_record_followup_anchor_migration.py | 92 +++ backend/tests/test_reply_iteration_api.py | 283 +++++++ backend/tests/test_reply_iteration_service.py | 253 ++++++ ...test_reply_iteration_training_migration.py | 104 +++ backend/tests/test_semantic_lint.py | 47 ++ .../tests/test_training_pipeline_service.py | 196 +++++ .../tests/test_workflow_semantic_planner.py | 44 ++ scripts/semantic_lint.py | 195 +++++ scripts/semantic_lint_baseline.txt | 15 + task_instance_20260326.xlsx | Bin 0 -> 445397 bytes task_instance_20260327_today.xlsx | Bin 0 -> 263455 bytes 94 files changed, 7538 insertions(+), 653 deletions(-) create mode 100644 MEMORY.md create mode 100644 backend/alembic/versions/20260327_add_external_qa_followup_state.py create mode 100644 backend/alembic/versions/20260327_add_qa_record_followup_anchor_fields.py create mode 100644 backend/alembic/versions/20260327_add_reply_iteration_training_tables.py create mode 100644 backend/app/api/ai_steward_api/routes_reply_iteration.py create mode 100644 backend/app/api/ai_steward_api/routes_training_pipeline.py create mode 100644 backend/app/models/reply_iteration.py create mode 100644 backend/app/models/training_pipeline.py create mode 100644 backend/app/schemas/reply_iteration.py create mode 100644 backend/app/schemas/training_pipeline.py create mode 100644 backend/app/services/adaptive_rag_service/mixin_followup_anchor.py create mode 100644 backend/app/services/ai_pmo/workflow_semantic_planner/__init__.py create mode 100644 backend/app/services/ai_pmo/workflow_semantic_planner/constants.py create mode 100644 backend/app/services/ai_pmo/workflow_semantic_planner/models.py create mode 100644 backend/app/services/ai_pmo/workflow_semantic_planner/service.py create mode 100644 backend/app/services/prompt_release/__init__.py create mode 100644 backend/app/services/prompt_release/service.py create mode 100644 backend/app/services/reply_iteration/__init__.py create mode 100644 backend/app/services/reply_iteration/service.py create mode 100644 backend/app/services/training_pipeline/__init__.py create mode 100644 backend/app/services/training_pipeline/service.py create mode 100644 backend/tests/test_adaptive_rag_external_followup_contract.py create mode 100644 backend/tests/test_external_qa_followup_migration.py create mode 100644 backend/tests/test_qa_record_followup_anchor_migration.py create mode 100644 backend/tests/test_reply_iteration_api.py create mode 100644 backend/tests/test_reply_iteration_service.py create mode 100644 backend/tests/test_reply_iteration_training_migration.py create mode 100644 backend/tests/test_semantic_lint.py create mode 100644 backend/tests/test_training_pipeline_service.py create mode 100644 backend/tests/test_workflow_semantic_planner.py create mode 100644 scripts/semantic_lint.py create mode 100644 scripts/semantic_lint_baseline.txt create mode 100644 task_instance_20260326.xlsx create mode 100644 task_instance_20260327_today.xlsx diff --git a/.github/workflows/contract-check.yml b/.github/workflows/contract-check.yml index 65ae838c..84e65398 100644 --- a/.github/workflows/contract-check.yml +++ b/.github/workflows/contract-check.yml @@ -10,6 +10,8 @@ on: - "frontend/src/types/**" - "docs/architecture/**" - "scripts/check_contract_sync.sh" + - "scripts/semantic_lint.py" + - "scripts/semantic_lint_baseline.txt" - ".github/workflows/contract-check.yml" push: branches: [ main, master ] @@ -21,6 +23,8 @@ on: - "frontend/src/types/**" - "docs/architecture/**" - "scripts/check_contract_sync.sh" + - "scripts/semantic_lint.py" + - "scripts/semantic_lint_baseline.txt" - ".github/workflows/contract-check.yml" jobs: @@ -31,3 +35,6 @@ jobs: - name: Run contract sync check run: | bash scripts/check_contract_sync.sh + - name: Run semantic lint + run: | + python3 scripts/semantic_lint.py diff --git a/.openclaw/workspace-state.json b/.openclaw/workspace-state.json index f4d03dda..07fe13b6 100644 --- a/.openclaw/workspace-state.json +++ b/.openclaw/workspace-state.json @@ -1,4 +1,4 @@ { "version": 1, - "onboardingCompletedAt": "2026-03-26T16:00:06.817Z" + "setupCompletedAt": "2026-03-26T16:00:06.817Z" } diff --git a/AGENTS.md b/AGENTS.md index 7ad4204c..1d4c1e1b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -86,6 +86,7 @@ frontend/ # React 前端 - 禁止在前端组件内直接调用 `fetch`，必须通过 `frontend/src/api/` 封装层 - 前端状态管理：服务端数据用 React Query，本地 UI 状态用 `useState` - 禁止模型兜底回复：模型失败/超时/空响应/结构化解析失败时，必须显式报错并保留真实失败原因，禁止返回固定兜底文案冒充成功结果 +- 业务语义治理：凡是会决定 `project.create / signal_source.onboard / followup.* / query vs execute` 的中文关键词、正则、`looks_like_*`、`*_HINTS/*_KEYWORDS`，只能定义在 `backend/app/services/ai_pmo/workflow_semantic_planner/` 或 prompt/catalog 配置层；其它目录只允许做文本清洗、ID/URL/repo/locator 抽取与结构化结果解析 ## 9. 新增代码的参考模式 @@ -176,3 +177,17 @@ frontend/ # React 前端 - 单任务预估改动超过200行 → 拆分执行 - 发生 context 不足时 → 停止并输出已完成部分 声明 `[CONTEXT: LIMIT]`，不要截断输出 + + +## 安全约束（必须严格遵守） + +### 🚫 绝对禁止的操作： +- 禁止删除任何文件或目录（rm、rmdir、unlink、trash 等） +- 禁止执行带 -rf、--force、-y 参数的命令 +- 禁止 DROP TABLE、TRUNCATE 等数据库破坏性操作 +- 禁止修改 /etc、/sys、/boot 等系统目录 + +### ✅ 文件操作前必须： +1. 先列出将要操作的文件路径 +2. 明确告知用户操作后果 +3. 等待用户输入"确认"后才能执行 \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md index 7755f081..c4a3b388 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -92,7 +92,8 @@ backend/ - 新增：`backend/app/core/startup/ai_pmo_ingress_async.py`（AI PMO 入站异步任务轮询启动循环） - 新增：`backend/app/utils/timezone.py`（统一北京时间工具：`now_cn_aware/now_cn_naive`） - 新增：`backend/app/utils/audited_write.py`（写接口审计上下文、caller 归一、北京时间格式化） -- 新增：`backend/app/utils/thread_context.py`（飞书线程/消息锚点归一：优先 root/thread/reply_to，其次 source_message_id） +- 新增：`backend/app/utils/thread_context.py`（飞书线程/消息锚点归一 + 外部问答 `conversation_scope_key` 生成：reply/root/thread 用于 reply anchor，稳定会话 scope 默认使用 `chat_id + sender_open_id`，不再用 `source_message_id` 作为外部连续会话真锚点） +- 新增：`backend/app/services/adaptive_rag_service/mixin_followup_anchor.py`（外部问答追问锚定与候选澄清：单候选自动绑定、多候选文本编号澄清、元追问优先锚定最近 PMFlow 回复） - 新增：`backend/app/middleware/audit_context.py`（请求级 trace/interface/caller 注入） - 新增：`backend/app/api/audit.py`（审计查询接口：`GET /audit/operations`） - 新增：`backend/app/services/audit_query_service/service.py`（operation_logs 过滤与序列化） @@ -100,6 +101,8 @@ backend/ - 更新：`backend/app/services/signal/signal_source_orchestration/mixin_registry_execute.py`（需求点归一化/去重与 `materialize_requirement_sources` 落库 helper，`raw_context` 记录来源与原始需求点） - 更新：`backend/app/services/signal/signal_capture_service/mixin_new_project.py`、`mixin_capture_legacy.py`（飞书 `new_project` 自动立项收口，项目创建与信号源落库失败即回滚，避免半成功状态） - 新增：`backend/alembic/versions/20260311_shift_all_timestamps_to_beijing.py`（全库历史时间 +8h，数据库默认时区切到 Asia/Shanghai） +- 新增：`backend/alembic/versions/20260327_add_external_qa_followup_state.py`（`qa_sessions` 增加 `external_conversation_key`，`qa_session_states` 增加外部追问待澄清状态字段） +- 新增：`backend/alembic/versions/20260327_add_qa_record_followup_anchor_fields.py`（`qa_records` 增加外部会话 scope / reply anchor / 路由快照字段，支撑跨 session 追问锚定与元追问追溯） - 新增：`backend/alembic/versions/20260312_add_signal_planner_fields.py`（signals 增加 planner 状态字段与索引） - 新增：`backend/app/services/signal/signal_planner/signal_strategic_analysis_service.py`（Signal Planner 写回收口） - 新增：`backend/app/services/integrations/feishu_outbox/service.py`（复用 reply_hash 的 outbox 入队收口） @@ -137,6 +140,8 @@ backend/ - 新增：`backend/tests/test_feishu_card_action_contract.py`（飞书卡片回调契约回归：动作解析与事件分发） - 新增：`backend/tests/test_feishu_pipeline_queue_contract.py`（飞书待确认队列契约回归：action card 元数据与 follow-up 唯一目标约束） - 新增：`backend/tests/test_feishu_receive_orchestration_contract.py`（飞书入口编排契约回归：bot 过滤、空文本分支、capture/finalize 编排） +- 新增：`backend/tests/test_adaptive_rag_external_followup_contract.py`（外部 QA 连续追问契约：真实 session 复用、最近回复锚定、编号澄清选择） +- 新增：`backend/tests/test_external_qa_followup_migration.py`（外部 QA 会话 migration 回归：列/索引新增与回滚） - 新增：`backend/tests/test_draft_generator_service.py`（草稿生成服务回归：PM 评审草稿包含相似项目、MVP、前景与需求清单） - 新增：`backend/tests/test_signal_planner_contract.py`（Signal Planner 契约回归：最新宪章加载、prompt 注入、无宪章降级） - 新增：`backend/tests/test_ai_prompt_registry_contract.py`（Prompt registry 契约回归：覆盖率与元数据完整性） @@ -178,6 +183,16 @@ backend/ - 移除：`backend/.env.example`（配置模板统一到根目录 `.env.example`） - 新增：`backend/app/utils/project_command_utils.py`（项目创建标题/描述提取与归一化辅助） - 新增：`backend/app/services/ai_pmo_intent_routing.py`（AI PMO 意图/路由常量与解析器收口，统一 `family.action` 路由映射） +- 新增：`backend/app/services/ai_pmo/workflow_semantic_planner/`（统一业务语义规划层：唯一允许承载 workflow bundle 语义关键词/正则/兼容 helper 的目录） +- 新增：`backend/app/models/reply_iteration.py`（回复质量迭代模型：`QualityAsset/QualityAssetPair/JudgeRun/OptimizerCandidate/PromptRelease`） +- 新增：`backend/app/models/training_pipeline.py`（训练/微调管线模型：`TrainingDataset/TrainingJob/TrainingEvaluation/TrainedModelArtifact/TrainedModelDeployment`） +- 新增：`backend/app/services/reply_iteration/service.py`（反馈中心提升为学习资产、裁判分桶、候选改动、prompt release trial 服务） +- 新增：`backend/app/services/training_pipeline/service.py`（训练数据集、训练作业、评测、artifact promote、deployment 决策服务） +- 新增：`backend/app/services/prompt_release/service.py`（只读 QA prompt release 版本管理与 serving 渲染优先级） +- 新增：`backend/app/api/ai_steward_api/routes_reply_iteration.py`（AI Steward 回复质量闭环接口：反馈提升、judge-runs、candidates、prompt-releases、trials） +- 新增：`backend/app/api/ai_steward_api/routes_training_pipeline.py`（AI Steward 训练管线接口：datasets、jobs、evaluations、artifacts、deployments） +- 新增：`backend/alembic/versions/20260327_add_reply_iteration_training_tables.py`（回复质量迭代/训练管线主迁移：学习资产表、prompt release、训练数据集、训练作业与 experiment 扩展字段） +- 新增：`backend/tests/test_reply_iteration_service.py`、`test_training_pipeline_service.py`、`test_reply_iteration_api.py`、`test_reply_iteration_training_migration.py`（回复质量闭环与训练管线基础回归） - 新增：`backend/app/services/ai_pmo/ai_pmo_kernel/ai_pmo_workflow_runtime.py`（AI PMO `ContextAssembler` + `WorkflowRegistry/WorkflowHandler` 运行时骨架） - 新增：`backend/app/services/ai_pmo_decision_runtime.py`（AI PMO 决策脑层：`Strategic/Tactical/Simulation/ExecutionPolicy/DecisionEngine`） - 新增：`backend/app/services/ai_pmo/ai_pmo_kernel/ai_pmo_reply_renderer.py`（AI PMO 回执渲染出口 `ReplyRenderer`） @@ -503,12 +518,19 @@ uvicorn app.main:app --reload --host 0.0.0.0 --port 8000 - 草稿确认只认显式 `reply_to_message_id` + 明确草稿动作（`确认/修改/取消`）或显式 `work_item_id`；草稿确认必须校验 `draft_version`，并通过 `confirm_message_id` 防重放；草稿超时取消统一由 `draft_expiry_worker` + `feishu_reply_outbox` 处理 - AI PMO 执行层必须统一产出 `execution_result.action_contract` 与 `action_param_source`，并写入 `operation_execution_ledger`；禁止在执行链路旁路写副作用且不入账 - AI PMO 写操作幂等以消息级锚点为准：优先使用 `source_message_id` / `feishu_message_id` 作为执行账本幂等键，标题/正文仅用于业务内容，不得参与重复执行判定 +- PMFlow 业务语义治理：会决定 `project.create / signal_source.onboard / followup.* / query vs execute` 的中文关键词、正则、`looks_like_*`、`*_HINTS/*_KEYWORDS` 只能定义在 `backend/app/services/ai_pmo/workflow_semantic_planner/` 或 prompt/catalog 配置层；其他目录仅允许做文本清洗、ID/URL/repo/locator 抽取与结构化结果解析 +- `scripts/semantic_lint.py` + `scripts/semantic_lint_baseline.txt` 为语义治理守门脚本；CI 会阻止新的散落语义进入非 allowlist 目录，baseline 仅记录已知兼容残留 +- 只读问答链路的 prompt 读取优先级固定为：`prompt registry manifest 校验 -> active prompt release -> 代码 seed prompt fallback`；业务服务禁止直接绕过 `PromptReleaseService` 拼接已纳管的 read-only QA prompt +- 回复质量迭代与训练管线的原始反馈入口统一复用 `feedback_center_records` / `qa_records` / `ai_call_logs`；新增 `quality_assets/training_datasets` 只能作为派生层，禁止再造平行原始数据主表 +- 训练/微调 artifact 只能先进入 `trained_model_artifacts -> trained_model_deployments` 内部候选链路，再绑定到 `low/high` 逻辑槽位；禁止在产品/API/日志直接暴露训练后真实底模名 ## 9. 新增代码的参考模式 - 新增后端接口：参考 `backend/app/api/sstc.py` 的结构 - 项目创建接口：参考 `backend/app/api/ai_steward_api/routes_capture.py`（`POST /ai-steward/project-from-text` 统一 `{code,message,data}`，返回 `signal_sources`） - 模型路由配置接口：参考 `backend/app/api/model_routing.py`（`GET/PUT /model-routing/functions/{function_name}`，仅管理员可写并写入 `operation_logs`） - `model-routing` 只暴露逻辑层字段：`function_name/tier_alias/source/rule_name/rule_priority/last_execution`；`PUT` 仅接受 `tier_alias=low|high` +- 回复质量闭环接口：参考 `backend/app/api/ai_steward_api/routes_reply_iteration.py`（`POST /ai-steward/feedback-center/items/{id}/promote`、`/reply-iteration/judge-runs/candidates/prompt-releases/trials`） +- 训练/微调管线接口：参考 `backend/app/api/ai_steward_api/routes_training_pipeline.py`（`GET/POST /ai-steward/training/datasets/jobs`、`GET /training/jobs/{id}/evaluations`、`POST /training/artifacts/{id}/promote`、`POST /training/deployments/{id}/decision`） - 任务包中心接口：参考 `backend/app/api/task_briefs.py`（`/task-briefs/center/templates/runs/generate/contract-sync`） - KG 上下文闭环接口：参考 `backend/app/api/knowledge_graph.py`（`GET /ai-steward/knowledge-graph/capability-summary`、`POST /ai-steward/knowledge-graph/verify-context-consumption`） - 需求点落信号源：参考 `backend/app/services/signal/signal_source_orchestration/mixin_registry_execute.py`（`materialize_requirement_sources` 负责归一、去重与 `raw_context` 持久化） @@ -596,6 +618,15 @@ uvicorn app.main:app --reload --host 0.0.0.0 --port 8000 - 飞书回复线程锚点抽取同时兼容 event 顶层与 message/content 内字段，并对 event/message 的嵌套结构做递归兜底；若 Feishu SDK 返回的 reply 关系字段在更深层对象里，也必须纳入线程锚点，不可只读 `message.content` - 飞书异步入站队列在 `ai_orchestration_runs.result_payload.task_payload` 中必须保留 `thread_context`，worker 重放时不得仅依赖 `source_message_id`，否则 reply-thread 会在异步链路丢锚点 - 飞书纯问答直答不再注入群聊级 `project_id` 兜底上下文；只有显式 reply-thread / follow-up 线程锚点命中时，才允许继承上一轮语义上下文，禁止把群里最近项目当成普通新问题的默认场景 +- 外部渠道 `asked_by=None` 的 QA 也必须 materialize 到真实 `qa_sessions`：统一用 `external_conversation_key` 复用会话，并允许 `qa_session_states` 持久化 `pending_clarification` +- 外部 QA 的 `external_conversation_key` 在 Feishu 场景下必须写稳定 `conversation_scope_key`：默认 `chat_id + sender_open_id`，仅 sender_open_id 缺失时才降级到 `chat_id + sender`；禁止再把 `source_message_id` 当成连续问答 scope key +- “这个/刚才/那条” 这类外部追问默认按连续对话处理：同线程/同发送者最近 5 分钟内仅 1 条 PMFlow 回复时直接绑定；有 2-3 条候选时返回文本编号澄清；只有完全无锚点时才返回 `no_anchor_found` +- 外部 QA 若存在显式 `reply_to_message_id`，必须优先按消息级锚定处理：先反查 `feishu_reply_outbox.sent_message_id` 还原被引用的 PMFlow 回复；若消息 ID 无法映射，也要回退到当前入站消息携带的 `closure_turns/closure_dialogue` 恢复上一轮机器人回复，再回退到 session/recent candidates；禁止把“直接引用机器人回复”的消息仍判成无锚点 +- 外部 QA 的“追问歧义”与“模型/上游失败”必须分开：前者返回 `clarification_code`（如 `ambiguous_recent_reply` / `no_anchor_found`）及候选列表，后者继续保留真实 provider/空响应错误，禁止共用模糊兜底文案 +- 外部 QA 的 `qa_records` 必须持久化 `conversation_scope_key/source_message_id/source_chat_id/source_sender_open_id/reply_to_message_id/root_message_id/anchor_kind/anchor_ref/routing_snapshot`，用于回答“为什么没接上上一条”“为什么走了候选澄清”“上一条回复走的是 low 还是 high” +- 元追问（如“哪个模型回复的”“为什么那条报错”“你刚才那句什么意思”）必须优先锚定最近一条 PMFlow 回复；对外只允许返回 `planned_tier/executed_tier/route_source/route_rule_name/routing_decision` 这类 low/high 路由语义，禁止暴露真实 provider/model 名称 +- Prompt release 目前只接入只读回复链路（AdaptiveRAG / query.read_only）；写操作 workflow 仍使用代码 prompt 与显式人工 gate，避免训练试验误触执行副作用 +- 训练自动化/影子回放当前只允许覆盖只读问答链路；`project.create/signal.create/signal_source.onboard/task.create` 等写操作 workflow 继续排除在自动训练与自动试验之外 - 成员/负载类问答（如“杨宇现在负载情况如何”）会优先走 `users + user_workloads` 的确定性直查；只有姓名/账号能唯一匹配时才直接返回数据库负载答案，不再把项目列表或历史上下文混入负载结论 - 会话命中 `session.last_intent=draft_pending_confirm` 不再自动劫持普通消息；只有明确 `reply_to_message_id` 且消息本身是草稿动作，或显式 `work_item_id` 命中挂起草稿时，才进入草稿确认处理器 - 飞书 follow-up 状态追问不再猜测“最近一条处理项”；只有显式 reply 锚点或唯一业务目标匹配时才允许继续查询，避免多个话题并行时串线 diff --git a/MEMORY.md b/MEMORY.md new file mode 100644 index 00000000..07582bdd --- /dev/null +++ b/MEMORY.md @@ -0,0 +1,37 @@ +# Memory + +## 飞书工单查询配置 + +当用户在飞书问"查询今天的工单"、"查询昨天的工单"时，**必须查询外部数据库**： + +### 数据库连接 +- **Host**: 173.1.1.32:5432 +- **Database**: middle_platform +- **User**: readonly +- **Password**: readonly@#2025 +- **Schema**: plat_task_center + +### 执行命令 +```bash +docker exec pmflow-db psql "postgresql://readonly:readonly%40%232025@173.1.1.32:5432/middle_platform" -c "SQL语句" -x +``` + +### 默认查询 SQL +```sql +SELECT + task_code as 工单编号, + task_name as 工单名称, + excutor_name as 执行人, + status as 状态, + start_time as 开始时间 +FROM plat_task_center.task_instance a +WHERE a.start_time >= CURRENT_DATE + AND a.start_time < CURRENT_DATE + INTERVAL '1 day' + AND a.ext3 IN ('90101', '901') +ORDER BY a.start_time DESC +LIMIT 50; +``` + +### ⚠️ 重要提醒 +**这是外部数据库 (middle_platform)，不是 PMFlow 数据库！** +飞书查询工单时，**不要查询 PMFlow 的 tasks 表**！ diff --git a/backend/alembic/versions/20260327_add_external_qa_followup_state.py b/backend/alembic/versions/20260327_add_external_qa_followup_state.py new file mode 100644 index 00000000..89f7e41c --- /dev/null +++ b/backend/alembic/versions/20260327_add_external_qa_followup_state.py @@ -0,0 +1,135 @@ +"""add external qa followup state fields + +Revision ID: 20260327_add_external_qa_followup_state +Revises: 20260327_cleanup_model_routing_legacy_names +Create Date: 2026-03-27 +""" + +from __future__ import annotations + +from alembic import op +import sqlalchemy as sa + +try: + from sqlalchemy.dialects.postgresql import JSONB +except Exception: # pragma: no cover + JSONB = sa.JSON + + +revision = "20260327_add_external_qa_followup_state" +down_revision = "20260327_cleanup_model_routing_legacy_names" +branch_labels = None +depends_on = None + + +def _json_type(bind): + return JSONB() if bind.dialect.name == "postgresql" else sa.JSON() + + +def _table_exists(bind, table_name: str) -> bool: + return sa.inspect(bind).has_table(table_name) + + +def _column_exists(bind, table_name: str, column_name: str) -> bool: + inspector = sa.inspect(bind) + try: + columns = inspector.get_columns(table_name) + except Exception: + return False + return any(str(col.get("name")) == column_name for col in columns) + + +def _index_exists(bind, table_name: str, index_name: str) -> bool: + inspector = sa.inspect(bind) + try: + indexes = inspector.get_indexes(table_name) + except Exception: + return False + return any(idx.get("name") == index_name for idx in indexes) + + +def _create_index_if_not_exists( + bind, + index_name: str, + table_name: str, + columns: list[str], + *, + unique: bool = False, +) -> None: + if not _index_exists(bind, table_name, index_name): + op.create_index(index_name, table_name, columns, unique=unique) + + +def _drop_index_if_exists(bind, index_name: str, table_name: str) -> None: + if _index_exists(bind, table_name, index_name): + op.drop_index(index_name, table_name=table_name) + + +def upgrade() -> None: + bind = op.get_bind() + + if _table_exists(bind, "qa_sessions"): + if not _column_exists(bind, "qa_sessions", "external_conversation_key"): + with op.batch_alter_table("qa_sessions") as batch_op: + batch_op.add_column(sa.Column("external_conversation_key", sa.VARCHAR(length=160), nullable=True)) + _create_index_if_not_exists( + bind, + "ix_qa_sessions_external_conversation_key", + "qa_sessions", + ["external_conversation_key"], + ) + _create_index_if_not_exists( + bind, + "uq_qa_sessions_tenant_external_conversation_key", + "qa_sessions", + ["tenant_id", "external_conversation_key"], + unique=True, + ) + + if _table_exists(bind, "qa_session_states"): + if not _column_exists(bind, "qa_session_states", "pending_clarification"): + with op.batch_alter_table("qa_session_states") as batch_op: + batch_op.add_column(sa.Column("pending_clarification", _json_type(bind), nullable=True)) + if not _column_exists(bind, "qa_session_states", "pending_clarification_expires_at"): + with op.batch_alter_table("qa_session_states") as batch_op: + batch_op.add_column(sa.Column("pending_clarification_expires_at", sa.TIMESTAMP(), nullable=True)) + _create_index_if_not_exists( + bind, + "ix_qa_session_states_pending_clarification_expires_at", + "qa_session_states", + ["pending_clarification_expires_at"], + ) + + +def downgrade() -> None: + bind = op.get_bind() + + if _table_exists(bind, "qa_session_states"): + _drop_index_if_exists( + bind, + "ix_qa_session_states_pending_clarification_expires_at", + "qa_session_states", + ) + if _column_exists(bind, "qa_session_states", "pending_clarification_expires_at") or _column_exists( + bind, "qa_session_states", "pending_clarification" + ): + with op.batch_alter_table("qa_session_states") as batch_op: + if _column_exists(bind, "qa_session_states", "pending_clarification_expires_at"): + batch_op.drop_column("pending_clarification_expires_at") + if _column_exists(bind, "qa_session_states", "pending_clarification"): + batch_op.drop_column("pending_clarification") + + if _table_exists(bind, "qa_sessions"): + _drop_index_if_exists( + bind, + "uq_qa_sessions_tenant_external_conversation_key", + "qa_sessions", + ) + _drop_index_if_exists( + bind, + "ix_qa_sessions_external_conversation_key", + "qa_sessions", + ) + if _column_exists(bind, "qa_sessions", "external_conversation_key"): + with op.batch_alter_table("qa_sessions") as batch_op: + batch_op.drop_column("external_conversation_key") diff --git a/backend/alembic/versions/20260327_add_qa_record_followup_anchor_fields.py b/backend/alembic/versions/20260327_add_qa_record_followup_anchor_fields.py new file mode 100644 index 00000000..f3d6c387 --- /dev/null +++ b/backend/alembic/versions/20260327_add_qa_record_followup_anchor_fields.py @@ -0,0 +1,116 @@ +"""add qa record followup anchor fields + +Revision ID: 20260327_add_qa_record_followup_anchor_fields +Revises: 20260327_add_external_qa_followup_state +Create Date: 2026-03-27 +""" + +from __future__ import annotations + +from alembic import op +import sqlalchemy as sa + +try: + from sqlalchemy.dialects.postgresql import JSONB +except Exception: # pragma: no cover + JSONB = sa.JSON + + +revision = "20260327_add_qa_record_followup_anchor_fields" +down_revision = "20260327_add_external_qa_followup_state" +branch_labels = None +depends_on = None + + +def _json_type(bind): + return JSONB() if bind.dialect.name == "postgresql" else sa.JSON() + + +def _table_exists(bind, table_name: str) -> bool: + return sa.inspect(bind).has_table(table_name) + + +def _column_exists(bind, table_name: str, column_name: str) -> bool: + inspector = sa.inspect(bind) + try: + columns = inspector.get_columns(table_name) + except Exception: + return False + return any(str(col.get("name")) == column_name for col in columns) + + +def _index_exists(bind, table_name: str, index_name: str) -> bool: + inspector = sa.inspect(bind) + try: + indexes = inspector.get_indexes(table_name) + except Exception: + return False + return any(idx.get("name") == index_name for idx in indexes) + + +def _create_index_if_not_exists( + bind, + index_name: str, + table_name: str, + columns: list[str], + *, + unique: bool = False, +) -> None: + if not _index_exists(bind, table_name, index_name): + op.create_index(index_name, table_name, columns, unique=unique) + + +def _drop_index_if_exists(bind, index_name: str, table_name: str) -> None: + if _index_exists(bind, table_name, index_name): + op.drop_index(index_name, table_name=table_name) + + +def upgrade() -> None: + bind = op.get_bind() + if not _table_exists(bind, "qa_records"): + return + + columns = [ + ("source_message_id", sa.VARCHAR(length=128), True), + ("source_chat_id", sa.VARCHAR(length=128), True), + ("source_sender_open_id", sa.VARCHAR(length=128), True), + ("reply_to_message_id", sa.VARCHAR(length=128), True), + ("root_message_id", sa.VARCHAR(length=128), True), + ("conversation_scope_key", sa.VARCHAR(length=160), True), + ("anchor_kind", sa.VARCHAR(length=32), True), + ("anchor_ref", sa.VARCHAR(length=128), True), + ("routing_snapshot", _json_type(bind), True), + ] + for name, column_type, nullable in columns: + if _column_exists(bind, "qa_records", name): + continue + with op.batch_alter_table("qa_records") as batch_op: + batch_op.add_column(sa.Column(name, column_type, nullable=nullable)) + + _create_index_if_not_exists(bind, "ix_qa_records_source_message_id", "qa_records", ["source_message_id"]) + _create_index_if_not_exists(bind, "ix_qa_records_conversation_scope_key", "qa_records", ["conversation_scope_key"]) + + +def downgrade() -> None: + bind = op.get_bind() + if not _table_exists(bind, "qa_records"): + return + + _drop_index_if_exists(bind, "ix_qa_records_conversation_scope_key", "qa_records") + _drop_index_if_exists(bind, "ix_qa_records_source_message_id", "qa_records") + + for name in ( + "routing_snapshot", + "anchor_ref", + "anchor_kind", + "conversation_scope_key", + "root_message_id", + "reply_to_message_id", + "source_sender_open_id", + "source_chat_id", + "source_message_id", + ): + if not _column_exists(bind, "qa_records", name): + continue + with op.batch_alter_table("qa_records") as batch_op: + batch_op.drop_column(name) diff --git a/backend/alembic/versions/20260327_add_reply_iteration_training_tables.py b/backend/alembic/versions/20260327_add_reply_iteration_training_tables.py new file mode 100644 index 00000000..763da22c --- /dev/null +++ b/backend/alembic/versions/20260327_add_reply_iteration_training_tables.py @@ -0,0 +1,587 @@ +"""add reply iteration and training pipeline tables + +Revision ID: 20260327_add_reply_iteration_training_tables +Revises: 20260325_add_feishu_reply_outbox_sent_message_id, 20260327_add_qa_record_followup_anchor_fields +Create Date: 2026-03-27 +""" + +from __future__ import annotations + +from alembic import op +import sqlalchemy as sa + +try: + from sqlalchemy.dialects.postgresql import JSONB +except Exception: # pragma: no cover + JSONB = sa.JSON + + +revision = "20260327_add_reply_iteration_training_tables" +down_revision = ( + "20260325_add_feishu_reply_outbox_sent_message_id", + "20260327_add_qa_record_followup_anchor_fields", +) +branch_labels = None +depends_on = None + + +def _json_type(bind): + return JSONB() if bind.dialect.name == "postgresql" else sa.JSON() + + +def _table_exists(bind, table_name: str) -> bool: + return sa.inspect(bind).has_table(table_name) + + +def _column_exists(bind, table_name: str, column_name: str) -> bool: + inspector = sa.inspect(bind) + try: + columns = inspector.get_columns(table_name) + except Exception: + return False + return any(str(column.get("name")) == column_name for column in columns) + + +def _index_exists(bind, table_name: str, index_name: str) -> bool: + inspector = sa.inspect(bind) + try: + indexes = inspector.get_indexes(table_name) + except Exception: + return False + return any(str(index.get("name")) == index_name for index in indexes) + + +def _create_index_if_missing(bind, table_name: str, index_name: str, columns: list[str], *, unique: bool = False) -> None: + if not _index_exists(bind, table_name, index_name): + op.create_index(index_name, table_name, columns, unique=unique) + + +def _drop_index_if_exists(bind, table_name: str, index_name: str) -> None: + if _index_exists(bind, table_name, index_name): + op.drop_index(index_name, table_name=table_name) + + +def _base_columns() -> list[sa.Column]: + return [ + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False, server_default=sa.func.now()), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False, server_default=sa.func.now()), + ] + + +def _create_quality_assets(bind) -> None: + if _table_exists(bind, "quality_assets"): + return + op.create_table( + "quality_assets", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("asset_type", sa.VARCHAR(length=16), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="approved"), + sa.Column("source_feedback_record_id", sa.Integer(), sa.ForeignKey("feedback_center_records.id", ondelete="SET NULL"), nullable=True), + sa.Column("qa_record_id", sa.Integer(), sa.ForeignKey("qa_records.id", ondelete="SET NULL"), nullable=True), + sa.Column("ai_call_log_id", sa.Integer(), nullable=True), + sa.Column("prompt_key", sa.VARCHAR(length=128), nullable=True), + sa.Column("workflow_type", sa.VARCHAR(length=64), nullable=True), + sa.Column("asked_via", sa.VARCHAR(length=32), nullable=True), + sa.Column("planned_tier", sa.VARCHAR(length=16), nullable=True), + sa.Column("executed_tier", sa.VARCHAR(length=16), nullable=True), + sa.Column("route_source", sa.VARCHAR(length=32), nullable=True), + sa.Column("route_rule_name", sa.VARCHAR(length=255), nullable=True), + sa.Column("question_text", sa.Text(), nullable=False), + sa.Column("answer_text", sa.Text(), nullable=False), + sa.Column("corrected_answer", sa.Text(), nullable=True), + sa.Column("source_snapshot", _json_type(bind), nullable=True), + sa.Column("tags", _json_type(bind), nullable=True), + sa.Column("notes", sa.Text(), nullable=True), + sa.Column("approved_by", sa.BigInteger(), nullable=True), + sa.Column("approved_at", sa.VARCHAR(length=64), nullable=True), + *_base_columns(), + ) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_tenant_id", ["tenant_id"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_project_id", ["project_id"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_asset_type", ["asset_type"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_status", ["status"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_source_feedback_record_id", ["source_feedback_record_id"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_qa_record_id", ["qa_record_id"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_ai_call_log_id", ["ai_call_log_id"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_prompt_key", ["prompt_key"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_workflow_type", ["workflow_type"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_asked_via", ["asked_via"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_planned_tier", ["planned_tier"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_executed_tier", ["executed_tier"]) + _create_index_if_missing(bind, "quality_assets", "ix_quality_assets_approved_by", ["approved_by"]) + + +def _create_quality_asset_pairs(bind) -> None: + if _table_exists(bind, "quality_asset_pairs"): + return + op.create_table( + "quality_asset_pairs", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("pair_type", sa.VARCHAR(length=24), nullable=False, server_default="preference"), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="approved"), + sa.Column("chosen_asset_id", sa.Integer(), sa.ForeignKey("quality_assets.id", ondelete="CASCADE"), nullable=False), + sa.Column("rejected_asset_id", sa.Integer(), sa.ForeignKey("quality_assets.id", ondelete="CASCADE"), nullable=False), + sa.Column("reason_text", sa.Text(), nullable=True), + sa.Column("approved_by", sa.BigInteger(), nullable=True), + sa.Column("approved_at", sa.VARCHAR(length=64), nullable=True), + *_base_columns(), + ) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_tenant_id", ["tenant_id"]) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_project_id", ["project_id"]) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_pair_type", ["pair_type"]) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_status", ["status"]) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_chosen_asset_id", ["chosen_asset_id"]) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_rejected_asset_id", ["rejected_asset_id"]) + _create_index_if_missing(bind, "quality_asset_pairs", "ix_quality_asset_pairs_approved_by", ["approved_by"]) + + +def _create_judge_runs(bind) -> None: + if _table_exists(bind, "judge_runs"): + return + op.create_table( + "judge_runs", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("asset_id", sa.Integer(), sa.ForeignKey("quality_assets.id", ondelete="CASCADE"), nullable=True), + sa.Column("pair_id", sa.Integer(), sa.ForeignKey("quality_asset_pairs.id", ondelete="CASCADE"), nullable=True), + sa.Column("prompt_key", sa.VARCHAR(length=128), nullable=True), + sa.Column("workflow_type", sa.VARCHAR(length=64), nullable=True), + sa.Column("asked_via", sa.VARCHAR(length=32), nullable=True), + sa.Column("planned_tier", sa.VARCHAR(length=16), nullable=True), + sa.Column("executed_tier", sa.VARCHAR(length=16), nullable=True), + sa.Column("route_rule_name", sa.VARCHAR(length=255), nullable=True), + sa.Column("judge_status", sa.VARCHAR(length=16), nullable=False, server_default="completed"), + sa.Column("bucket_key", sa.VARCHAR(length=255), nullable=False), + sa.Column("rule_score", sa.Float(), nullable=True), + sa.Column("llm_score", sa.Float(), nullable=True), + sa.Column("overall_score", sa.Float(), nullable=True), + sa.Column("findings", _json_type(bind), nullable=True), + sa.Column("llm_evidence", _json_type(bind), nullable=True), + sa.Column("metadata_json", _json_type(bind), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_judge_runs_tenant_id", ["tenant_id"]), + ("ix_judge_runs_project_id", ["project_id"]), + ("ix_judge_runs_asset_id", ["asset_id"]), + ("ix_judge_runs_pair_id", ["pair_id"]), + ("ix_judge_runs_prompt_key", ["prompt_key"]), + ("ix_judge_runs_workflow_type", ["workflow_type"]), + ("ix_judge_runs_asked_via", ["asked_via"]), + ("ix_judge_runs_planned_tier", ["planned_tier"]), + ("ix_judge_runs_executed_tier", ["executed_tier"]), + ("ix_judge_runs_judge_status", ["judge_status"]), + ("ix_judge_runs_bucket_key", ["bucket_key"]), + ): + _create_index_if_missing(bind, "judge_runs", index_name, columns) + + +def _create_optimizer_candidates(bind) -> None: + if _table_exists(bind, "optimizer_candidates"): + return + op.create_table( + "optimizer_candidates", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("judge_run_id", sa.Integer(), sa.ForeignKey("judge_runs.id", ondelete="CASCADE"), nullable=False), + sa.Column("candidate_type", sa.VARCHAR(length=32), nullable=False), + sa.Column("target_type", sa.VARCHAR(length=32), nullable=False), + sa.Column("target_ref", sa.VARCHAR(length=255), nullable=False), + sa.Column("status", sa.VARCHAR(length=24), nullable=False, server_default="draft"), + sa.Column("suggestion", _json_type(bind), nullable=True), + sa.Column("evidence", _json_type(bind), nullable=True), + sa.Column("notes", sa.Text(), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_optimizer_candidates_tenant_id", ["tenant_id"]), + ("ix_optimizer_candidates_project_id", ["project_id"]), + ("ix_optimizer_candidates_judge_run_id", ["judge_run_id"]), + ("ix_optimizer_candidates_candidate_type", ["candidate_type"]), + ("ix_optimizer_candidates_target_type", ["target_type"]), + ("ix_optimizer_candidates_target_ref", ["target_ref"]), + ("ix_optimizer_candidates_status", ["status"]), + ): + _create_index_if_missing(bind, "optimizer_candidates", index_name, columns) + + +def _create_prompt_releases(bind) -> None: + if _table_exists(bind, "prompt_releases"): + return + op.create_table( + "prompt_releases", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("prompt_key", sa.VARCHAR(length=128), nullable=False), + sa.Column("version", sa.Integer(), nullable=False, server_default="1"), + sa.Column("body_snapshot", sa.Text(), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="draft"), + sa.Column("notes", sa.Text(), nullable=True), + sa.Column("created_by", sa.BigInteger(), nullable=True), + sa.Column("activated_by", sa.BigInteger(), nullable=True), + sa.Column("activated_at", sa.VARCHAR(length=64), nullable=True), + *_base_columns(), + sa.UniqueConstraint("tenant_id", "prompt_key", "version", name="uq_prompt_releases_tenant_key_version"), + ) + for index_name, columns in ( + ("ix_prompt_releases_tenant_id", ["tenant_id"]), + ("ix_prompt_releases_prompt_key", ["prompt_key"]), + ("ix_prompt_releases_status", ["status"]), + ("ix_prompt_releases_created_by", ["created_by"]), + ("ix_prompt_releases_activated_by", ["activated_by"]), + ): + _create_index_if_missing(bind, "prompt_releases", index_name, columns) + + +def _create_training_datasets(bind) -> None: + if _table_exists(bind, "training_datasets"): + return + op.create_table( + "training_datasets", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("dataset_type", sa.VARCHAR(length=16), nullable=False), + sa.Column("version", sa.VARCHAR(length=64), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="ready"), + sa.Column("sample_count", sa.Integer(), nullable=False, server_default="0"), + sa.Column("selection_rules", _json_type(bind), nullable=True), + sa.Column("channel_scope", _json_type(bind), nullable=True), + sa.Column("notes", sa.Text(), nullable=True), + sa.Column("created_by", sa.BigInteger(), nullable=True), + *_base_columns(), + sa.UniqueConstraint("tenant_id", "dataset_type", "version", name="uq_training_datasets_tenant_type_version"), + ) + for index_name, columns in ( + ("ix_training_datasets_tenant_id", ["tenant_id"]), + ("ix_training_datasets_project_id", ["project_id"]), + ("ix_training_datasets_dataset_type", ["dataset_type"]), + ("ix_training_datasets_version", ["version"]), + ("ix_training_datasets_status", ["status"]), + ("ix_training_datasets_created_by", ["created_by"]), + ): + _create_index_if_missing(bind, "training_datasets", index_name, columns) + + +def _create_training_dataset_items(bind) -> None: + if _table_exists(bind, "training_dataset_items"): + return + op.create_table( + "training_dataset_items", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("dataset_id", sa.Integer(), sa.ForeignKey("training_datasets.id", ondelete="CASCADE"), nullable=False), + sa.Column("quality_asset_id", sa.Integer(), sa.ForeignKey("quality_assets.id", ondelete="CASCADE"), nullable=True), + sa.Column("quality_asset_pair_id", sa.Integer(), sa.ForeignKey("quality_asset_pairs.id", ondelete="CASCADE"), nullable=True), + sa.Column("redacted_snapshot", _json_type(bind), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_training_dataset_items_tenant_id", ["tenant_id"]), + ("ix_training_dataset_items_dataset_id", ["dataset_id"]), + ("ix_training_dataset_items_quality_asset_id", ["quality_asset_id"]), + ("ix_training_dataset_items_quality_asset_pair_id", ["quality_asset_pair_id"]), + ): + _create_index_if_missing(bind, "training_dataset_items", index_name, columns) + + +def _create_training_jobs(bind) -> None: + if _table_exists(bind, "training_jobs"): + return + op.create_table( + "training_jobs", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("dataset_id", sa.Integer(), sa.ForeignKey("training_datasets.id", ondelete="CASCADE"), nullable=False), + sa.Column("job_type", sa.VARCHAR(length=16), nullable=False), + sa.Column("base_model_family", sa.VARCHAR(length=64), nullable=False), + sa.Column("target_slot", sa.VARCHAR(length=16), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="queued"), + sa.Column("provider_backend", sa.VARCHAR(length=64), nullable=False), + sa.Column("artifact_ref", sa.VARCHAR(length=255), nullable=True), + sa.Column("metrics_json", _json_type(bind), nullable=True), + sa.Column("created_by", sa.BigInteger(), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_training_jobs_tenant_id", ["tenant_id"]), + ("ix_training_jobs_project_id", ["project_id"]), + ("ix_training_jobs_dataset_id", ["dataset_id"]), + ("ix_training_jobs_job_type", ["job_type"]), + ("ix_training_jobs_base_model_family", ["base_model_family"]), + ("ix_training_jobs_target_slot", ["target_slot"]), + ("ix_training_jobs_status", ["status"]), + ("ix_training_jobs_created_by", ["created_by"]), + ): + _create_index_if_missing(bind, "training_jobs", index_name, columns) + + +def _create_training_job_runs(bind) -> None: + if _table_exists(bind, "training_job_runs"): + return + op.create_table( + "training_job_runs", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("training_job_id", sa.Integer(), sa.ForeignKey("training_jobs.id", ondelete="CASCADE"), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="queued"), + sa.Column("provider_run_ref", sa.VARCHAR(length=255), nullable=True), + sa.Column("metrics_json", _json_type(bind), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_training_job_runs_tenant_id", ["tenant_id"]), + ("ix_training_job_runs_training_job_id", ["training_job_id"]), + ("ix_training_job_runs_status", ["status"]), + ): + _create_index_if_missing(bind, "training_job_runs", index_name, columns) + + +def _create_training_evaluations(bind) -> None: + if _table_exists(bind, "training_evaluations"): + return + op.create_table( + "training_evaluations", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("training_job_id", sa.Integer(), sa.ForeignKey("training_jobs.id", ondelete="CASCADE"), nullable=False), + sa.Column("evaluation_type", sa.VARCHAR(length=32), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="pending"), + sa.Column("score", sa.Float(), nullable=True), + sa.Column("evaluation_summary", _json_type(bind), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_training_evaluations_tenant_id", ["tenant_id"]), + ("ix_training_evaluations_training_job_id", ["training_job_id"]), + ("ix_training_evaluations_evaluation_type", ["evaluation_type"]), + ("ix_training_evaluations_status", ["status"]), + ): + _create_index_if_missing(bind, "training_evaluations", index_name, columns) + + +def _create_trained_model_artifacts(bind) -> None: + if _table_exists(bind, "trained_model_artifacts"): + return + op.create_table( + "trained_model_artifacts", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("training_job_id", sa.Integer(), sa.ForeignKey("training_jobs.id", ondelete="CASCADE"), nullable=False), + sa.Column("artifact_ref", sa.VARCHAR(length=255), nullable=False), + sa.Column("base_model_family", sa.VARCHAR(length=64), nullable=False), + sa.Column("target_slot", sa.VARCHAR(length=16), nullable=False), + sa.Column("status", sa.VARCHAR(length=16), nullable=False, server_default="pending_eval"), + sa.Column("metrics_json", _json_type(bind), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_trained_model_artifacts_tenant_id", ["tenant_id"]), + ("ix_trained_model_artifacts_training_job_id", ["training_job_id"]), + ("ix_trained_model_artifacts_artifact_ref", ["artifact_ref"]), + ("ix_trained_model_artifacts_base_model_family", ["base_model_family"]), + ("ix_trained_model_artifacts_target_slot", ["target_slot"]), + ("ix_trained_model_artifacts_status", ["status"]), + ): + _create_index_if_missing(bind, "trained_model_artifacts", index_name, columns) + + +def _create_trained_model_deployments(bind) -> None: + if _table_exists(bind, "trained_model_deployments"): + return + op.create_table( + "trained_model_deployments", + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("artifact_id", sa.Integer(), sa.ForeignKey("trained_model_artifacts.id", ondelete="CASCADE"), nullable=False), + sa.Column("deployment_status", sa.VARCHAR(length=16), nullable=False, server_default="candidate"), + sa.Column("bound_tier", sa.VARCHAR(length=16), nullable=False), + sa.Column("effective_scope", _json_type(bind), nullable=True), + sa.Column("decision", sa.VARCHAR(length=24), nullable=True), + sa.Column("notes", sa.Text(), nullable=True), + sa.Column("decided_by", sa.BigInteger(), nullable=True), + sa.Column("decided_at", sa.VARCHAR(length=64), nullable=True), + *_base_columns(), + ) + for index_name, columns in ( + ("ix_trained_model_deployments_tenant_id", ["tenant_id"]), + ("ix_trained_model_deployments_artifact_id", ["artifact_id"]), + ("ix_trained_model_deployments_deployment_status", ["deployment_status"]), + ("ix_trained_model_deployments_bound_tier", ["bound_tier"]), + ("ix_trained_model_deployments_decision", ["decision"]), + ("ix_trained_model_deployments_decided_by", ["decided_by"]), + ): + _create_index_if_missing(bind, "trained_model_deployments", index_name, columns) + + +def _add_experiment_columns(bind) -> None: + if not _table_exists(bind, "experiments"): + return + additions = [ + ("experiment_type", sa.VARCHAR(length=64), True), + ("baseline_release_id", sa.Integer(), True), + ("candidate_release_id", sa.Integer(), True), + ("scope_json", _json_type(bind), True), + ("result_summary", _json_type(bind), True), + ("decision", sa.VARCHAR(length=24), True), + ] + for column_name, column_type, nullable in additions: + if _column_exists(bind, "experiments", column_name): + continue + with op.batch_alter_table("experiments") as batch_op: + batch_op.add_column(sa.Column(column_name, column_type, nullable=nullable)) + for index_name, columns in ( + ("ix_experiments_experiment_type", ["experiment_type"]), + ("ix_experiments_baseline_release_id", ["baseline_release_id"]), + ("ix_experiments_candidate_release_id", ["candidate_release_id"]), + ("ix_experiments_decision", ["decision"]), + ): + _create_index_if_missing(bind, "experiments", index_name, columns) + + +def upgrade() -> None: + bind = op.get_bind() + _create_quality_assets(bind) + _create_quality_asset_pairs(bind) + _create_judge_runs(bind) + _create_optimizer_candidates(bind) + _create_prompt_releases(bind) + _create_training_datasets(bind) + _create_training_dataset_items(bind) + _create_training_jobs(bind) + _create_training_job_runs(bind) + _create_training_evaluations(bind) + _create_trained_model_artifacts(bind) + _create_trained_model_deployments(bind) + _add_experiment_columns(bind) + + +def downgrade() -> None: + bind = op.get_bind() + + for index_name in ( + "ix_experiments_decision", + "ix_experiments_candidate_release_id", + "ix_experiments_baseline_release_id", + "ix_experiments_experiment_type", + ): + _drop_index_if_exists(bind, "experiments", index_name) + if _table_exists(bind, "experiments"): + for column_name in ( + "decision", + "result_summary", + "scope_json", + "candidate_release_id", + "baseline_release_id", + "experiment_type", + ): + if _column_exists(bind, "experiments", column_name): + with op.batch_alter_table("experiments") as batch_op: + batch_op.drop_column(column_name) + + for table_name, index_names in ( + ("trained_model_deployments", [ + "ix_trained_model_deployments_decided_by", + "ix_trained_model_deployments_decision", + "ix_trained_model_deployments_bound_tier", + "ix_trained_model_deployments_deployment_status", + "ix_trained_model_deployments_artifact_id", + "ix_trained_model_deployments_tenant_id", + ]), + ("trained_model_artifacts", [ + "ix_trained_model_artifacts_status", + "ix_trained_model_artifacts_target_slot", + "ix_trained_model_artifacts_base_model_family", + "ix_trained_model_artifacts_artifact_ref", + "ix_trained_model_artifacts_training_job_id", + "ix_trained_model_artifacts_tenant_id", + ]), + ("training_evaluations", [ + "ix_training_evaluations_status", + "ix_training_evaluations_evaluation_type", + "ix_training_evaluations_training_job_id", + "ix_training_evaluations_tenant_id", + ]), + ("training_job_runs", [ + "ix_training_job_runs_status", + "ix_training_job_runs_training_job_id", + "ix_training_job_runs_tenant_id", + ]), + ("training_jobs", [ + "ix_training_jobs_created_by", + "ix_training_jobs_status", + "ix_training_jobs_target_slot", + "ix_training_jobs_base_model_family", + "ix_training_jobs_job_type", + "ix_training_jobs_dataset_id", + "ix_training_jobs_project_id", + "ix_training_jobs_tenant_id", + ]), + ("training_dataset_items", [ + "ix_training_dataset_items_quality_asset_pair_id", + "ix_training_dataset_items_quality_asset_id", + "ix_training_dataset_items_dataset_id", + "ix_training_dataset_items_tenant_id", + ]), + ("training_datasets", [ + "ix_training_datasets_created_by", + "ix_training_datasets_status", + "ix_training_datasets_version", + "ix_training_datasets_dataset_type", + "ix_training_datasets_project_id", + "ix_training_datasets_tenant_id", + ]), + ("prompt_releases", [ + "ix_prompt_releases_activated_by", + "ix_prompt_releases_created_by", + "ix_prompt_releases_status", + "ix_prompt_releases_prompt_key", + "ix_prompt_releases_tenant_id", + ]), + ("optimizer_candidates", [ + "ix_optimizer_candidates_status", + "ix_optimizer_candidates_target_ref", + "ix_optimizer_candidates_target_type", + "ix_optimizer_candidates_candidate_type", + "ix_optimizer_candidates_judge_run_id", + "ix_optimizer_candidates_project_id", + "ix_optimizer_candidates_tenant_id", + ]), + ("judge_runs", [ + "ix_judge_runs_bucket_key", + "ix_judge_runs_judge_status", + "ix_judge_runs_executed_tier", + "ix_judge_runs_planned_tier", + "ix_judge_runs_asked_via", + "ix_judge_runs_workflow_type", + "ix_judge_runs_prompt_key", + "ix_judge_runs_pair_id", + "ix_judge_runs_asset_id", + "ix_judge_runs_project_id", + "ix_judge_runs_tenant_id", + ]), + ("quality_asset_pairs", [ + "ix_quality_asset_pairs_approved_by", + "ix_quality_asset_pairs_rejected_asset_id", + "ix_quality_asset_pairs_chosen_asset_id", + "ix_quality_asset_pairs_status", + "ix_quality_asset_pairs_pair_type", + "ix_quality_asset_pairs_project_id", + "ix_quality_asset_pairs_tenant_id", + ]), + ("quality_assets", [ + "ix_quality_assets_approved_by", + "ix_quality_assets_executed_tier", + "ix_quality_assets_planned_tier", + "ix_quality_assets_asked_via", + "ix_quality_assets_workflow_type", + "ix_quality_assets_prompt_key", + "ix_quality_assets_ai_call_log_id", + "ix_quality_assets_qa_record_id", + "ix_quality_assets_source_feedback_record_id", + "ix_quality_assets_status", + "ix_quality_assets_asset_type", + "ix_quality_assets_project_id", + "ix_quality_assets_tenant_id", + ]), + ): + for index_name in index_names: + _drop_index_if_exists(bind, table_name, index_name) + if _table_exists(bind, table_name): + op.drop_table(table_name) diff --git a/backend/app/api/ai_steward_api/__init__.py b/backend/app/api/ai_steward_api/__init__.py index cab4ee34..f764ac64 100644 --- a/backend/app/api/ai_steward_api/__init__.py +++ b/backend/app/api/ai_steward_api/__init__.py @@ -7,8 +7,10 @@ from . import ( routes_capture, routes_conflicts, routes_feedback_center, + routes_reply_iteration, routes_rag_sources, routes_stats_config, + routes_training_pipeline, routes_workflow, ) @@ -18,8 +20,10 @@ for _module in [ routes_capture, routes_conflicts, routes_feedback_center, + routes_reply_iteration, routes_brief_blockers, routes_stats_config, + routes_training_pipeline, routes_workflow, ]: router.include_router(_module.router) diff --git a/backend/app/api/ai_steward_api/routes_reply_iteration.py b/backend/app/api/ai_steward_api/routes_reply_iteration.py new file mode 100644 index 00000000..3558e577 --- /dev/null +++ b/backend/app/api/ai_steward_api/routes_reply_iteration.py @@ -0,0 +1,263 @@ +from __future__ import annotations + +from fastapi import Depends, HTTPException, Query +from sqlalchemy.ext.asyncio import AsyncSession + +from ...core.response import success_response +from ...dependencies.permissions import require_manager_user +from ...dependencies.tenant import get_tenant_id +from ...models import User +from ...schemas.reply_iteration import ( + FeedbackAssetPromoteRequest, + PromptReleaseCreateRequest, + PromptTrialCreateRequest, + PromptTrialDecisionRequest, + ReplyIterationCandidateCreateRequest, + ReplyIterationJudgeRunCreateRequest, +) +from ...services.prompt_release import PromptReleaseService +from ...services.reply_iteration import ReplyIterationService +from .shared import * + + +@router.post("/feedback-center/items/{record_id}/promote") +async def promote_feedback_center_item_to_asset( + record_id: int, + request: FeedbackAssetPromoteRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await ReplyIterationService(db).promote_feedback_record( + tenant_id=effective_tenant_id, + record_id=record_id, + actor_id=int(current_user.id), + asset_type=request.asset_type, + prompt_key=request.prompt_key, + workflow_type=request.workflow_type, + notes=request.notes, + pair_with_asset_id=request.pair_with_asset_id, + pair_role=request.pair_role, + pair_reason=request.pair_reason, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/reply-iteration/assets") +async def list_reply_iteration_assets( + asset_type: str | None = Query(default=None), + prompt_key: str | None = Query(default=None), + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + data = await ReplyIterationService(db).list_assets( + tenant_id=effective_tenant_id, + asset_type=asset_type, + prompt_key=prompt_key, + limit=limit, + offset=offset, + ) + return success_response(data) + + +@router.post("/reply-iteration/judge-runs") +async def create_reply_iteration_judge_run( + request: ReplyIterationJudgeRunCreateRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await ReplyIterationService(db).create_judge_run( + tenant_id=effective_tenant_id, + asset_id=request.asset_id, + actor_id=int(current_user.id), + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/reply-iteration/judge-runs") +async def list_reply_iteration_judge_runs( + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await ReplyIterationService(db).list_judge_runs( + tenant_id=effective_tenant_id, + limit=limit, + offset=offset, + ) + ) + + +@router.post("/reply-iteration/candidates") +async def create_reply_iteration_candidate( + request: ReplyIterationCandidateCreateRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await ReplyIterationService(db).create_optimizer_candidate( + tenant_id=effective_tenant_id, + judge_run_id=request.judge_run_id, + actor_id=int(current_user.id), + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/reply-iteration/candidates") +async def list_reply_iteration_candidates( + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await ReplyIterationService(db).list_candidates( + tenant_id=effective_tenant_id, + limit=limit, + offset=offset, + ) + ) + + +@router.post("/reply-iteration/prompt-releases") +async def create_prompt_release( + request: PromptReleaseCreateRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await PromptReleaseService(db).create_release( + tenant_id=effective_tenant_id, + prompt_key=request.prompt_key, + body_snapshot=request.body_snapshot, + created_by=int(current_user.id), + notes=request.notes, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/reply-iteration/prompt-releases") +async def list_prompt_releases( + prompt_key: str | None = Query(default=None), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await PromptReleaseService(db).list_releases( + tenant_id=effective_tenant_id, + prompt_key=prompt_key, + ) + ) + + +@router.post("/reply-iteration/prompt-releases/{release_id}/activate") +async def activate_prompt_release( + release_id: int, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await PromptReleaseService(db).activate_release( + tenant_id=effective_tenant_id, + release_id=release_id, + actor_id=int(current_user.id), + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/reply-iteration/trials") +async def list_prompt_release_trials( + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await ReplyIterationService(db).list_trials( + tenant_id=effective_tenant_id, + limit=limit, + offset=offset, + ) + ) + + +@router.post("/reply-iteration/trials") +async def create_prompt_release_trial( + request: PromptTrialCreateRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await ReplyIterationService(db).create_trial( + tenant_id=effective_tenant_id, + actor_id=int(current_user.id), + title=request.title, + hypothesis=request.hypothesis, + target_metric=request.target_metric, + prompt_key=request.prompt_key, + baseline_release_id=request.baseline_release_id, + candidate_release_id=request.candidate_release_id, + scope_json=request.scope_json, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.post("/reply-iteration/trials/{trial_id}/decision") +async def decide_prompt_release_trial( + trial_id: int, + request: PromptTrialDecisionRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await ReplyIterationService(db).decide_trial( + tenant_id=effective_tenant_id, + trial_id=trial_id, + actor_id=int(current_user.id), + decision=request.decision, + result_summary=request.result_summary, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) diff --git a/backend/app/api/ai_steward_api/routes_training_pipeline.py b/backend/app/api/ai_steward_api/routes_training_pipeline.py new file mode 100644 index 00000000..4a053c1d --- /dev/null +++ b/backend/app/api/ai_steward_api/routes_training_pipeline.py @@ -0,0 +1,180 @@ +from __future__ import annotations + +from fastapi import Depends, HTTPException, Query +from sqlalchemy.ext.asyncio import AsyncSession + +from ...core.response import success_response +from ...dependencies.permissions import require_manager_user +from ...dependencies.tenant import get_tenant_id +from ...models import User +from ...schemas.training_pipeline import ( + TrainingDatasetCreateRequest, + TrainingDeploymentDecisionRequest, + TrainingJobCreateRequest, +) +from ...services.training_pipeline import TrainingPipelineService +from .shared import * + + +@router.post("/training/datasets") +async def create_training_dataset( + request: TrainingDatasetCreateRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await TrainingPipelineService(db).create_dataset( + tenant_id=effective_tenant_id, + actor_id=int(current_user.id), + dataset_type=request.dataset_type, + version=request.version, + asset_ids=request.asset_ids, + pair_ids=request.pair_ids, + selection_rules=request.selection_rules, + notes=request.notes, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/training/datasets") +async def list_training_datasets( + dataset_type: str | None = Query(default=None), + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await TrainingPipelineService(db).list_datasets( + tenant_id=effective_tenant_id, + dataset_type=dataset_type, + limit=limit, + offset=offset, + ) + ) + + +@router.post("/training/jobs") +async def create_training_job( + request: TrainingJobCreateRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await TrainingPipelineService(db).create_job( + tenant_id=effective_tenant_id, + actor_id=int(current_user.id), + dataset_id=request.dataset_id, + job_type=request.job_type, + base_model_family=request.base_model_family, + target_slot=request.target_slot, + provider_backend=request.provider_backend, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/training/jobs") +async def list_training_jobs( + status: str | None = Query(default=None), + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await TrainingPipelineService(db).list_jobs( + tenant_id=effective_tenant_id, + status=status, + limit=limit, + offset=offset, + ) + ) + + +@router.get("/training/jobs/{job_id}/evaluations") +async def list_training_job_evaluations( + job_id: int, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await TrainingPipelineService(db).list_evaluations( + tenant_id=effective_tenant_id, + job_id=job_id, + ) + ) + + +@router.post("/training/artifacts/{artifact_id}/promote") +async def promote_trained_model_artifact( + artifact_id: int, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await TrainingPipelineService(db).promote_artifact( + tenant_id=effective_tenant_id, + artifact_id=artifact_id, + actor_id=int(current_user.id), + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.post("/training/deployments/{deployment_id}/decision") +async def decide_trained_model_deployment( + deployment_id: int, + request: TrainingDeploymentDecisionRequest, + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + try: + data = await TrainingPipelineService(db).decide_deployment( + tenant_id=effective_tenant_id, + deployment_id=deployment_id, + actor_id=int(current_user.id), + decision=request.decision, + notes=request.notes, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return success_response(data) + + +@router.get("/training/deployments") +async def list_training_deployments( + deployment_status: str | None = Query(default=None), + limit: int = Query(default=20, ge=1, le=100), + offset: int = Query(default=0, ge=0), + current_user: User = Depends(require_manager_user), + db: AsyncSession = Depends(get_db), + tenant_id: int = Depends(get_tenant_id), +): + effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id) + return success_response( + await TrainingPipelineService(db).list_deployments( + tenant_id=effective_tenant_id, + deployment_status=deployment_status, + limit=limit, + offset=offset, + ) + ) diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py index 3ce356f3..221ea90b 100644 --- a/backend/app/models/__init__.py +++ b/backend/app/models/__init__.py @@ -46,6 +46,16 @@ from .knowledge_base_chunk import KnowledgeBaseChunk from .qa_record import QARecord from .qa_feedback import QAFeedback from .feedback_center import FeedbackCenterRecord, FeedbackCenterRecordRevision +from .reply_iteration import QualityAsset, QualityAssetPair, JudgeRun, OptimizerCandidate, PromptRelease +from .training_pipeline import ( + TrainingDataset, + TrainingDatasetItem, + TrainingJob, + TrainingJobRun, + TrainingEvaluation, + TrainedModelArtifact, + TrainedModelDeployment, +) from .qa_session import QASession from .qa_session_state import QASessionState from .kg_entity import KGEntity @@ -114,6 +124,18 @@ __all__ = [ "QAFeedback", "FeedbackCenterRecord", "FeedbackCenterRecordRevision", + "QualityAsset", + "QualityAssetPair", + "JudgeRun", + "OptimizerCandidate", + "PromptRelease", + "TrainingDataset", + "TrainingDatasetItem", + "TrainingJob", + "TrainingJobRun", + "TrainingEvaluation", + "TrainedModelArtifact", + "TrainedModelDeployment", "QASession", "QASessionState", "KGEntity", diff --git a/backend/app/models/experiment.py b/backend/app/models/experiment.py index 47e33706..c5c6608f 100644 --- a/backend/app/models/experiment.py +++ b/backend/app/models/experiment.py @@ -1,9 +1,11 @@ """实验模型""" +from typing import Optional + +from sqlalchemy import BigInteger, Float, ForeignKey, Integer, Text, VARCHAR +from sqlalchemy.orm import Mapped, mapped_column + from .base import Base from .types import JSONB -from sqlalchemy.orm import Mapped, mapped_column -from sqlalchemy import BigInteger, Integer, VARCHAR, Text, Float, ForeignKey -from typing import Optional class Experiment(Base): @@ -16,6 +18,12 @@ class Experiment(Base): target_metric: Mapped[Optional[str]] = mapped_column(VARCHAR(50), nullable=True) current_score: Mapped[Optional[float]] = mapped_column(Float, nullable=True) linked_context_nodes: Mapped[Optional[object]] = mapped_column(JSONB, nullable=True) + experiment_type: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True, index=True) + baseline_release_id: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, index=True) + candidate_release_id: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, index=True) + scope_json: Mapped[Optional[object]] = mapped_column(JSONB, nullable=True) + result_summary: Mapped[Optional[object]] = mapped_column(JSONB, nullable=True) + decision: Mapped[Optional[str]] = mapped_column(VARCHAR(24), nullable=True, index=True) project_id: Mapped[Optional[int]] = mapped_column( BigInteger, ForeignKey("projects.id"), nullable=True, index=True ) diff --git a/backend/app/models/qa_record.py b/backend/app/models/qa_record.py index ead8fad9..7d067770 100644 --- a/backend/app/models/qa_record.py +++ b/backend/app/models/qa_record.py @@ -31,3 +31,12 @@ class QARecord(Base): index=True, ) turn_index: Mapped[int] = mapped_column(Integer, nullable=False, default=1) + source_message_id: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True, index=True) + source_chat_id: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True) + source_sender_open_id: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True) + reply_to_message_id: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True) + root_message_id: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True) + conversation_scope_key: Mapped[Optional[str]] = mapped_column(VARCHAR(160), nullable=True, index=True) + anchor_kind: Mapped[Optional[str]] = mapped_column(VARCHAR(32), nullable=True) + anchor_ref: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True) + routing_snapshot: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) diff --git a/backend/app/models/qa_session.py b/backend/app/models/qa_session.py index b7c675e2..6ee05bc6 100644 --- a/backend/app/models/qa_session.py +++ b/backend/app/models/qa_session.py @@ -4,7 +4,7 @@ from __future__ import annotations from typing import Optional -from sqlalchemy import BigInteger, Integer, TIMESTAMP, VARCHAR +from sqlalchemy import BigInteger, Integer, TIMESTAMP, VARCHAR, UniqueConstraint from sqlalchemy.orm import Mapped, mapped_column from .base import Base @@ -12,9 +12,17 @@ from .base import Base class QASession(Base): __tablename__ = "qa_sessions" + __table_args__ = ( + UniqueConstraint( + "tenant_id", + "external_conversation_key", + name="uq_qa_sessions_tenant_external_conversation_key", + ), + ) id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) user_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + external_conversation_key: Mapped[Optional[str]] = mapped_column(VARCHAR(160), nullable=True, index=True) title: Mapped[str] = mapped_column(VARCHAR(120), nullable=False, default="新会话") project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) started_at: Mapped[Optional[TIMESTAMP]] = mapped_column(TIMESTAMP, nullable=True, index=True) diff --git a/backend/app/models/qa_session_state.py b/backend/app/models/qa_session_state.py index dc81410d..346959b1 100644 --- a/backend/app/models/qa_session_state.py +++ b/backend/app/models/qa_session_state.py @@ -4,7 +4,7 @@ from __future__ import annotations from typing import Any, Optional -from sqlalchemy import ForeignKey, Integer, VARCHAR +from sqlalchemy import ForeignKey, Integer, TIMESTAMP, VARCHAR from sqlalchemy.orm import Mapped, mapped_column from .base import Base @@ -27,3 +27,5 @@ class QASessionState(Base): last_intent: Mapped[Optional[str]] = mapped_column(VARCHAR(20), nullable=True, index=True) ambiguity: Mapped[Optional[str]] = mapped_column(VARCHAR(20), nullable=True, index=True) rewrite_history: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + pending_clarification: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + pending_clarification_expires_at: Mapped[Optional[TIMESTAMP]] = mapped_column(TIMESTAMP, nullable=True, index=True) diff --git a/backend/app/models/reply_iteration.py b/backend/app/models/reply_iteration.py new file mode 100644 index 00000000..72714f36 --- /dev/null +++ b/backend/app/models/reply_iteration.py @@ -0,0 +1,152 @@ +"""回复质量迭代相关模型。""" + +from __future__ import annotations + +from typing import Any, Optional + +from sqlalchemy import BigInteger, ForeignKey, Integer, Text, UniqueConstraint, VARCHAR +from sqlalchemy.orm import Mapped, mapped_column + +from .base import Base +from .types import JSONB + + +class QualityAsset(Base): + __tablename__ = "quality_assets" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + asset_type: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, index=True) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="approved", index=True) + source_feedback_record_id: Mapped[Optional[int]] = mapped_column( + Integer, + ForeignKey("feedback_center_records.id", ondelete="SET NULL"), + nullable=True, + index=True, + ) + qa_record_id: Mapped[Optional[int]] = mapped_column( + Integer, + ForeignKey("qa_records.id", ondelete="SET NULL"), + nullable=True, + index=True, + ) + ai_call_log_id: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, index=True) + prompt_key: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True, index=True) + workflow_type: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True, index=True) + asked_via: Mapped[Optional[str]] = mapped_column(VARCHAR(32), nullable=True, index=True) + planned_tier: Mapped[Optional[str]] = mapped_column(VARCHAR(16), nullable=True, index=True) + executed_tier: Mapped[Optional[str]] = mapped_column(VARCHAR(16), nullable=True, index=True) + route_source: Mapped[Optional[str]] = mapped_column(VARCHAR(32), nullable=True) + route_rule_name: Mapped[Optional[str]] = mapped_column(VARCHAR(255), nullable=True) + question_text: Mapped[str] = mapped_column(Text, nullable=False) + answer_text: Mapped[str] = mapped_column(Text, nullable=False) + corrected_answer: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + source_snapshot: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + tags: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + notes: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + approved_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + approved_at: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True) + + +class QualityAssetPair(Base): + __tablename__ = "quality_asset_pairs" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + pair_type: Mapped[str] = mapped_column(VARCHAR(24), nullable=False, default="preference", index=True) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="approved", index=True) + chosen_asset_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("quality_assets.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + rejected_asset_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("quality_assets.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + reason_text: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + approved_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + approved_at: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True) + + +class JudgeRun(Base): + __tablename__ = "judge_runs" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + asset_id: Mapped[Optional[int]] = mapped_column( + Integer, + ForeignKey("quality_assets.id", ondelete="CASCADE"), + nullable=True, + index=True, + ) + pair_id: Mapped[Optional[int]] = mapped_column( + Integer, + ForeignKey("quality_asset_pairs.id", ondelete="CASCADE"), + nullable=True, + index=True, + ) + prompt_key: Mapped[Optional[str]] = mapped_column(VARCHAR(128), nullable=True, index=True) + workflow_type: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True, index=True) + asked_via: Mapped[Optional[str]] = mapped_column(VARCHAR(32), nullable=True, index=True) + planned_tier: Mapped[Optional[str]] = mapped_column(VARCHAR(16), nullable=True, index=True) + executed_tier: Mapped[Optional[str]] = mapped_column(VARCHAR(16), nullable=True, index=True) + route_rule_name: Mapped[Optional[str]] = mapped_column(VARCHAR(255), nullable=True) + judge_status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="completed", index=True) + bucket_key: Mapped[str] = mapped_column(VARCHAR(255), nullable=False, index=True) + rule_score: Mapped[Optional[float]] = mapped_column(nullable=True) + llm_score: Mapped[Optional[float]] = mapped_column(nullable=True) + overall_score: Mapped[Optional[float]] = mapped_column(nullable=True) + findings: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + llm_evidence: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + metadata_json: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + + +class OptimizerCandidate(Base): + __tablename__ = "optimizer_candidates" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + judge_run_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("judge_runs.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + candidate_type: Mapped[str] = mapped_column(VARCHAR(32), nullable=False, index=True) + target_type: Mapped[str] = mapped_column(VARCHAR(32), nullable=False, index=True) + target_ref: Mapped[str] = mapped_column(VARCHAR(255), nullable=False, index=True) + status: Mapped[str] = mapped_column(VARCHAR(24), nullable=False, default="draft", index=True) + suggestion: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + evidence: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + notes: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + + +class PromptRelease(Base): + __tablename__ = "prompt_releases" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + prompt_key: Mapped[str] = mapped_column(VARCHAR(128), nullable=False, index=True) + version: Mapped[int] = mapped_column(Integer, nullable=False, default=1) + body_snapshot: Mapped[str] = mapped_column(Text, nullable=False) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="draft", index=True) + notes: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + created_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + activated_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + activated_at: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True) + + __table_args__ = ( + UniqueConstraint("tenant_id", "prompt_key", "version", name="uq_prompt_releases_tenant_key_version"), + ) + + +__all__ = [ + "QualityAsset", + "QualityAssetPair", + "JudgeRun", + "OptimizerCandidate", + "PromptRelease", +] diff --git a/backend/app/models/training_pipeline.py b/backend/app/models/training_pipeline.py new file mode 100644 index 00000000..32f135d4 --- /dev/null +++ b/backend/app/models/training_pipeline.py @@ -0,0 +1,154 @@ +"""训练 / 微调管线相关模型。""" + +from __future__ import annotations + +from typing import Any, Optional + +from sqlalchemy import BigInteger, ForeignKey, Integer, Text, UniqueConstraint, VARCHAR +from sqlalchemy.orm import Mapped, mapped_column + +from .base import Base +from .types import JSONB + + +class TrainingDataset(Base): + __tablename__ = "training_datasets" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + dataset_type: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, index=True) + version: Mapped[str] = mapped_column(VARCHAR(64), nullable=False, index=True) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="ready", index=True) + sample_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0) + selection_rules: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + channel_scope: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + notes: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + created_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + + __table_args__ = ( + UniqueConstraint("tenant_id", "dataset_type", "version", name="uq_training_datasets_tenant_type_version"), + ) + + +class TrainingDatasetItem(Base): + __tablename__ = "training_dataset_items" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + dataset_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("training_datasets.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + quality_asset_id: Mapped[Optional[int]] = mapped_column( + Integer, + ForeignKey("quality_assets.id", ondelete="CASCADE"), + nullable=True, + index=True, + ) + quality_asset_pair_id: Mapped[Optional[int]] = mapped_column( + Integer, + ForeignKey("quality_asset_pairs.id", ondelete="CASCADE"), + nullable=True, + index=True, + ) + redacted_snapshot: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + + +class TrainingJob(Base): + __tablename__ = "training_jobs" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + project_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + dataset_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("training_datasets.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + job_type: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, index=True) + base_model_family: Mapped[str] = mapped_column(VARCHAR(64), nullable=False, index=True) + target_slot: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, index=True) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="queued", index=True) + provider_backend: Mapped[str] = mapped_column(VARCHAR(64), nullable=False) + artifact_ref: Mapped[Optional[str]] = mapped_column(VARCHAR(255), nullable=True) + metrics_json: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + created_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + + +class TrainingJobRun(Base): + __tablename__ = "training_job_runs" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + training_job_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("training_jobs.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="queued", index=True) + provider_run_ref: Mapped[Optional[str]] = mapped_column(VARCHAR(255), nullable=True) + metrics_json: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + + +class TrainingEvaluation(Base): + __tablename__ = "training_evaluations" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + training_job_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("training_jobs.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + evaluation_type: Mapped[str] = mapped_column(VARCHAR(32), nullable=False, index=True) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="pending", index=True) + score: Mapped[Optional[float]] = mapped_column(nullable=True) + evaluation_summary: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + + +class TrainedModelArtifact(Base): + __tablename__ = "trained_model_artifacts" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + training_job_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("training_jobs.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + artifact_ref: Mapped[str] = mapped_column(VARCHAR(255), nullable=False, index=True) + base_model_family: Mapped[str] = mapped_column(VARCHAR(64), nullable=False, index=True) + target_slot: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, index=True) + status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="pending_eval", index=True) + metrics_json: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + + +class TrainedModelDeployment(Base): + __tablename__ = "trained_model_deployments" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True) + artifact_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("trained_model_artifacts.id", ondelete="CASCADE"), + nullable=False, + index=True, + ) + deployment_status: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, default="candidate", index=True) + bound_tier: Mapped[str] = mapped_column(VARCHAR(16), nullable=False, index=True) + effective_scope: Mapped[Optional[Any]] = mapped_column(JSONB, nullable=True) + decision: Mapped[Optional[str]] = mapped_column(VARCHAR(24), nullable=True) + notes: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + decided_by: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, index=True) + decided_at: Mapped[Optional[str]] = mapped_column(VARCHAR(64), nullable=True) + + +__all__ = [ + "TrainingDataset", + "TrainingDatasetItem", + "TrainingJob", + "TrainingJobRun", + "TrainingEvaluation", + "TrainedModelArtifact", + "TrainedModelDeployment", +] diff --git a/backend/app/schemas/reply_iteration.py b/backend/app/schemas/reply_iteration.py new file mode 100644 index 00000000..a18e5971 --- /dev/null +++ b/backend/app/schemas/reply_iteration.py @@ -0,0 +1,56 @@ +from __future__ import annotations + +from typing import Any, Literal, Optional + +from pydantic import BaseModel, ConfigDict, Field + + +class FeedbackAssetPromoteRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + asset_type: Literal["golden", "failure"] + prompt_key: Optional[str] = None + workflow_type: Optional[str] = None + notes: Optional[str] = None + pair_with_asset_id: Optional[int] = None + pair_role: Optional[Literal["chosen", "rejected"]] = None + pair_reason: Optional[str] = None + + +class ReplyIterationJudgeRunCreateRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + asset_id: int + + +class ReplyIterationCandidateCreateRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + judge_run_id: int + + +class PromptReleaseCreateRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + prompt_key: str + body_snapshot: str + notes: Optional[str] = None + + +class PromptTrialCreateRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + title: str + hypothesis: str + target_metric: str + prompt_key: str + baseline_release_id: int + candidate_release_id: int + scope_json: dict[str, Any] = Field(default_factory=dict) + + +class PromptTrialDecisionRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + decision: Literal["accepted", "rejected", "rolled_back"] + result_summary: dict[str, Any] = Field(default_factory=dict) diff --git a/backend/app/schemas/training_pipeline.py b/backend/app/schemas/training_pipeline.py new file mode 100644 index 00000000..7dd8aa5d --- /dev/null +++ b/backend/app/schemas/training_pipeline.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from typing import Any, Literal, Optional + +from pydantic import BaseModel, ConfigDict, Field + + +class TrainingDatasetCreateRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + dataset_type: Literal["sft", "preference", "eval"] + version: str + asset_ids: list[int] = Field(default_factory=list) + pair_ids: list[int] = Field(default_factory=list) + selection_rules: dict[str, Any] = Field(default_factory=dict) + notes: Optional[str] = None + + +class TrainingJobCreateRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + dataset_id: int + job_type: Literal["sft", "preference"] + base_model_family: str + target_slot: Literal["low", "high"] + provider_backend: str + + +class TrainingDeploymentDecisionRequest(BaseModel): + model_config = ConfigDict(extra="ignore") + + decision: Literal["accepted", "rejected", "rolled_back"] + notes: Optional[str] = None diff --git a/backend/app/services/adaptive_rag_service/mixin_answer_entry.py b/backend/app/services/adaptive_rag_service/mixin_answer_entry.py index ffb67262..29a08e4a 100644 --- a/backend/app/services/adaptive_rag_service/mixin_answer_entry.py +++ b/backend/app/services/adaptive_rag_service/mixin_answer_entry.py @@ -69,8 +69,11 @@ class AdaptiveRAGAnswerEntryMixin: asked_via: str, project_id: Optional[int] = None, source_chat_id: Optional[str] = None, + source_message_id: Optional[str] = None, session_id: Optional[int] = None, conversation_key: Optional[str] = None, + source_sender_open_id: Optional[str] = None, + thread_context: Optional[dict[str, Any]] = None, force_new_session: bool = False, thinking_mode: str = THINKING_MODE_NORMAL, action_mode: str = ACTION_MODE_AUTO, @@ -116,11 +119,15 @@ class AdaptiveRAGAnswerEntryMixin: asked_via=asked_via, project_id=project_id, source_chat_id=source_chat_id, + source_message_id=source_message_id, session_id=session_id, conversation_key=conversation_key, force_new_session=force_new_session, action_mode=action_mode, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, ) + clean_q = str(runtime.get("resolved_question") or clean_q).strip() or clean_q session_id = runtime["session_id"] turn_index = int(runtime["turn_index"] or 1) context_session_id = runtime["context_session_id"] @@ -130,6 +137,7 @@ class AdaptiveRAGAnswerEntryMixin: rewrite_meta = runtime["rewrite_meta"] if isinstance(runtime["rewrite_meta"], dict) else {} query_type = str(runtime["query_type"] or QUERY_TYPE_UNKNOWN) effective_action_mode = str(runtime["effective_action_mode"] or ACTION_MODE_AUTO).strip().lower() + anchor_resolution = runtime["anchor_resolution"] if self._should_trigger_write_ack_gate( sync_requirement=sync_requirement, @@ -177,4 +185,5 @@ class AdaptiveRAGAnswerEntryMixin: started=started, message_intent=message_intent, mixed_signal_part=mixed_signal_part, + anchor_resolution=anchor_resolution, ) diff --git a/backend/app/services/adaptive_rag_service/mixin_answer_mainline.py b/backend/app/services/adaptive_rag_service/mixin_answer_mainline.py index 5132d588..6004e751 100644 --- a/backend/app/services/adaptive_rag_service/mixin_answer_mainline.py +++ b/backend/app/services/adaptive_rag_service/mixin_answer_mainline.py @@ -17,11 +17,24 @@ class AdaptiveRAGAnswerMainlineMixin: conversation_key: Optional[str], force_new_session: bool, action_mode: str, + source_message_id: Optional[str] = None, + source_sender_open_id: Optional[str] = None, + thread_context: Optional[dict[str, Any]] = None, ) -> dict[str, Any]: external_conversation_key = self._build_external_conversation_key( asked_via=asked_via, source_chat_id=source_chat_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + sender=None, + thread_context=thread_context, + ) + self._set_active_external_qa_context( + source_chat_id=source_chat_id, + source_message_id=source_message_id, + source_sender_open_id=source_sender_open_id, + conversation_scope_key=external_conversation_key, + thread_context=thread_context, ) session_id, turn_index = await self._touch_session_for_new_record( asked_by=asked_by, @@ -30,6 +43,7 @@ class AdaptiveRAGAnswerMainlineMixin: question=clean_q, preferred_session_id=session_id, force_new_session=bool(force_new_session), + external_conversation_key=external_conversation_key, ) context_session_id: Optional[int] if session_id is not None: @@ -46,17 +60,39 @@ class AdaptiveRAGAnswerMainlineMixin: external_session_id=context_session_id, limit=10, ) - state_row = await self._ensure_session_state(session_id=session_id) - effective_q, rewrite_meta = self._rewrite_question_with_state( + state_session_id = int(session_id) if session_id is not None else ( + int(context_session_id) if context_session_id is not None else None + ) + state_row = await self._ensure_session_state(session_id=state_session_id) + pending_selection = self._consume_pending_clarification_selection( question=clean_q, + session_state=state_row, + ) + resolved_question = str(pending_selection.get("effective_question") or clean_q).strip() if isinstance( + pending_selection, dict + ) else clean_q + anchor_resolution = await self._resolve_followup_anchor( + question=resolved_question, + session_id=state_session_id, + context_session_id=context_session_id, + session_state=state_row, + conversation_scope_key=external_conversation_key, + source_chat_id=source_chat_id, + source_sender_open_id=source_sender_open_id, + source_message_id=source_message_id, + thread_context=thread_context, + ) + effective_q, rewrite_meta = self._rewrite_question_with_state( + question=resolved_question, conversation=conversation, session_state=state_row, + anchor_resolution=anchor_resolution, ) query_type = self._classify_query_type(effective_q) requested_action_mode = self._normalize_action_mode(action_mode) effective_action_mode = self._resolve_action_mode( requested_mode=requested_action_mode, - question=clean_q, + question=resolved_question, effective_question=effective_q, ) return { @@ -65,10 +101,12 @@ class AdaptiveRAGAnswerMainlineMixin: "context_session_id": context_session_id, "conversation": conversation, "state_row": state_row, + "resolved_question": resolved_question, "effective_q": effective_q, "rewrite_meta": rewrite_meta, "query_type": query_type, "effective_action_mode": effective_action_mode, + "anchor_resolution": anchor_resolution, } async def _execute_base_answer_mainline( @@ -96,6 +134,7 @@ class AdaptiveRAGAnswerMainlineMixin: started: float, message_intent: Optional[str], mixed_signal_part: Optional[str], + anchor_resolution: Optional[FollowupAnchorResolution] = None, ) -> dict[str, Any]: forced_deep_reason = "" if not deep_thinking: @@ -115,13 +154,36 @@ class AdaptiveRAGAnswerMainlineMixin: else: forced_deep_reason = "" - clarification_answer = self._build_clarification_question( - original_question=clean_q, - effective_question=effective_q, + clarification_payload = self._build_followup_clarification_payload( + question=clean_q, + anchor_resolution=anchor_resolution, session_state=state_row, ) + meta_followup_payload = await self._build_meta_followup_payload( + question=clean_q, + anchor_resolution=anchor_resolution, + conversation_scope_key=self._get_active_external_qa_context().get("conversation_scope_key"), + ) + meta_followup_result = await self._maybe_return_meta_followup_response( + meta_followup_payload=meta_followup_payload, + started=started, + clean_q=clean_q, + effective_q=effective_q, + query_type=query_type, + asked_by=asked_by, + asked_via=asked_via, + project_id=project_id, + session_id=session_id, + turn_index=turn_index, + state_row=state_row, + rewrite_meta=rewrite_meta, + context_session_id=context_session_id, + active_thinking_mode=active_thinking_mode, + ) + if meta_followup_result is not None: + return meta_followup_result clarification_result = await self._maybe_return_clarification_response( - clarification_answer=clarification_answer, + clarification_payload=clarification_payload, started=started, clean_q=clean_q, effective_q=effective_q, diff --git a/backend/app/services/adaptive_rag_service/mixin_answer_payload.py b/backend/app/services/adaptive_rag_service/mixin_answer_payload.py index a693a868..42abbfdc 100644 --- a/backend/app/services/adaptive_rag_service/mixin_answer_payload.py +++ b/backend/app/services/adaptive_rag_service/mixin_answer_payload.py @@ -34,6 +34,12 @@ class AdaptiveRAGAnswerPayloadMixin: ack_latency_ms: Optional[int] = None, trace_id: Optional[str] = None, processing_stage: Optional[str] = None, + clarification_code: Optional[str] = None, + clarification_candidates: Optional[list[dict[str, Any]]] = None, + anchor_mode: Optional[str] = None, + anchor_kind: Optional[str] = None, + meta_followup_kind: Optional[str] = None, + reason_code: Optional[str] = None, ) -> dict[str, Any]: evidence: list[dict[str, Any]] = [] for item in sources[:8]: @@ -77,6 +83,16 @@ class AdaptiveRAGAnswerPayloadMixin: "ack_latency_ms": int(ack_latency_ms) if ack_latency_ms is not None else None, "trace_id": str(trace_id or "").strip() or None, "processing_stage": str(processing_stage or "").strip() or None, + "clarification_code": str(clarification_code or "").strip() or None, + "clarification_candidates": ( + clarification_candidates[:3] + if isinstance(clarification_candidates, list) + else [] + ), + "anchor_mode": str(anchor_mode or "").strip() or None, + "anchor_kind": str(anchor_kind or "").strip() or None, + "meta_followup_kind": str(meta_followup_kind or "").strip() or None, + "reason_code": str(reason_code or "").strip() or None, } @staticmethod @@ -127,4 +143,3 @@ class AdaptiveRAGAnswerPayloadMixin: "trace_id": trace_id or None, "processing_stage": normalized_stage or None, } - diff --git a/backend/app/services/adaptive_rag_service/mixin_answer_precheck.py b/backend/app/services/adaptive_rag_service/mixin_answer_precheck.py index e995fa21..d39d049c 100644 --- a/backend/app/services/adaptive_rag_service/mixin_answer_precheck.py +++ b/backend/app/services/adaptive_rag_service/mixin_answer_precheck.py @@ -5,10 +5,10 @@ from .shared import * class AdaptiveRAGAnswerPrecheckMixin: - async def _maybe_return_clarification_response( + async def _maybe_return_meta_followup_response( self, *, - clarification_answer: Optional[str], + meta_followup_payload: Optional[dict[str, Any]], started: float, clean_q: str, effective_q: str, @@ -23,8 +23,137 @@ class AdaptiveRAGAnswerPrecheckMixin: context_session_id: Optional[int], active_thinking_mode: str, ) -> Optional[dict[str, Any]]: + if not isinstance(meta_followup_payload, dict): + return None + answer = str(meta_followup_payload.get("answer") or "").strip() + if not answer: + return None + reason_code = str(meta_followup_payload.get("reason_code") or "").strip() or "meta_followup_answered" + anchor_kind = str(meta_followup_payload.get("anchor_kind") or "").strip() or None + anchor_mode = str(meta_followup_payload.get("anchor_mode") or "").strip() or None + meta_followup_kind = str(meta_followup_payload.get("meta_followup_kind") or "").strip() or None + routing_snapshot = ( + meta_followup_payload.get("routing_snapshot") + if isinstance(meta_followup_payload.get("routing_snapshot"), dict) + else {} + ) + elapsed = int((time.perf_counter() - started) * 1000) + direct_sources = [ + { + "source": "system", + "label": "Followup Anchor", + "score": 0.97, + "metadata": { + "mode": "meta_followup", + "reason_code": reason_code, + "anchor_kind": anchor_kind, + "anchor_mode": anchor_mode, + "meta_followup_kind": meta_followup_kind, + }, + } + ] + active_session_id = int(session_id) if session_id is not None else ( + int(context_session_id) if context_session_id is not None else None + ) + qa = QARecord( + tenant_id=self.tenant_id, + question=clean_q, + answer=answer, + sources=direct_sources, + intent="question", + domains_used=["system_context"], + response_time_ms=elapsed, + asked_by=asked_by, + asked_via=(asked_via or "pmflow")[:20], + project_id=project_id, + session_id=active_session_id, + turn_index=turn_index, + **self._build_qa_record_external_fields( + anchor_kind=anchor_kind, + anchor_ref=str(meta_followup_payload.get("anchor_ref") or "").strip() or None, + routing_snapshot=routing_snapshot, + ), + ) + self.db.add(qa) + await self._update_session_state_after_turn( + session_state=state_row, + question=clean_q, + effective_question=effective_q, + answer=answer, + query_type=query_type, + ambiguity="clear", + rewrite_meta=rewrite_meta, + sources=direct_sources, + ) + await self.db.commit() + await self.db.refresh(qa) + await self.context_cache.append_session_messages( + tenant_id=self.tenant_id, + session_id=context_session_id, + question=clean_q, + answer=answer, + ) + return self._build_response_payload( + answer=answer, + sources=direct_sources, + domains_used=["system_context"], + response_time_ms=elapsed, + db_query_ms=0, + vector_search_ms=0, + db_timeout=False, + vector_timeout=False, + qa_id=int(qa.id), + session_id=active_session_id, + turn_index=int(turn_index), + relevance_max=0.97, + query_type=query_type, + confidence=0.94, + missing_fields=[], + thinking_mode=active_thinking_mode, + anchor_mode=anchor_mode, + anchor_kind=anchor_kind, + meta_followup_kind=meta_followup_kind, + reason_code=reason_code, + ) + + async def _maybe_return_clarification_response( + self, + *, + clarification_payload: Optional[dict[str, Any]], + started: float, + clean_q: str, + effective_q: str, + query_type: str, + asked_by: Optional[int], + asked_via: str, + project_id: Optional[int], + session_id: Optional[int], + turn_index: int, + state_row: Optional[QASessionState], + rewrite_meta: dict[str, Any], + context_session_id: Optional[int], + active_thinking_mode: str, + ) -> Optional[dict[str, Any]]: + if not isinstance(clarification_payload, dict): + return None + clarification_answer = str(clarification_payload.get("answer") or "").strip() if not clarification_answer: return None + clarification_code = str(clarification_payload.get("code") or "no_anchor_found").strip() or "no_anchor_found" + clarification_candidates = ( + clarification_payload.get("candidates") + if isinstance(clarification_payload.get("candidates"), list) + else [] + ) + missing_fields = [ + str(item) + for item in ( + clarification_payload.get("missing_fields") + if isinstance(clarification_payload.get("missing_fields"), list) + else ["reply_anchor"] + ) + if str(item).strip() + ] elapsed = int((time.perf_counter() - started) * 1000) clarify_sources = [ @@ -32,9 +161,12 @@ class AdaptiveRAGAnswerPrecheckMixin: "source": "system", "label": "Session State", "score": 0.95, - "metadata": {"mode": "clarification", "reason": "missing_subject"}, + "metadata": {"mode": "clarification", "reason": clarification_code}, } ] + active_session_id = int(session_id) if session_id is not None else ( + int(context_session_id) if context_session_id is not None else None + ) qa = QARecord( tenant_id=self.tenant_id, question=clean_q, @@ -46,10 +178,23 @@ class AdaptiveRAGAnswerPrecheckMixin: asked_by=asked_by, asked_via=(asked_via or "pmflow")[:20], project_id=project_id, - session_id=session_id, + session_id=active_session_id, turn_index=turn_index, + **self._build_qa_record_external_fields(), ) self.db.add(qa) + if clarification_code == "ambiguous_recent_reply" and clarification_candidates: + previous = self._get_pending_clarification(session_state=state_row) + previous_attempts = int(previous.get("attempts") or 0) if isinstance(previous, dict) else 0 + self._store_pending_clarification( + session_state=state_row, + original_question=clean_q, + clarification_code=clarification_code, + candidates=clarification_candidates, + previous_attempts=previous_attempts, + ) + else: + self._clear_pending_clarification(session_state=state_row) await self._update_session_state_after_turn( session_state=state_row, question=clean_q, @@ -78,13 +223,16 @@ class AdaptiveRAGAnswerPrecheckMixin: db_timeout=False, vector_timeout=False, qa_id=int(qa.id), - session_id=int(session_id) if session_id is not None else None, + session_id=active_session_id, turn_index=int(turn_index), relevance_max=0.95, query_type=query_type, confidence=0.92, - missing_fields=["subject"], + missing_fields=missing_fields, thinking_mode=active_thinking_mode, + clarification_code=clarification_code, + clarification_candidates=clarification_candidates, + reason_code=clarification_code, ) async def _maybe_return_snapshot_direct_response( @@ -138,8 +286,9 @@ class AdaptiveRAGAnswerPrecheckMixin: asked_by=asked_by, asked_via=(asked_via or "pmflow")[:20], project_id=project_id, - session_id=session_id, + session_id=int(session_id) if session_id is not None else (int(context_session_id) if context_session_id is not None else None), turn_index=turn_index, + **self._build_qa_record_external_fields(), ) self.db.add(qa) await self._update_session_state_after_turn( @@ -178,4 +327,3 @@ class AdaptiveRAGAnswerPrecheckMixin: missing_fields=[], thinking_mode=active_thinking_mode, ) - diff --git a/backend/app/services/adaptive_rag_service/mixin_answer_retrieval.py b/backend/app/services/adaptive_rag_service/mixin_answer_retrieval.py index c07a197d..45ccaf3f 100644 --- a/backend/app/services/adaptive_rag_service/mixin_answer_retrieval.py +++ b/backend/app/services/adaptive_rag_service/mixin_answer_retrieval.py @@ -83,6 +83,7 @@ class AdaptiveRAGAnswerRetrievalMixin: mixed_signal_part=mixed_signal_part, query_type=query_type, ) + routing_snapshot = self._peek_last_answer_routing_snapshot() used_sources = self._dedupe_sources(retrieved) if not used_sources: used_sources = [ @@ -244,6 +245,11 @@ class AdaptiveRAGAnswerRetrievalMixin: project_id=project_id, session_id=session_id, turn_index=turn_index, + **self._build_qa_record_external_fields( + anchor_kind=None, + anchor_ref=None, + routing_snapshot=routing_snapshot, + ), ) self.db.add(qa) confidence = round(max(0.2, min(1.0, max_score if max_score > 0 else 0.55)), 4) @@ -293,4 +299,5 @@ class AdaptiveRAGAnswerRetrievalMixin: confidence=confidence, missing_fields=missing_fields, thinking_mode=active_thinking_mode, + reason_code="answer_generated", ) diff --git a/backend/app/services/adaptive_rag_service/mixin_core_intent.py b/backend/app/services/adaptive_rag_service/mixin_core_intent.py index 7a4b7de8..36fa074d 100644 --- a/backend/app/services/adaptive_rag_service/mixin_core_intent.py +++ b/backend/app/services/adaptive_rag_service/mixin_core_intent.py @@ -10,6 +10,7 @@ class AdaptiveRAGCoreIntentMixin: self.tenant_id = int(tenant_id) self.llm = LLMService() self.context_cache = context_cache_service + self._active_external_qa_context: dict[str, Any] = {} @staticmethod def _normalize_thinking_mode(value: Optional[str]) -> str: @@ -33,17 +34,107 @@ class AdaptiveRAGCoreIntentMixin: asked_via: str, source_chat_id: Optional[str], conversation_key: Optional[str], + source_sender_open_id: Optional[str] = None, + sender: Optional[str] = None, + thread_context: Optional[dict[str, Any]] = None, ) -> str: + channel = str(asked_via or "").strip().lower() + if channel == "feishu": + stable_scope = self._normalize_conversation_key( + build_feishu_conversation_scope_key( + source_chat_id=source_chat_id, + source_sender_open_id=source_sender_open_id, + sender=sender, + ) + ) + if stable_scope: + return stable_scope explicit = self._normalize_conversation_key(conversation_key) if explicit: return explicit - channel = str(asked_via or "").strip().lower() if channel == "feishu": - chat = str(source_chat_id or "").strip() - if chat: - return self._normalize_conversation_key(f"feishu:{chat}") + return self._normalize_conversation_key( + build_feishu_thread_key( + source_chat_id=source_chat_id, + source_sender_open_id=source_sender_open_id, + sender=sender, + thread_context=thread_context, + ) + ) return "" + def _set_active_external_qa_context( + self, + *, + source_chat_id: Optional[str], + source_message_id: Optional[str], + source_sender_open_id: Optional[str], + conversation_scope_key: Optional[str], + thread_context: Optional[dict[str, Any]], + ) -> None: + context = { + "source_chat_id": str(source_chat_id or "").strip()[:128] or None, + "source_message_id": str(source_message_id or "").strip()[:128] or None, + "source_sender_open_id": str(source_sender_open_id or "").strip()[:128] or None, + "conversation_scope_key": str(conversation_scope_key or "").strip()[:160] or None, + "reply_to_message_id": str((thread_context or {}).get("reply_to_message_id") or "").strip()[:128] or None, + "root_message_id": str((thread_context or {}).get("root_message_id") or "").strip()[:128] or None, + } + self._active_external_qa_context = context + + def _get_active_external_qa_context(self) -> dict[str, Any]: + payload = self._active_external_qa_context if isinstance(self._active_external_qa_context, dict) else {} + return dict(payload) + + @staticmethod + def _normalize_routing_snapshot(raw: Any) -> dict[str, Any]: + payload = raw if isinstance(raw, dict) else {} + planned_tier = str(payload.get("planned_tier") or "").strip().lower() + executed_tier = str(payload.get("executed_tier") or "").strip().lower() + route_source = str(payload.get("route_source") or "").strip().lower() + route_rule_name = str(payload.get("route_rule_name") or "").strip() + routing_decision = str(payload.get("routing_decision") or "").strip() + normalized = { + "planned_tier": planned_tier if planned_tier in {"low", "high"} else None, + "executed_tier": executed_tier if executed_tier in {"low", "high"} else None, + "route_source": route_source or None, + "route_rule_name": route_rule_name or None, + "routing_decision": routing_decision or None, + } + return {key: value for key, value in normalized.items() if value is not None} + + def _peek_last_answer_routing_snapshot(self) -> dict[str, Any]: + payload = getattr(self.llm, "_last_ai_call_summary", None) + if not isinstance(payload, dict): + return {} + if str(payload.get("function_name") or "").strip() not in { + "adaptive_rag_answer_normal", + "adaptive_rag_answer_deep", + }: + return {} + return self._normalize_routing_snapshot(payload) + + def _build_qa_record_external_fields( + self, + *, + anchor_kind: Optional[str] = None, + anchor_ref: Optional[str] = None, + routing_snapshot: Optional[dict[str, Any]] = None, + ) -> dict[str, Any]: + context = self._get_active_external_qa_context() + normalized_snapshot = self._normalize_routing_snapshot(routing_snapshot) or None + return { + "source_message_id": context.get("source_message_id"), + "source_chat_id": context.get("source_chat_id"), + "source_sender_open_id": context.get("source_sender_open_id"), + "reply_to_message_id": context.get("reply_to_message_id"), + "root_message_id": context.get("root_message_id"), + "conversation_scope_key": context.get("conversation_scope_key"), + "anchor_kind": str(anchor_kind or "").strip()[:32] or None, + "anchor_ref": str(anchor_ref or "").strip()[:128] or None, + "routing_snapshot": normalized_snapshot, + } + @staticmethod def _external_session_id_from_key(conversation_key: str) -> Optional[int]: key = str(conversation_key or "").strip() @@ -144,4 +235,3 @@ class AdaptiveRAGCoreIntentMixin: "question_part": "", "statement_part": text[:1000], } - diff --git a/backend/app/services/adaptive_rag_service/mixin_deep_guard_answer.py b/backend/app/services/adaptive_rag_service/mixin_deep_guard_answer.py index b11e0e6c..c3970309 100644 --- a/backend/app/services/adaptive_rag_service/mixin_deep_guard_answer.py +++ b/backend/app/services/adaptive_rag_service/mixin_deep_guard_answer.py @@ -2,6 +2,7 @@ from __future__ import annotations from ...config.ai_prompts import PROMPT_PROJECT_STATUS_QA +from ..prompt_release import PromptReleaseService from .shared import * @@ -140,7 +141,21 @@ class AdaptiveRAGDeepGuardAnswerMixin: return f"[回答] {answer_block}\n[已收到需求] {signal_block}，已入库处理" - def _select_scene_prompt( + async def _render_scene_prompt( + self, + *, + prompt_key: str, + fallback_template: str, + **kwargs: Any, + ) -> str: + return await PromptReleaseService(self.db).render_prompt( + tenant_id=self.tenant_id, + prompt_key=prompt_key, + fallback_template=fallback_template, + **kwargs, + ) + + async def _select_scene_prompt( self, *, question: str, @@ -167,12 +182,14 @@ class AdaptiveRAGDeepGuardAnswerMixin: compact_user_snapshot_text = json.dumps(compact_user_snapshot or {}, ensure_ascii=False)[:6000] return ( "member_workload", - PROMPT_MEMBER_WORKLOAD_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_MEMBER_WORKLOAD_QA", + fallback_template=PROMPT_MEMBER_WORKLOAD_QA, question=question, system_snapshot=system_snapshot_text or "{}", user_snapshot=compact_user_snapshot_text or "{}", context_blocks=filtered_context_blocks, - ).strip(), + ), ) if str(message_intent or "").strip().lower() == "mixed": @@ -180,26 +197,30 @@ class AdaptiveRAGDeepGuardAnswerMixin: merged_message = f"{question}\n{safe_signal_part}".strip() return ( "mixed", - PROMPT_FEISHU_MIXED_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_FEISHU_MIXED_QA", + fallback_template=PROMPT_FEISHU_MIXED_QA, project_id=project_id if project_id is not None else "unknown", message=merged_message, question_part=question, signal_part=safe_signal_part, system_snapshot=system_snapshot_text or "{}", context_blocks=context_blocks_text or "无", - ).strip(), + ), ) if self._is_project_status_question(question, query_type): return ( "project_status", - PROMPT_PROJECT_STATUS_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_PROJECT_STATUS_QA", + fallback_template=PROMPT_PROJECT_STATUS_QA, project_id=project_id if project_id is not None else "unknown", question=question, system_snapshot=system_snapshot_text or "{}", user_snapshot=user_snapshot_text or "{}", context_blocks=context_blocks_text or "无", - ).strip(), + ), ) if self._contains_any_keyword(normalized_question, trend_keywords): @@ -231,25 +252,31 @@ class AdaptiveRAGDeepGuardAnswerMixin: )[:16000] return ( "external_trend", - PROMPT_EXTERNAL_TREND_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_EXTERNAL_TREND_QA", + fallback_template=PROMPT_EXTERNAL_TREND_QA, question=question, project_context=project_context_text or "{}", external_results=context_blocks_text or "无", - ).strip(), + ), ) return ( "industry_trend", - PROMPT_INDUSTRY_TREND_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_INDUSTRY_TREND_QA", + fallback_template=PROMPT_INDUSTRY_TREND_QA, question=question, - ).strip(), + ), ) if self._is_decision_choice_question(question): return ( "decision_choice", - PROMPT_DECISION_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_DECISION_QA", + fallback_template=PROMPT_DECISION_QA, question=question, - ).strip(), + ), ) if self._is_ai_pmo_process_entry(asked_via): @@ -262,31 +289,37 @@ class AdaptiveRAGDeepGuardAnswerMixin: )[:18000] return ( "ai_pmo", - PROMPT_AI_PMO_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_AI_PMO_QA", + fallback_template=PROMPT_AI_PMO_QA, question=question, project_id=project_id if project_id is not None else "unknown", world_model=world_model_text or "{}", context_blocks=context_blocks_text or "无", - ).strip(), + ), ) normalized_asked_via = str(asked_via or "").strip().lower() if normalized_asked_via in {"feishu", "lark", "feishu_group", "feishu_dm"}: return ( "feishu_direct", - PROMPT_FEISHU_DIRECT_QA.format( + await self._render_scene_prompt( + prompt_key="PROMPT_FEISHU_DIRECT_QA", + fallback_template=PROMPT_FEISHU_DIRECT_QA, project_id=project_id if project_id is not None else "unknown", question=question, system_snapshot=system_snapshot_text or "{}", user_snapshot=user_snapshot_text or "{}", conversation=conversation_text or "无", context_blocks=context_blocks_text or "无", - ).strip(), + ), ) return ( "default", - PROMPT_RAG_ANSWER.format( + await self._render_scene_prompt( + prompt_key="PROMPT_RAG_ANSWER", + fallback_template=PROMPT_RAG_ANSWER, project_id=project_id if project_id is not None else "unknown", question=question, conversation=conversation_text or "无", @@ -294,7 +327,7 @@ class AdaptiveRAGDeepGuardAnswerMixin: system_snapshot=system_snapshot_text or "{}", user_snapshot=user_snapshot_text or "{}", relevance_max=f"{max(0.0, float(relevance_max or 0.0)):.3f}", - ).strip(), + ), ) def _build_snapshot_direct_answer( @@ -535,7 +568,7 @@ class AdaptiveRAGDeepGuardAnswerMixin: context_blocks_text = chr(10).join(context_blocks) if context_blocks else "无" system_snapshot_text = json.dumps(system_snapshot or {}, ensure_ascii=False)[:12000] user_snapshot_text = json.dumps(user_snapshot or {}, ensure_ascii=False)[:6000] - scene_key, prompt = self._select_scene_prompt( + scene_key, prompt = await self._select_scene_prompt( question=question, project_id=project_id, asked_via=asked_via, diff --git a/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p1.py b/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p1.py index 693815bc..366002a3 100644 --- a/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p1.py +++ b/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p1.py @@ -1,6 +1,7 @@ """Adaptive RAG mixin module.""" from __future__ import annotations +from ..prompt_release import PromptReleaseService from .shared import * @@ -112,10 +113,13 @@ class AdaptiveRAGFastAnswerSemanticMixinP1: } ) - prompt = PROMPT_RAG_DB_PROJECT_QA.format( + prompt = await PromptReleaseService(self.db).render_prompt( + tenant_id=self.tenant_id, + prompt_key="PROMPT_RAG_DB_PROJECT_QA", + fallback_template=PROMPT_RAG_DB_PROJECT_QA, question=question[:600], project_index=json.dumps(project_index, ensure_ascii=False), - ).strip() + ) llm_started = time.perf_counter() try: raw = await self.llm.generate( @@ -165,4 +169,3 @@ class AdaptiveRAGFastAnswerSemanticMixinP1: } except Exception: return None - diff --git a/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p2.py b/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p2.py index 9a5e298c..8750815f 100644 --- a/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p2.py +++ b/backend/app/services/adaptive_rag_service/mixin_fast_answer_semantic_p2.py @@ -56,6 +56,7 @@ class AdaptiveRAGFastAnswerSemanticMixinP2: project_id=project_id, session_id=active_session_id_int, turn_index=active_turn_index, + **self._build_qa_record_external_fields(), ) self.db.add(qa) if state_row is None and active_session_id_int is not None: @@ -100,4 +101,3 @@ class AdaptiveRAGFastAnswerSemanticMixinP2: missing_fields=list(missing_fields or []), thinking_mode=thinking_mode, ) - diff --git a/backend/app/services/adaptive_rag_service/mixin_followup_anchor.py b/backend/app/services/adaptive_rag_service/mixin_followup_anchor.py new file mode 100644 index 00000000..4727b336 --- /dev/null +++ b/backend/app/services/adaptive_rag_service/mixin_followup_anchor.py @@ -0,0 +1,742 @@ +"""Adaptive RAG follow-up anchor resolution helpers.""" +from __future__ import annotations + +from dataclasses import dataclass, field +from datetime import timedelta + +from .shared import * + + +FOLLOWUP_RECENT_REPLY_WINDOW_MINUTES = 5 +FOLLOWUP_CANDIDATE_LIMIT = 3 +FOLLOWUP_META_HINTS = ( + "哪个模型", + "什么模型", + "谁回复", + "谁回答", + "为什么报错", + "为什么会报错", + "为什么失败", + "什么意思", + "你说的这个", + "你刚才那句", + "刚才那条", + "那条回复", + "上一条回复", +) +FOLLOWUP_SELECTION_DIGIT_RE = re.compile(r"^\s*([1-3])\s*$") +FOLLOWUP_SELECTION_ORDINAL_RE = re.compile(r"^\s*第?([一二三123])(?:条|个|项)?\s*$") +FOLLOWUP_FRESH_QUESTION_HINTS = ("?", "？", "为什么", "怎么", "如何", "哪些", "多少", "有没有", "帮我", "请", "解释") +FOLLOWUP_REMOVABLE_TOKENS = ( + "上一条", + "上一句", + "刚才", + "那条", + "这条", + "那个", + "这个", + "回复", + "回答", + "一下", + "帮我", + "请", + "解释", + "说下", + "说说", + "那句", + "这句", + "的", +) + + +@dataclass +class FollowupAnchorResolution: + anchor_mode: str = "no_anchor" + anchor_kind: Optional[str] = None + anchor_reply_id: Optional[int] = None + anchor_session_id: Optional[int] = None + candidate_replies: list[dict[str, Any]] = field(default_factory=list) + is_meta_followup: bool = False + meta_followup_kind: Optional[str] = None + clarification_code: Optional[str] = None + anchor_reply: Optional[dict[str, Any]] = None + effective_question: Optional[str] = None + + +class AdaptiveRAGFollowupAnchorMixin: + @staticmethod + def _normalize_followup_created_at(created_at: Optional[datetime]) -> Optional[datetime]: + if created_at is None: + return None + normalized = created_at if created_at.tzinfo is None else created_at.astimezone(CN_TZ).replace(tzinfo=None) + now_value = now_cn_naive() + direct_gap = abs((now_value - normalized).total_seconds()) + shifted = normalized + timedelta(hours=8) + shifted_gap = abs((now_value - shifted).total_seconds()) + # SQLite/部分环境下 server_default=now() 可能落成 UTC naive；优先选择更贴近当前会话时间的解释。 + if shifted_gap + 60 < direct_gap: + return shifted + return normalized + + @staticmethod + def _normalize_followup_selection_text(text: str) -> str: + normalized = re.sub(r"\s+", "", str(text or "")).strip().lower() + for token in FOLLOWUP_REMOVABLE_TOKENS: + normalized = normalized.replace(token, "") + normalized = re.sub(r"[^\w\u4e00-\u9fff]", "", normalized) + return normalized[:120] + + @staticmethod + def _normalize_followup_preview(text: str) -> str: + cleaned = re.sub(r"]*>.*?", "", str(text or ""), flags=re.IGNORECASE) + cleaned = " ".join(cleaned.split()).strip() + return cleaned[:160] + + @staticmethod + def _looks_like_meta_followup(question: str) -> bool: + normalized = re.sub(r"\s+", "", str(question or "")).lower() + return any(token in normalized for token in FOLLOWUP_META_HINTS) + + @staticmethod + def _classify_meta_followup_kind(question: str) -> Optional[str]: + normalized = re.sub(r"\s+", "", str(question or "")).lower() + if any(token in normalized for token in ("哪个模型", "什么模型", "谁回复", "谁回答")): + return "reply_model_identity" + if any(token in normalized for token in ("为什么报错", "为什么会报错", "为什么失败")): + return "reply_error_reason" + if any(token in normalized for token in ("来源", "根据什么", "什么依据")): + return "reply_source" + if any(token in normalized for token in ("什么意思", "你说的这个", "你刚才那句", "刚才那条", "那条回复", "上一条回复")): + return "reply_explanation" + return "reply_explanation" if normalized else None + + @staticmethod + def _looks_like_referential_followup(question: str) -> bool: + normalized = re.sub(r"\s+", "", str(question or "")).lower() + return any(token in normalized for token in (*FOLLOWUP_REFERENTIAL_KEYWORDS, "那条", "这条", "上一条", "上一句")) + + @staticmethod + def _looks_like_fresh_question(question: str) -> bool: + text = str(question or "").strip() + normalized = re.sub(r"\s+", "", text) + if not normalized: + return False + if FOLLOWUP_SELECTION_DIGIT_RE.match(text) or FOLLOWUP_SELECTION_ORDINAL_RE.match(text): + return False + return len(normalized) >= 5 and any(token in normalized for token in FOLLOWUP_FRESH_QUESTION_HINTS) + + @staticmethod + def _candidate_relative_time(created_at: Optional[datetime]) -> str: + if created_at is None: + return "刚才" + now_value = now_cn_naive() + delta_seconds = max(0, int((now_value - created_at).total_seconds())) + if delta_seconds < 60: + return "刚才" + minutes = max(1, delta_seconds // 60) + if minutes < 60: + return f"{minutes}分钟前" + hours = max(1, minutes // 60) + return f"{hours}小时前" + + def _build_followup_candidate(self, *, index: int, row: QARecord) -> dict[str, Any]: + question = " ".join(str(row.question or "").split()).strip() + answer = " ".join(str(row.answer or "").split()).strip() + label = question or "最近回复" + label = re.sub(r"^(?:帮我|请|麻烦|我想知道|想问下|问下|给我|解释下|解释一下|告诉我|说下)", "", label).strip() + label = re.sub(r"[？?！!。\.].*$", "", label).strip(" ，,:：") + label = label[:20] or (question[:20] if question else "最近回复") + answer_preview = answer[:56] + ("..." if len(answer) > 56 else "") + created_at = self._normalize_followup_created_at(getattr(row, "created_at", None)) + return { + "index": int(index), + "qa_id": int(row.id), + "label": label, + "question": question[:160], + "anchor_reply_preview": answer_preview, + "created_at": created_at.isoformat() if created_at else None, + "relative_time": self._candidate_relative_time(created_at), + "match_text": self._normalize_followup_selection_text(label or question), + } + + async def _load_explicit_reply_anchor( + self, + *, + thread_context: Optional[dict[str, Any]], + source_message_id: Optional[str] = None, + ) -> Optional[dict[str, Any]]: + if not isinstance(thread_context, dict): + return None + reply_to_message_id = str(thread_context.get("reply_to_message_id") or "").strip() + if not reply_to_message_id: + return None + outbox = ( + await self.db.execute( + select(FeishuReplyOutbox) + .where( + and_( + FeishuReplyOutbox.tenant_id == self.tenant_id, + FeishuReplyOutbox.status == "sent", + or_( + FeishuReplyOutbox.sent_message_id == reply_to_message_id, + FeishuReplyOutbox.source_message_id == reply_to_message_id, + ), + ) + ) + .order_by(FeishuReplyOutbox.id.desc()) + .limit(1) + ) + ).scalars().first() + if outbox is None: + return await self._load_current_ingest_closure_anchor(source_message_id=source_message_id) + + source_message_id = str(outbox.source_message_id or "").strip() + previous_question = "" + if source_message_id: + ingest = ( + await self.db.execute( + select(IngestEvent) + .where( + and_( + IngestEvent.tenant_id == self.tenant_id, + IngestEvent.channel == "feishu_message", + IngestEvent.event_key == source_message_id, + ) + ) + .order_by(IngestEvent.id.desc()) + .limit(1) + ) + ).scalars().first() + payload = ingest.payload if ingest is not None and isinstance(ingest.payload, dict) else {} + previous_question = ( + str(payload.get("message_text") or "").strip() + or str(payload.get("closure_summary") or "").strip() + or str(payload.get("closure_dialogue") or "").strip().splitlines()[-1].replace("用户：", "").strip() + ) + + preview = self._normalize_followup_preview(str(outbox.message_text or "")) + created_at = self._normalize_followup_created_at(getattr(outbox, "sent_at", None) or getattr(outbox, "created_at", None)) + label = previous_question or preview or "最近回复" + label = re.sub(r"[？?！!。\.].*$", "", label).strip(" ，,:：") + label = label[:20] or "最近回复" + return { + "index": 1, + "qa_id": 0, + "label": label, + "question": previous_question[:160], + "anchor_reply_preview": preview[:56] + ("..." if len(preview) > 56 else ""), + "created_at": created_at.isoformat() if created_at else None, + "relative_time": self._candidate_relative_time(created_at), + "match_text": self._normalize_followup_selection_text(previous_question or label), + "source_message_id": source_message_id or None, + "sent_message_id": str(outbox.sent_message_id or "").strip() or None, + "anchor_kind": "feishu_reply_outbox", + "anchor_id": int(outbox.id), + } + + async def _load_current_ingest_closure_anchor( + self, + *, + source_message_id: Optional[str], + ) -> Optional[dict[str, Any]]: + event_key = str(source_message_id or "").strip() + if not event_key: + return None + ingest = ( + await self.db.execute( + select(IngestEvent) + .where( + and_( + IngestEvent.tenant_id == self.tenant_id, + IngestEvent.channel == "feishu_message", + IngestEvent.event_key == event_key, + ) + ) + .order_by(IngestEvent.id.desc()) + .limit(1) + ) + ).scalars().first() + payload = ingest.payload if ingest is not None and isinstance(ingest.payload, dict) else {} + turns = payload.get("closure_turns") if isinstance(payload.get("closure_turns"), list) else [] + assistant_text = "" + previous_question = "" + for idx in range(len(turns) - 1, -1, -1): + turn = turns[idx] + if not isinstance(turn, dict): + continue + role = str(turn.get("role") or "").strip().lower() + text = str(turn.get("text") or "").strip() + if role != "assistant" or not text: + continue + assistant_text = text + for previous_idx in range(idx - 1, -1, -1): + previous_turn = turns[previous_idx] + if not isinstance(previous_turn, dict): + continue + if str(previous_turn.get("role") or "").strip().lower() != "user": + continue + previous_question = str(previous_turn.get("text") or "").strip() + if previous_question: + break + break + if not assistant_text: + return None + preview = self._normalize_followup_preview(assistant_text) + created_at = self._normalize_followup_created_at(getattr(ingest, "created_at", None)) + label = previous_question or preview or "最近回复" + label = re.sub(r"[？?！!。\.].*$", "", label).strip(" ，,:：") + label = label[:20] or "最近回复" + return { + "index": 1, + "qa_id": 0, + "label": label, + "question": previous_question[:160], + "anchor_reply_preview": preview[:56] + ("..." if len(preview) > 56 else ""), + "created_at": created_at.isoformat() if created_at else None, + "relative_time": self._candidate_relative_time(created_at), + "match_text": self._normalize_followup_selection_text(previous_question or label), + "source_message_id": event_key, + "sent_message_id": None, + "anchor_kind": "ingest_closure_turns", + "anchor_id": int(getattr(ingest, "id", 0) or 0), + } + + async def _load_recent_followup_candidates( + self, + *, + session_id: Optional[int], + conversation_scope_key: Optional[str] = None, + ) -> list[dict[str, Any]]: + if session_id is None and not str(conversation_scope_key or "").strip(): + return [] + recent_after = now_cn_naive() - timedelta(minutes=FOLLOWUP_RECENT_REPLY_WINDOW_MINUTES) + filters = [QARecord.tenant_id == self.tenant_id] + normalized_scope = str(conversation_scope_key or "").strip() + if normalized_scope: + filters.append(QARecord.conversation_scope_key == normalized_scope) + elif session_id is not None: + filters.append(QARecord.session_id == int(session_id)) + rows = ( + await self.db.execute( + select(QARecord) + .where(and_(*filters)) + .order_by(QARecord.created_at.desc(), QARecord.id.desc()) + .limit(FOLLOWUP_CANDIDATE_LIMIT * 4) + ) + ).scalars().all() + candidates: list[dict[str, Any]] = [] + for row in rows: + if not str(row.answer or "").strip(): + continue + created_at = self._normalize_followup_created_at(getattr(row, "created_at", None)) + if created_at is not None and created_at < recent_after: + continue + candidates.append(self._build_followup_candidate(index=len(candidates) + 1, row=row)) + if len(candidates) >= FOLLOWUP_CANDIDATE_LIMIT: + break + return candidates + + def _clear_pending_clarification(self, *, session_state: Optional[QASessionState]) -> None: + if session_state is None: + return + session_state.pending_clarification = None + session_state.pending_clarification_expires_at = None + + def _store_pending_clarification( + self, + *, + session_state: Optional[QASessionState], + original_question: str, + clarification_code: str, + candidates: list[dict[str, Any]], + previous_attempts: int = 0, + ) -> None: + if session_state is None: + return + session_state.pending_clarification = { + "kind": "followup_anchor_selection", + "clarification_code": clarification_code, + "original_question": str(original_question or "").strip()[:500], + "attempts": int(previous_attempts) + 1, + "candidates": [ + { + "index": int(candidate.get("index") or 0), + "qa_id": int(candidate.get("qa_id") or 0), + "label": str(candidate.get("label") or "").strip()[:80], + "match_text": str(candidate.get("match_text") or "").strip()[:120], + "question": str(candidate.get("question") or "").strip()[:180], + } + for candidate in candidates[:FOLLOWUP_CANDIDATE_LIMIT] + if int(candidate.get("qa_id") or 0) > 0 + ], + } + session_state.pending_clarification_expires_at = now_cn_naive() + timedelta( + minutes=FOLLOWUP_RECENT_REPLY_WINDOW_MINUTES + ) + + def _get_pending_clarification(self, *, session_state: Optional[QASessionState]) -> Optional[dict[str, Any]]: + if session_state is None: + return None + payload = session_state.pending_clarification if isinstance(session_state.pending_clarification, dict) else None + expires_at = self._to_naive_utc(getattr(session_state, "pending_clarification_expires_at", None)) + if not payload: + return None + if expires_at is not None and expires_at < now_cn_naive(): + self._clear_pending_clarification(session_state=session_state) + return None + return payload + + def _consume_pending_clarification_selection( + self, + *, + question: str, + session_state: Optional[QASessionState], + ) -> Optional[dict[str, Any]]: + payload = self._get_pending_clarification(session_state=session_state) + if not payload: + return None + text = str(question or "").strip() + index: Optional[int] = None + digit_match = FOLLOWUP_SELECTION_DIGIT_RE.match(text) + if digit_match: + index = int(digit_match.group(1)) + else: + ordinal_match = FOLLOWUP_SELECTION_ORDINAL_RE.match(text) + if ordinal_match: + raw = ordinal_match.group(1) + index = {"一": 1, "二": 2, "三": 3}.get(raw) + if index is None: + index = int(raw) + candidates = payload.get("candidates") if isinstance(payload.get("candidates"), list) else [] + normalized = self._normalize_followup_selection_text(text) + selected: Optional[dict[str, Any]] = None + for candidate in candidates: + if not isinstance(candidate, dict): + continue + candidate_index = int(candidate.get("index") or 0) + if index is not None and candidate_index == index: + selected = candidate + break + match_text = str(candidate.get("match_text") or "").strip() + if normalized and match_text and (normalized in match_text or match_text in normalized): + selected = candidate + break + if selected is None: + if self._looks_like_fresh_question(question): + self._clear_pending_clarification(session_state=session_state) + return None + self._clear_pending_clarification(session_state=session_state) + return { + "selected_qa_id": int(selected.get("qa_id") or 0), + "effective_question": str(payload.get("original_question") or "").strip(), + } + + async def _resolve_followup_anchor( + self, + *, + question: str, + session_id: Optional[int], + context_session_id: Optional[int], + session_state: Optional[QASessionState], + conversation_scope_key: Optional[str] = None, + source_chat_id: Optional[str] = None, + source_sender_open_id: Optional[str] = None, + source_message_id: Optional[str] = None, + thread_context: Optional[dict[str, Any]] = None, + ) -> FollowupAnchorResolution: + text = str(question or "").strip() + if not text: + return FollowupAnchorResolution() + is_meta_followup = self._looks_like_meta_followup(text) + meta_followup_kind = self._classify_meta_followup_kind(text) if is_meta_followup else None + is_referential_followup = self._looks_like_referential_followup(text) + if not is_meta_followup and not is_referential_followup: + return FollowupAnchorResolution(is_meta_followup=False) + + active_session_id = int(session_id) if session_id is not None else ( + int(context_session_id) if context_session_id is not None else None + ) + explicit_anchor = await self._load_explicit_reply_anchor( + thread_context=thread_context, + source_message_id=source_message_id, + ) + if explicit_anchor is not None: + return FollowupAnchorResolution( + anchor_mode="explicit", + anchor_kind=str(explicit_anchor.get("anchor_kind") or "explicit_reply"), + anchor_reply_id=int(explicit_anchor.get("anchor_id") or 0) or None, + anchor_session_id=active_session_id, + is_meta_followup=is_meta_followup, + meta_followup_kind=meta_followup_kind, + anchor_reply=explicit_anchor, + ) + scope_key = str(conversation_scope_key or "").strip() + if not scope_key and (source_chat_id or source_sender_open_id): + scope_key = build_feishu_conversation_scope_key( + source_chat_id=source_chat_id, + source_sender_open_id=source_sender_open_id, + sender=None, + ) + candidates = await self._load_recent_followup_candidates( + session_id=active_session_id, + conversation_scope_key=scope_key, + ) + if not candidates: + return FollowupAnchorResolution( + anchor_mode="no_anchor", + anchor_session_id=active_session_id, + is_meta_followup=is_meta_followup, + meta_followup_kind=meta_followup_kind, + clarification_code="no_anchor_found", + ) + + normalized = self._normalize_followup_selection_text(text) + matching = [ + candidate + for candidate in candidates + if normalized + and str(candidate.get("match_text") or "").strip() + and ( + normalized in str(candidate.get("match_text") or "").strip() + or str(candidate.get("match_text") or "").strip() in normalized + ) + ] + chosen = matching[0] if len(matching) == 1 else None + if chosen is not None: + return FollowupAnchorResolution( + anchor_mode="explicit", + anchor_kind="recent_scope_reply", + anchor_reply_id=int(chosen["qa_id"]), + anchor_session_id=active_session_id, + is_meta_followup=is_meta_followup, + meta_followup_kind=meta_followup_kind, + anchor_reply=chosen, + ) + + if len(candidates) == 1: + chosen = candidates[0] + return FollowupAnchorResolution( + anchor_mode="implicit_recent_reply", + anchor_kind="meta_recent_reply" if is_meta_followup else "recent_scope_reply", + anchor_reply_id=int(chosen["qa_id"]), + anchor_session_id=active_session_id, + is_meta_followup=is_meta_followup, + meta_followup_kind=meta_followup_kind, + anchor_reply=chosen, + ) + + if isinstance(thread_context, dict) and str(thread_context.get("reply_to_message_id") or "").strip(): + chosen = candidates[0] + return FollowupAnchorResolution( + anchor_mode="implicit_recent_reply", + anchor_kind="meta_recent_reply" if is_meta_followup else "recent_scope_reply", + anchor_reply_id=int(chosen["qa_id"]), + anchor_session_id=active_session_id, + is_meta_followup=is_meta_followup, + meta_followup_kind=meta_followup_kind, + anchor_reply=chosen, + ) + + return FollowupAnchorResolution( + anchor_mode="ambiguous_candidates", + anchor_kind="recent_scope_reply", + anchor_session_id=active_session_id, + candidate_replies=candidates, + is_meta_followup=is_meta_followup, + meta_followup_kind=meta_followup_kind, + clarification_code="ambiguous_recent_reply", + ) + + def _rewrite_question_with_followup_anchor( + self, + *, + question: str, + anchor_resolution: Optional[FollowupAnchorResolution], + ) -> tuple[str, dict[str, Any]]: + resolution = anchor_resolution or FollowupAnchorResolution() + anchor_reply = resolution.anchor_reply if isinstance(resolution.anchor_reply, dict) else None + if anchor_reply is None: + return str(question or "").strip(), {"mode": "direct"} + current = str(question or "").strip() + label = str(anchor_reply.get("label") or anchor_reply.get("question") or "最近回复").strip() + preview = str(anchor_reply.get("anchor_reply_preview") or "").strip() + previous_question = str(anchor_reply.get("question") or "").strip() + if resolution.is_meta_followup: + rewritten = ( + f"围绕上一条 PMFlow 回复回答。上一轮用户问题：{previous_question}。" + f"上一轮回复摘要：{preview}。当前追问：{current}" + ) + return rewritten[:1200], {"mode": "followup_anchor_meta", "qa_id": int(anchor_reply.get("qa_id") or 0)} + rewritten = f"围绕上一轮对话“{label}”继续回答：{current}" + return rewritten[:1200], {"mode": "followup_anchor_recent_reply", "qa_id": int(anchor_reply.get("qa_id") or 0)} + + def _build_followup_clarification_payload( + self, + *, + question: str, + anchor_resolution: Optional[FollowupAnchorResolution], + session_state: Optional[QASessionState], + ) -> Optional[dict[str, Any]]: + resolution = anchor_resolution or FollowupAnchorResolution() + if resolution.clarification_code == "ambiguous_recent_reply": + existing = self._get_pending_clarification(session_state=session_state) + attempts = int(existing.get("attempts") or 0) if isinstance(existing, dict) else 0 + if attempts >= 1: + return { + "answer": ( + "我不确定你指的是哪一条我刚才的回复。" + "你可以直接回复那条消息，或者告诉我是“系统架构”那条还是“系统模型”那条。" + ), + "code": "no_anchor_found", + "candidates": [], + "missing_fields": ["reply_anchor"], + } + lines = ["我猜你在追问我刚才其中一条回复，请回我编号或短标题："] + for candidate in resolution.candidate_replies[:FOLLOWUP_CANDIDATE_LIMIT]: + if not isinstance(candidate, dict): + continue + lines.append( + f"{int(candidate.get('index') or 0)}. {str(candidate.get('label') or '最近回复')} " + f"({str(candidate.get('relative_time') or '刚才')})" + ) + return { + "answer": "\n".join(lines), + "code": "ambiguous_recent_reply", + "candidates": resolution.candidate_replies[:FOLLOWUP_CANDIDATE_LIMIT], + "missing_fields": ["reply_anchor"], + } + if resolution.clarification_code == "no_anchor_found": + return { + "answer": ( + "我没定位到你指的是哪条我刚才的回复。" + "你可以直接引用那条消息，或者补一句关键词让我对上。" + ), + "code": "no_anchor_found", + "candidates": [], + "missing_fields": ["reply_anchor"], + } + _ = question + return None + + async def _resolve_anchor_qa_record( + self, + *, + anchor_resolution: Optional[FollowupAnchorResolution], + conversation_scope_key: Optional[str] = None, + ) -> Optional[QARecord]: + resolution = anchor_resolution or FollowupAnchorResolution() + if resolution.anchor_reply_id: + row = await self.db.get(QARecord, int(resolution.anchor_reply_id)) + if row is not None: + return row + anchor_reply = resolution.anchor_reply if isinstance(resolution.anchor_reply, dict) else {} + source_message_id = str(anchor_reply.get("source_message_id") or "").strip() + if source_message_id: + row = ( + await self.db.execute( + select(QARecord) + .where( + and_( + QARecord.tenant_id == self.tenant_id, + QARecord.source_message_id == source_message_id, + ) + ) + .order_by(QARecord.created_at.desc(), QARecord.id.desc()) + .limit(1) + ) + ).scalars().first() + if row is not None: + return row + scope_key = str(conversation_scope_key or "").strip() + if not scope_key: + return None + return ( + await self.db.execute( + select(QARecord) + .where( + and_( + QARecord.tenant_id == self.tenant_id, + QARecord.conversation_scope_key == scope_key, + ) + ) + .order_by(QARecord.created_at.desc(), QARecord.id.desc()) + .limit(1) + ) + ).scalars().first() + + async def _build_meta_followup_payload( + self, + *, + question: str, + anchor_resolution: Optional[FollowupAnchorResolution], + conversation_scope_key: Optional[str] = None, + ) -> Optional[dict[str, Any]]: + resolution = anchor_resolution or FollowupAnchorResolution() + if not resolution.is_meta_followup: + return None + meta_kind = str(resolution.meta_followup_kind or self._classify_meta_followup_kind(question) or "").strip() + if not meta_kind: + return None + anchor_row = await self._resolve_anchor_qa_record( + anchor_resolution=resolution, + conversation_scope_key=conversation_scope_key, + ) + anchor_kind = str(resolution.anchor_kind or "").strip() or None + if anchor_row is None: + return { + "answer": "当前无法追溯到本次回复的路由记录。", + "meta_followup_kind": meta_kind, + "reason_code": "meta_followup_no_route_record", + "anchor_kind": anchor_kind, + "anchor_mode": resolution.anchor_mode, + "routing_snapshot": {}, + } + + routing_snapshot = ( + anchor_row.routing_snapshot + if isinstance(anchor_row.routing_snapshot, dict) + else {} + ) + normalized_snapshot = self._normalize_routing_snapshot(routing_snapshot) + answer_text = "" + reason_code = "meta_followup_answered" + if meta_kind == "reply_model_identity": + if normalized_snapshot: + answer_text = ( + "这条回复的逻辑路由为：" + f"planned_tier={normalized_snapshot.get('planned_tier') or 'unknown'}, " + f"executed_tier={normalized_snapshot.get('executed_tier') or normalized_snapshot.get('planned_tier') or 'unknown'}, " + f"source={normalized_snapshot.get('route_source') or 'unknown'}, " + f"rule={normalized_snapshot.get('route_rule_name') or 'unknown'}, " + f"decision={normalized_snapshot.get('routing_decision') or 'unknown'}。" + ) + else: + source_labels = [str(item.get("label") or "").strip() for item in (anchor_row.sources or []) if isinstance(item, dict)] + if any("snapshot" in label.lower() or "system" in label.lower() for label in source_labels): + answer_text = "这条回复不是模型生成结果，而是系统快照/确定性查询回执，所以没有 low/high 路由记录。" + reason_code = "meta_followup_non_model_answer" + else: + answer_text = "当前无法追溯到本次回复的路由记录。" + reason_code = "meta_followup_no_route_record" + elif meta_kind == "reply_error_reason": + anchored_answer = str(anchor_row.answer or "").strip() + if "系统处理中出现异常" in anchored_answer or "未执行" in anchored_answer: + answer_text = "那条回复是一次执行异常回执，不是正常问答结果。" + else: + answer_text = "那条回复本身不是错误回执；如果你指的是模型失败，需要引用具体那条报错消息。" + elif meta_kind == "reply_source": + source_labels = [str(item.get("label") or "").strip() for item in (anchor_row.sources or []) if isinstance(item, dict)] + labels_text = "、".join([label for label in source_labels[:3] if label]) or "system_context" + answer_text = f"那条回复主要基于这些来源：{labels_text}。" + else: + answer_text = f"我刚才那条回复的核心意思是：{str(anchor_row.answer or '').strip()[:200]}" + + return { + "answer": answer_text, + "meta_followup_kind": meta_kind, + "reason_code": reason_code, + "anchor_kind": anchor_kind, + "anchor_mode": resolution.anchor_mode, + "routing_snapshot": normalized_snapshot, + "anchor_ref": str(anchor_row.id), + } diff --git a/backend/app/services/adaptive_rag_service/mixin_qa_session_core.py b/backend/app/services/adaptive_rag_service/mixin_qa_session_core.py index a74bc50d..000aa9d2 100644 --- a/backend/app/services/adaptive_rag_service/mixin_qa_session_core.py +++ b/backend/app/services/adaptive_rag_service/mixin_qa_session_core.py @@ -44,8 +44,10 @@ class AdaptiveRAGQASessionCoreMixin: question: str, preferred_session_id: Optional[int] = None, force_new_session: bool = False, + external_conversation_key: Optional[str] = None, ) -> tuple[Optional[int], int]: - if asked_by is None: + external_key = str(external_conversation_key or "").strip()[:160] or None + if asked_by is None and external_key is None: return (None, 1) now_utc = now_cn_naive() @@ -57,15 +59,31 @@ class AdaptiveRAGQASessionCoreMixin: select(QASession).where( and_( QASession.tenant_id == self.tenant_id, - QASession.user_id == int(asked_by), QASession.id == preferred_id, + ( + QASession.user_id == int(asked_by) + if asked_by is not None + else QASession.external_conversation_key == external_key + ), + ) + ) + ) + ).scalar_one_or_none() + + if chosen is None and external_key: + chosen = ( + await self.db.execute( + select(QASession).where( + and_( + QASession.tenant_id == self.tenant_id, + QASession.external_conversation_key == external_key, ) ) ) ).scalar_one_or_none() # 无显式 session_id 时，仅在非强制新会话模式下复用同渠道（asked_via）且时间窗口内的最近会话。 - if chosen is None and not force_new_session: + if chosen is None and asked_by is not None and not force_new_session: latest_record = ( await self.db.execute( select(QARecord.session_id, QARecord.created_at) @@ -103,7 +121,8 @@ class AdaptiveRAGQASessionCoreMixin: title = self._build_auto_session_title(question) or SESSION_DEFAULT_TITLE chosen = QASession( tenant_id=self.tenant_id, - user_id=int(asked_by), + user_id=int(asked_by) if asked_by is not None else None, + external_conversation_key=external_key, title=title[:120], project_id=project_id, started_at=now_utc, @@ -115,6 +134,8 @@ class AdaptiveRAGQASessionCoreMixin: else: if chosen.project_id is None and project_id is not None: chosen.project_id = int(project_id) + if not str(chosen.external_conversation_key or "").strip() and external_key: + chosen.external_conversation_key = external_key chosen.last_message_at = now_utc chosen.message_count = int(chosen.message_count or 0) + 1 @@ -149,4 +170,3 @@ class AdaptiveRAGQASessionCoreMixin: if curr is None or curr_at is None or fb_at >= curr_at: latest_feedback[key] = fb return latest_feedback - diff --git a/backend/app/services/adaptive_rag_service/mixin_requirement_ack_flow.py b/backend/app/services/adaptive_rag_service/mixin_requirement_ack_flow.py index 4f8294cf..dc046fdc 100644 --- a/backend/app/services/adaptive_rag_service/mixin_requirement_ack_flow.py +++ b/backend/app/services/adaptive_rag_service/mixin_requirement_ack_flow.py @@ -2,6 +2,7 @@ from __future__ import annotations from .shared import * +from ..ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class AdaptiveRAGRequirementAckFlowMixin: @@ -44,7 +45,7 @@ class AdaptiveRAGRequirementAckFlowMixin: linked_signal_id is not None and resolved_project_id is not None and action_taken in {"signal_created", "signal_deduped"} - and SignalSourceOrchestrationService.looks_like_signal_source_request(effective_question or question) + and WorkflowSemanticPlanner.looks_like_signal_source_request(effective_question or question) ): try: source_orchestration_result = await SignalSourceOrchestrationService(self.db).orchestrate_from_signal( @@ -115,6 +116,7 @@ class AdaptiveRAGRequirementAckFlowMixin: project_id=resolved_project_id if resolved_project_id is not None else project_id, session_id=session_id, turn_index=int(turn_index or 1), + **self._build_qa_record_external_fields(), ) self.db.add(qa) await self._update_session_state_after_turn( @@ -170,4 +172,3 @@ class AdaptiveRAGRequirementAckFlowMixin: trace_id=trace_id, processing_stage="ack_only", ) - diff --git a/backend/app/services/adaptive_rag_service/mixin_session_state.py b/backend/app/services/adaptive_rag_service/mixin_session_state.py index bbe1d30d..7d3e2e6c 100644 --- a/backend/app/services/adaptive_rag_service/mixin_session_state.py +++ b/backend/app/services/adaptive_rag_service/mixin_session_state.py @@ -27,6 +27,8 @@ class AdaptiveRAGSessionStateMixin: last_intent=None, ambiguity="unknown", rewrite_history=[], + pending_clarification=None, + pending_clarification_expires_at=None, ) self.db.add(row) await self.db.flush() @@ -38,6 +40,7 @@ class AdaptiveRAGSessionStateMixin: question: str, conversation: list[dict[str, str]], session_state: Optional[QASessionState], + anchor_resolution: Optional[FollowupAnchorResolution] = None, ) -> tuple[str, dict[str, Any]]: expanded = self._expand_followup_question(question, conversation) current = str(expanded or question or "").strip() @@ -66,37 +69,14 @@ class AdaptiveRAGSessionStateMixin: anchor = ",".join(str(x) for x in state_entity_ids[:6]) rewritten = f"围绕会话实体ID[{anchor}]回答：{current}" return rewritten[:1200], {"mode": "state_entities", "entity_ids": state_entity_ids[:6]} + anchored_question, anchor_meta = self._rewrite_question_with_followup_anchor( + question=current, + anchor_resolution=anchor_resolution, + ) + if str(anchor_meta.get("mode") or "").strip() not in {"", "direct"}: + return anchored_question, anchor_meta return current, {"mode": "referential_without_subject"} - def _build_clarification_question( - self, - *, - original_question: str, - effective_question: str, - session_state: Optional[QASessionState], - ) -> Optional[str]: - text = str(original_question or "").strip().lower() - if not text: - return None - if self._is_correction_query(text): - if self._has_explicit_target_scope(text): - return None - return ( - "收到，你在纠正上一条回答。请直接说你要的目标范围，例如：" - "`我问的是 AI 引擎驱动方式，第一层是否调用 openclaw？`" - ) - has_referential = any(k in text for k in FOLLOWUP_REFERENTIAL_KEYWORDS) - if not has_referential: - return None - state_subject = str(getattr(session_state, "last_subject", "") or "").strip() - state_entity_ids = getattr(session_state, "last_entity_ids", None) - has_state_entities = isinstance(state_entity_ids, list) and any(str(x).strip() for x in state_entity_ids) - if state_subject or has_state_entities: - return None - if str(effective_question or "").strip() != text and "补充问题" in str(effective_question): - return None - return "你这句缺少明确主语。请先指明对象，例如：`分别是哪些项目？` 或 `请列出这些项目的名称和ID`。" - async def _update_session_state_after_turn( self, *, @@ -111,12 +91,14 @@ class AdaptiveRAGSessionStateMixin: ) -> None: if session_state is None: return - subject = self._extract_state_subject(question=question, answer=answer, sources=sources) - if subject: - session_state.last_subject = subject[:255] session_state.last_intent = "question" session_state.ambiguity = str(ambiguity or "clear")[:20] - session_state.last_entity_ids = self._collect_entity_ids_from_sources(sources) + if str(ambiguity or "").strip() != "needs_clarification": + subject = self._extract_state_subject(question=question, answer=answer, sources=sources) + if subject: + session_state.last_subject = subject[:255] + session_state.last_entity_ids = self._collect_entity_ids_from_sources(sources) + self._clear_pending_clarification(session_state=session_state) history = session_state.rewrite_history if isinstance(session_state.rewrite_history, list) else [] history.append( @@ -220,6 +202,11 @@ class AdaptiveRAGSessionStateMixin: "last_intent": str(state.last_intent or "") if state else "", "ambiguity": str(state.ambiguity or "") if state else "", "rewrite_history": history[-20:], + "pending_clarification": state.pending_clarification if state else None, + "pending_clarification_expires_at": ( + state.pending_clarification_expires_at.isoformat() + if state and state.pending_clarification_expires_at + else None + ), "updated_at": state.updated_at.isoformat() if state and state.updated_at else None, } - diff --git a/backend/app/services/adaptive_rag_service/service.py b/backend/app/services/adaptive_rag_service/service.py index 05bec306..3e98e08f 100644 --- a/backend/app/services/adaptive_rag_service/service.py +++ b/backend/app/services/adaptive_rag_service/service.py @@ -39,6 +39,7 @@ from .mixin_deep_guard_answer import AdaptiveRAGDeepGuardAnswerMixin from .mixin_conversation_utils_a_p1 import AdaptiveRAGConversationUtilsAMixinP1 from .mixin_conversation_utils_a_p2 import AdaptiveRAGConversationUtilsAMixinP2 from .mixin_conversation_utils_b import AdaptiveRAGConversationUtilsBMixin +from .mixin_followup_anchor import AdaptiveRAGFollowupAnchorMixin class AdaptiveRAGService( @@ -80,6 +81,7 @@ class AdaptiveRAGService( AdaptiveRAGConversationUtilsAMixinP1, AdaptiveRAGConversationUtilsAMixinP2, AdaptiveRAGConversationUtilsBMixin, + AdaptiveRAGFollowupAnchorMixin, ): """项目内统一 RAG 服务。""" _symbol_snapshot_cache: dict[str, tuple[float, dict[str, Any]]] = {} diff --git a/backend/app/services/adaptive_rag_service/shared_imports.py b/backend/app/services/adaptive_rag_service/shared_imports.py index db0b00b9..f3f51fbb 100644 --- a/backend/app/services/adaptive_rag_service/shared_imports.py +++ b/backend/app/services/adaptive_rag_service/shared_imports.py @@ -46,6 +46,9 @@ from ...models import ( KGEvidence, KGEntity, KGRelation, + AICallLog, + FeishuReplyOutbox, + IngestEvent, Project, ProjectSignalLink, QAFeedback, @@ -66,3 +69,4 @@ from ..signal.symbol_index import SymbolIndexService from ...utils.timezone import CN_TZ, now_cn_aware, now_cn_naive +from ...utils.thread_context import build_feishu_conversation_scope_key, build_feishu_thread_key diff --git a/backend/app/services/ai_pmo/ai_pmo_intent/intent_resolver.py b/backend/app/services/ai_pmo/ai_pmo_intent/intent_resolver.py index 6c88445d..22333a45 100644 --- a/backend/app/services/ai_pmo/ai_pmo_intent/intent_resolver.py +++ b/backend/app/services/ai_pmo/ai_pmo_intent/intent_resolver.py @@ -1,6 +1,7 @@ from __future__ import annotations from .models import * +from ..workflow_semantic_planner import WorkflowSemanticPlanner class IntentResolver: """Resolve raw text to canonical intent.""" @@ -50,10 +51,16 @@ class IntentResolver: @staticmethod def resolve(*, text: str, project_id: Optional[int]) -> CanonicalIntent: - normalized = re.sub(r"\s+", "", str(text or "")).lower() pretty = re.sub(r"\s+", " ", str(text or "")).strip() + normalized = re.sub(r"\s+", "", str(text or "")).lower() if not pretty: return CanonicalIntent(INTENT_IGNORE, 1.0, project_id, "", "", {"reason": "empty"}) + bundle = WorkflowSemanticPlanner.plan_message( + message_text=pretty, + source_system="compat_intent_resolver", + metadata={"project_id": project_id}, + ) + workflow_types = [item.workflow_type for item in bundle.workflows] if IntentResolver._is_smalltalk_message(pretty=pretty, normalized=normalized): return CanonicalIntent(INTENT_IGNORE, 0.95, project_id, "", "", {"reason": "smalltalk"}) if IntentResolver._looks_like_negated_write_statement(text=pretty): @@ -76,34 +83,46 @@ class IntentResolver: { "followup_by_work_item_id": True, "target_work_item_id": _safe_int(explicit_followup_target.group(1)), + "semantic_bundle": bundle.to_dict(), }, ) if any(token in pretty for token in FOLLOWUP_CONFIRM_HINTS): return CanonicalIntent(INTENT_FOLLOWUP_CONFIRM, 0.82, project_id, "", "", {}) if any(token in pretty for token in FOLLOWUP_CONTINUE_HINTS): return CanonicalIntent(INTENT_FOLLOWUP_CONTINUE, 0.82, project_id, "", "", {}) - if SignalSourceOrchestrationService.looks_like_signal_source_request(pretty): + if workflow_types and workflow_types[0] == "followup_flow": + followup_action = bundle.workflows[0].workflow_action + followup_intent = INTENT_FOLLOWUP_CONFIRM if followup_action == "confirm" else INTENT_FOLLOWUP_CONTINUE + return CanonicalIntent( + followup_intent, + 0.84, + project_id, + "", + "", + { + "followup_action": followup_action, + "semantic_bundle": bundle.to_dict(), + }, + ) + if WorkflowSemanticPlanner.looks_like_signal_source_request(pretty): return CanonicalIntent( INTENT_SIGNAL_SOURCE_ONBOARD, 0.92, project_id, IntentResolver._build_signal_title(pretty, default="新增信号源接入请求"), pretty[:300], - {"source_request": True}, + {"source_request": True, "semantic_bundle": bundle.to_dict()}, ) - if ( - IntentResolver._looks_like_project_create_request(text=pretty) - or extract_project_create_title(pretty) - ): + if "new_project_flow" in workflow_types or extract_project_create_title(pretty): return CanonicalIntent( INTENT_PROJECT_CREATE, 0.9, project_id, IntentResolver._build_signal_title(pretty, default="新项目创建请求"), pretty[:300], - {}, + {"semantic_bundle": bundle.to_dict()}, ) - if IntentResolver._looks_like_task_create_request(text=pretty): + if "task_flow" in workflow_types: extracted_title = IntentResolver._extract_task_title(pretty) return CanonicalIntent( INTENT_TASK_CREATE, @@ -111,25 +130,35 @@ class IntentResolver: project_id, extracted_title or IntentResolver._build_signal_title(pretty, default="新任务"), pretty[:300], - {"task_title": extracted_title} if extracted_title else {}, + { + **({"task_title": extracted_title} if extracted_title else {}), + "semantic_bundle": bundle.to_dict(), + }, ) - if IntentResolver._looks_like_signal_create_request(text=pretty): + if "project_signal_flow" in workflow_types: return CanonicalIntent( INTENT_SIGNAL_CREATE, 0.78, project_id, IntentResolver._build_signal_title(pretty, default="新信号"), pretty[:300], - {}, + { + "semantic_bundle": bundle.to_dict(), + "workflow_route": ( + "project_signal.discover" + if bundle.workflows and bundle.workflows[0].workflow_action == "discover" + else "project_signal.create" + ), + }, ) - if IntentResolver._looks_like_query(text=pretty): + if "query_flow" in workflow_types or IntentResolver._looks_like_query(text=pretty): return CanonicalIntent( INTENT_QUERY, 0.88, project_id, "", pretty[:300], - {}, + {"semantic_bundle": bundle.to_dict()}, ) return CanonicalIntent( INTENT_QUERY, @@ -137,61 +166,24 @@ class IntentResolver: project_id, "", pretty[:300], - {"fallback": True, "reason": "default_query_fallback"}, + {"fallback": True, "reason": "default_query_fallback", "semantic_bundle": bundle.to_dict()}, ) @staticmethod - def _looks_like_signal_create_request(*, text: str) -> bool: - normalized = re.sub(r"\s+", "", str(text or "")).lower() - if not normalized: - return False - if IntentResolver._looks_like_negated_write_statement(text=normalized): - return False - candidate_discover_hints = ("候选", "换一批", "刷新", "再来一批", "先分析") - if ( - any(token in normalized for token in candidate_discover_hints) - and any(token in normalized for token in ("确认", "入库", "提交")) - and any(token in normalized for token in ("项目", "project")) - ): - return True - if re.search(r"(?:抓|找|给).{0,8}(?:\d+|[一二两三四五])(?:条|个)?候选", normalized, re.IGNORECASE): - return True - if any(token in normalized for token in SIGNAL_CREATE_HINTS): - return True - signal_object_hints = ("信号", "需求", "事项", "问题", "改造", "优化") - has_operation = any(token in normalized for token in IntentResolver.OPERATION_VERBS) - has_signal_object = any(token in normalized for token in signal_object_hints) - if has_operation and has_signal_object: - return True - return bool( - re.search( - r"(?:给|帮|请).{0,20}(?:新增|增加|添加|补充|加).{0,20}(?:信号|需求|事项)", - normalized, - re.IGNORECASE, - ) + def _looks_like_signal_create_request(*, text: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + bundle = WorkflowSemanticPlanner.plan_message( + message_text=str(text or ""), + source_system="compat_intent_resolver", ) + return any(item.workflow_type == "project_signal_flow" for item in bundle.workflows) @staticmethod - def _looks_like_task_create_request(*, text: str) -> bool: - normalized = re.sub(r"\s+", "", str(text or "")).lower() - if not normalized: - return False - if IntentResolver._looks_like_negated_write_statement(text=normalized): - return False - if any(token in normalized for token in TASK_CREATE_HINTS): - return True - task_object_hints = ("任务", "工单", "待办", "todo") - has_operation = any(token in normalized for token in IntentResolver.OPERATION_VERBS) - has_task_object = any(token in normalized for token in task_object_hints) - if has_operation and has_task_object: - return True - return bool( - re.search( - r"(?:给|帮|请).{0,24}(?:新增|增加|添加|创建|新建|加).{0,16}(?:任务|工单|待办)", - normalized, - re.IGNORECASE, - ) + def _looks_like_task_create_request(*, text: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + bundle = WorkflowSemanticPlanner.plan_message( + message_text=str(text or ""), + source_system="compat_intent_resolver", ) + return any(item.workflow_type == "task_flow" for item in bundle.workflows) @staticmethod def _extract_task_title(text: str) -> str: @@ -225,52 +217,24 @@ class IntentResolver: @staticmethod def _is_smalltalk_message(*, pretty: str, normalized: str) -> bool: - compact = re.sub(r"[\\s\\?？!！,，。~～、]+", "", str(pretty or "")).strip().lower() - if not compact: - return True - if any(keyword in compact for keyword in SMALLTALK_STRUCTURED_HINTS): - return False - if compact in SMALLTALK_EXACT: - return True - if len(compact) <= 8 and any(keyword in compact for keyword in SMALLTALK_SHORT_HINTS): - return True - return False + _ = normalized + return WorkflowSemanticPlanner._is_smalltalk_message(pretty) @staticmethod - def _looks_like_query(*, text: str) -> bool: - normalized = re.sub(r"\s+", "", str(text or "")).lower() - if not normalized: - return False - if IntentResolver._looks_like_signal_create_request(text=normalized): - return False - if IntentResolver._looks_like_task_create_request(text=normalized): - return False - if any(token in normalized for token in QUESTION_HINTS): - return True - has_question_structure = ( - "?" in normalized - or "？" in normalized - or any(token in normalized for token in ("吗", "呢", "吧", "是否", "是不是")) + def _looks_like_query(*, text: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + bundle = WorkflowSemanticPlanner.plan_message( + message_text=str(text or ""), + source_system="compat_intent_resolver", ) - if not has_question_structure: - return False - has_operation = any(token in normalized for token in IntentResolver.OPERATION_VERBS) - return not has_operation + return len(bundle.workflows) == 1 and bundle.workflows[0].workflow_type == "query_flow" @staticmethod - def _looks_like_project_create_request(*, text: str) -> bool: - normalized = re.sub(r"\s+", "", str(text or "")).lower() - if not normalized: - return False - if any(token in normalized for token in PROJECT_CREATE_HINTS): - return True - return bool( - re.search( - r"(?:新增|增加|添加|新建|创建|建立|开个|开一个|建个|建一个|做个|做一个|加个|加一个|立项)(?:一个|个)?(?:[^，。！？,.!?]{0,24})项目", - normalized, - re.IGNORECASE, - ) + def _looks_like_project_create_request(*, text: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + bundle = WorkflowSemanticPlanner.plan_message( + message_text=str(text or ""), + source_system="compat_intent_resolver", ) + return any(item.workflow_type == "new_project_flow" for item in bundle.workflows) @staticmethod def _build_signal_title(text: str, *, default: str) -> str: diff --git a/backend/app/services/ai_pmo/ai_pmo_intent/route_resolver.py b/backend/app/services/ai_pmo/ai_pmo_intent/route_resolver.py index 609d19f0..86fd945a 100644 --- a/backend/app/services/ai_pmo/ai_pmo_intent/route_resolver.py +++ b/backend/app/services/ai_pmo/ai_pmo_intent/route_resolver.py @@ -1,6 +1,7 @@ from __future__ import annotations from .models import * +from ..workflow_semantic_planner import WorkflowSemanticPlanner class RouteResolver: """Map canonical intent + text into workflow route.""" @@ -57,7 +58,7 @@ class RouteResolver: return 1 @staticmethod - def looks_like_project_signal_discover(*, message_text: str, metadata: dict[str, Any]) -> bool: + def looks_like_project_signal_discover(*, message_text: str, metadata: dict[str, Any]) -> bool: # semantic-lint: ignore - compat route helper over planner metadata explicit_route = str(metadata.get("workflow_route") or "").strip().lower() if isinstance(metadata, dict) else "" if explicit_route == ROUTE_PROJECT_SIGNAL_DISCOVER: return True @@ -71,26 +72,11 @@ class RouteResolver: canonical_intent: str, message_text: str = "", ) -> str: - payload = metadata if isinstance(metadata, dict) else {} - explicit_action = str(payload.get("followup_action") or payload.get("action") or "").strip().lower() - if explicit_action in { - ROUTE_ACTION_CONTINUE, - ROUTE_ACTION_CONFIRM, - ROUTE_ACTION_COMMIT, - ROUTE_ACTION_CANCEL, - ROUTE_ACTION_REFRESH, - }: - return explicit_action - normalized_text = re.sub(r"\s+", "", str(message_text or "")).lower() - if any(token in normalized_text for token in FOLLOWUP_REFRESH_HINTS): - return ROUTE_ACTION_REFRESH - if any(token in normalized_text for token in FOLLOWUP_CANCEL_HINTS): - return ROUTE_ACTION_CANCEL - if any(token in normalized_text for token in FOLLOWUP_COMMIT_HINTS): - return ROUTE_ACTION_COMMIT - if canonical_intent in {INTENT_FOLLOWUP_CONFIRM, INTENT_FOLLOWUP_CONTINUE}: - return ROUTE_ACTION_COMMIT - return ROUTE_ACTION_CONTINUE + return WorkflowSemanticPlanner.parse_followup_action( + metadata=metadata, + canonical_intent=canonical_intent, + message_text=message_text, + ) @classmethod def from_canonical( @@ -114,7 +100,7 @@ class RouteResolver: route_key = ROUTE_TASK_CREATE elif canonical_intent.name in {INTENT_FOLLOWUP_CONFIRM, INTENT_FOLLOWUP_CONTINUE}: action = cls.parse_followup_action( - metadata=metadata, + metadata={**metadata, "followup_context_present": True}, canonical_intent=canonical_intent.name, message_text=message_text, ) diff --git a/backend/app/services/ai_pmo/ai_pmo_intent/shared.py b/backend/app/services/ai_pmo/ai_pmo_intent/shared.py index 758636cc..710c92a6 100644 --- a/backend/app/services/ai_pmo/ai_pmo_intent/shared.py +++ b/backend/app/services/ai_pmo/ai_pmo_intent/shared.py @@ -8,6 +8,23 @@ from typing import Any, Optional from ....utils.project_command_utils import extract_project_create_title from ...signal.signal_source_orchestration import SignalSourceOrchestrationService +from ..workflow_semantic_planner.constants import ( + FOLLOWUP_CANCEL_HINTS, + FOLLOWUP_COMMIT_HINTS, + FOLLOWUP_CONFIRM_HINTS, + FOLLOWUP_CONTINUE_HINTS, + FOLLOWUP_REFRESH_HINTS, + FOLLOWUP_WORK_ITEM_ID_RE, + PROJECT_CREATE_HINTS, + PROJECT_SIGNAL_DISCOVER_HINTS, + QUESTION_HINTS, + SHORT_CONFIRM_HINTS, + SIGNAL_CREATE_HINTS, + SMALLTALK_EXACT, + SMALLTALK_SHORT_HINTS, + SMALLTALK_STRUCTURED_HINTS, + TASK_CREATE_HINTS, +) INTENT_QUERY = "query.read_only" INTENT_PROJECT_CREATE = "project.create" @@ -215,116 +232,8 @@ LEGACY_INTENT_ROUTE_MAP: dict[str, str] = { "signal_source.onboard": ROUTE_SIGNAL_SOURCE_ONBOARD, } -PROJECT_SIGNAL_DISCOVER_HINTS = ( - "候选", - "先分析", - "先看候选", - "给我确认", - "待确认", - "再让我确认", - "确认后入库", - "先不要入库", - "先别入库", -) -FOLLOWUP_REFRESH_HINTS = ("换一批", "再来一批", "刷新候选", "重新找", "再找一组", "换一组") -FOLLOWUP_CANCEL_HINTS = ("取消", "先不做", "先别做", "不要了", "算了", "reject", "驳回") -FOLLOWUP_COMMIT_HINTS = ("确认", "继续处理", "继续执行", "同意", "批准", "approve") - -QUESTION_HINTS = ( - "?", - "？", - "怎么", - "如何", - "为何", - "为什么", - "什么", - "是什么", - "哪些", - "有哪些", - "特点", - "技术特点", - "能力", - "介绍", - "说明", - "多少", - "是否", - "帮我看", - "状态", - "风险", - "能做什么", - "可以做什么", -) -SMALLTALK_EXACT = { - "收到", - "收到啦", - "好的", - "ok", - "okk", - "yes", - "no", - "谢谢", - "thanks", - "thx", - "在吗", - "在不在", - "怎么样了", - "咋样了", - "辛苦了", -} -SMALLTALK_SHORT_HINTS = ("怎么样了", "咋样了", "在吗", "辛苦了", "收到", "谢谢", "ok") -SMALLTALK_STRUCTURED_HINTS = ("项目", "信号", "任务", "风险", "进度", "状态", "work_item", "工作项", "#") -FOLLOWUP_CONFIRM_HINTS = ("确认归属", "确认项目", "确认到项目", "确认关联", "确认这条") -FOLLOWUP_CONTINUE_HINTS = ("继续处理", "继续执行", "接着处理", "往下做", "继续推进") -FOLLOWUP_WORK_ITEM_ID_RE = re.compile(r"(?:work[_ -]?item|工作项|队列项)\s*(?:id|ID)?\s*[:#：]?\s*(\d+)", re.IGNORECASE) -SIGNAL_CREATE_HINTS = ("新增一个信号", "新增一条信号", "增加一个信号", "录入一个信号", "关注", "跟踪") -TASK_CREATE_HINTS = ( - "创建任务", - "新建任务", - "新增任务", - "增加任务", - "添加任务", - "加个任务", - "加一个任务", - "安排任务", - "分配任务", - "派个任务", -) -PROJECT_CREATE_HINTS = ( - "创建项目", - "新建项目", - "建立项目", - "做个项目", - "立项", - "开个项目", - "新增项目", - "新增个项目", - "新增一个项目", - "增加项目", - "增加个项目", - "增加一个项目", - "添加项目", - "添加一个项目", - "加个项目", - "加一个项目", -) SESSION_SHORT_CONFIRM_WINDOW_SECONDS = 5 * 60 SHORT_CONFIRM_MAX_MESSAGE_LENGTH = 10 -SHORT_CONFIRM_HINTS = ( - "是", - "好", - "对", - "确认", - "新增", - "加", - "嗯", - "yes", - "ok", - "好的", - "是的", - "行", - "可以", - "没问题", -) INTENT_LLM_FUNCTION_NAME = "classify_intent_ai_pmo_kernel" INTENT_CANDIDATES = ( INTENT_SIGNAL_SOURCE_ONBOARD, diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel/ai_agent_kernel.py b/backend/app/services/ai_pmo/ai_pmo_kernel/ai_agent_kernel.py index 22a9eeaa..b483f0e6 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel/ai_agent_kernel.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel/ai_agent_kernel.py @@ -7,25 +7,16 @@ import re from dataclasses import dataclass from typing import Iterable, Sequence +from ..workflow_semantic_planner.constants import ( + BACKGROUND_MARKERS, + CORRECTION_ACTION_PATTERNS, + INTENT_GROUP_KEYWORDS, + MULTI_SEGMENT_MARKERS, +) + INTENT_FUNCTION_SIMPLE = "classify_intent_ai_pmo_kernel" INTENT_FUNCTION_COMPLEX = "classify_intent_complex" -BACKGROUND_MARKERS = ("因为", "所以", "用来", "为了", "方便", "希望", "背景", "场景") -MULTI_SEGMENT_MARKERS = (",", "，", "、", ";", "；", "并且", "同时", "然后") -INTENT_GROUP_KEYWORDS: dict[str, tuple[str, ...]] = { - "project": ("项目", "立项", "创建项目", "新增项目", "新建项目"), - "signal": ("信号", "信号源", "接入", "onboard", "source"), - "task": ("任务", "分配", "指派", "执行", "部署"), - "change": ("修改", "更新", "改为", "改成", "撤销", "回滚", "归档"), -} - -CORRECTION_ACTION_PATTERNS: tuple[tuple[str, tuple[str, ...]], ...] = ( - ("undo_last", ("撤销", "撤回", "undo", "作废上一步", "取消上一步")), - ("rollback", ("回滚", "恢复到", "还原", "回退")), - ("replace_target", ("改为", "改成", "替换为", "不是", "不对", "纠正")), - ("reroute", ("重新识别", "重新判断", "重新路由", "再判断一次")), -) - def _env_float(name: str, default: float) -> float: raw = os.getenv(name) diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel/ai_pmo_typed_executor_common.py b/backend/app/services/ai_pmo/ai_pmo_kernel/ai_pmo_typed_executor_common.py index e6594f4f..a0ec0dcf 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel/ai_pmo_typed_executor_common.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel/ai_pmo_typed_executor_common.py @@ -4,7 +4,6 @@ from __future__ import annotations import hashlib import json -import re from datetime import timedelta from typing import Any, Optional @@ -96,6 +95,10 @@ from ..ai_pmo_intent import ( IntentResolver, RouteResolver, ) +from ..workflow_semantic_planner.constants import ( + GENERIC_SIGNAL_SOURCE_MESSAGE_RE, + MODULE_KEYWORD_RULES, +) from ...ai_steward_service import AIStewardService from ...llm_service import llm_service from ...model.model_context_bundle import ModelContextBundleService @@ -103,22 +106,6 @@ from ...signal.signal_planner import SignalPlannerService logger = get_logger(__name__) -GENERIC_SIGNAL_SOURCE_MESSAGE_RE = re.compile( - r"^(?:请)?(?:按|按照)?(?:这个|上述|这条)?(?:分步|步骤)?(?:骤)?(?:把|将)?(?:它|该需求|这条需求)?(?:加入|接入|录入).{0,24}信号源(?:中)?$", - re.IGNORECASE, -) - -MODULE_KEYWORD_RULES: tuple[tuple[str, tuple[str, ...]], ...] = ( - ("用户管理与权限", ("用户管理", "角色权限", "crud", "批量导入", "成员管理")), - ("技能图谱", ("技能图谱", "技能标签", "能力图谱", "雷达图")), - ("工作量管理", ("工作量", "负载", "产能", "workload")), - ("SSTC 工作流", ("sstc", "charter", "signal", "task", "execution", "release", "review", "工作流")), - ("AI 能力编排", ("ai能力", "智能", "自动化", "推荐", "编排", "agent", "llm")), - ("信号源接入", ("信号源", "source", "onboard", "接入")), - ("飞书集成", ("飞书", "feishu", "群聊", "机器人")), - ("消息台与详情页", ("消息台", "详情页", "展开详情", "摘要", "时间戳", "按钮")), -) - def _utc_now_naive(): return now_cn_naive() diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/ingress/ai_pmo_kernel_mixins_ingress_render.py b/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/ingress/ai_pmo_kernel_mixins_ingress_render.py index bcd25372..456d5fd2 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/ingress/ai_pmo_kernel_mixins_ingress_render.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/ingress/ai_pmo_kernel_mixins_ingress_render.py @@ -3,6 +3,7 @@ from __future__ import annotations from .... import ai_pmo_kernel_common_core as _common +from ....workflow_semantic_planner import WorkflowSemanticPlanner for _name, _value in vars(_common).items(): if not _name.startswith("__"): @@ -86,6 +87,24 @@ class KernelIngressRenderMixin: else ((intent.metadata or {}).get("decision_trace") if isinstance(intent.metadata, dict) else None) ), } + semantic_bundle = ( + (intent.metadata or {}).get("semantic_bundle") + if isinstance(intent.metadata, dict) + else None + ) + if not isinstance(semantic_bundle, dict): + semantic_bundle = WorkflowSemanticPlanner.plan_from_intent( + intent_name=str(intent.name or ""), + message_text=str(getattr(work_item, "raw_message", "") or direct_reply_text or intent.signal_summary or ""), + source_system=str(getattr(work_item, "source_system", "") or "unknown"), + workflow_route=str(work_item.intent or execution_result.get("workflow_route") or "").strip(), + project_id=_safe_int(work_item.project_id), + metadata=intent.metadata if isinstance(intent.metadata, dict) else {}, + ).to_dict() + result["semantic_bundle"] = semantic_bundle + result["semantic_bundle_id"] = str(semantic_bundle.get("bundle_id") or "").strip() or None + result["semantic_version"] = str(semantic_bundle.get("semantic_version") or "").strip() or None + result["semantic_source"] = "workflow_semantic_planner" if str(render.get("template_key") or "").strip().lower() == "draft_pending_confirm": payload = render.get("payload") if isinstance(render.get("payload"), dict) else {} result["draft_version"] = _safe_int(payload.get("draft_version")) or _safe_int(getattr(work_item, "draft_version", None)) diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_llm.py b/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_llm.py index e022d1b5..1083bcbe 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_llm.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_llm.py @@ -3,6 +3,7 @@ from __future__ import annotations from .... import ai_pmo_kernel_common_core as _common +from ....workflow_semantic_planner import WorkflowSemanticPlanner for _name, _value in vars(_common).items(): if not _name.startswith("__"): @@ -198,6 +199,26 @@ class KernelIntentLLMMixin: if structured_route is not None else bool(payload.get("requires_confirmation")) ), + "semantic_bundle": WorkflowSemanticPlanner.plan_from_intent( + intent_name=intent_name, + message_text=message_text, + source_system="ai_pmo_ingress", + workflow_route=( + structured_route.key + if structured_route is not None + else LEGACY_INTENT_ROUTE_MAP.get(intent_name, ROUTE_QUERY_ANSWER) + ), + project_id=project_id, + metadata={ + **payload, + "confidence": confidence, + "requires_confirmation": ( + structured_route.requires_confirmation + if structured_route is not None + else bool(payload.get("requires_confirmation")) + ), + }, + ).to_dict(), }, ) diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_rules.py b/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_rules.py index 28673432..3e63aaab 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_rules.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel/mixins/intent/ai_pmo_kernel_mixins_intent_rules.py @@ -3,6 +3,7 @@ from __future__ import annotations from .... import ai_pmo_kernel_common_core as _common +from ....workflow_semantic_planner import WorkflowSemanticPlanner for _name, _value in vars(_common).items(): if not _name.startswith("__"): @@ -10,42 +11,6 @@ for _name, _value in vars(_common).items(): class KernelIntentRulesMixin: - CONTEXTUAL_CONFIRM_HINTS = ( - "来吧", - "那就", - "就这么办", - "就按这个", - "可以", - "好的", - "不错", - "开始吧", - "行", - "没问题", - "同意", - "确认", - ) - CONTEXTUAL_DEICTIC_HINTS = ( - "这个", - "这个项目", - "这条", - "它", - "按这个", - "照这个", - ) - CONTEXTUAL_WRITE_ACTION_HINTS = ( - "创建", - "新建", - "新增", - "增加", - "添加", - "执行", - "开始", - "继续处理", - "继续执行", - "推进", - "落地", - ) - @staticmethod def _intent_llm_enabled() -> bool: return _env_bool("AI_PMO_INTENT_LLM_ENABLED", True) @@ -104,18 +69,8 @@ class KernelIntentRulesMixin: ) @classmethod - def _looks_like_contextual_write_confirmation(cls, *, message_text: str) -> bool: - normalized = re.sub(r"\s+", "", str(message_text or "")).lower() - if not normalized: - return False - if cls._has_question_structure(normalized=normalized): - return False - has_write_action = any(token in normalized for token in cls.CONTEXTUAL_WRITE_ACTION_HINTS) - if not has_write_action: - return False - has_confirm = any(token in normalized for token in cls.CONTEXTUAL_CONFIRM_HINTS) - has_deictic = any(token in normalized for token in cls.CONTEXTUAL_DEICTIC_HINTS) - return has_confirm or has_deictic + def _looks_like_contextual_write_confirmation(cls, *, message_text: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_contextual_write_confirmation(message_text) def _recover_session_followup_write_intent( self, diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel_common_core/constants.py b/backend/app/services/ai_pmo/ai_pmo_kernel_common_core/constants.py index 73158e7c..4eab709b 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel_common_core/constants.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel_common_core/constants.py @@ -3,6 +3,12 @@ from __future__ import annotations from .imports import re +from ..workflow_semantic_planner.constants import ( + GENERIC_SIGNAL_SOURCE_MESSAGE_RE, + MODULE_KEYWORD_RULES, + POLICY_GATE_RULES, + TRANSPORT_MODE_CORRECTION_HINTS, +) STATE_RECEIVED = "received" STATE_MODELED = "modeled" @@ -20,37 +26,6 @@ RECEIPT_PHASE_ACTION = "action_applied" RECEIPT_PHASE_PENDING = "pending_manual" RECEIPT_PHASE_ERROR = "error" -TRANSPORT_MODE_CORRECTION_HINTS = ( - "不是", - "不再", - "改为", - "改成", - "替换为", - "取代", - "现在都", - "现在是", -) -GENERIC_SIGNAL_SOURCE_MESSAGE_RE = re.compile( - r"^(?:请)?(?:按|按照)?(?:这个|上述|这条)?(?:分步|步骤)?(?:骤)?(?:把|将)?(?:它|该需求|这条需求)?(?:加入|接入|录入).{0,24}信号源(?:中)?$", - re.IGNORECASE, -) -MODULE_KEYWORD_RULES: tuple[tuple[str, tuple[str, ...]], ...] = ( - ("用户管理与权限", ("用户管理", "角色权限", "crud", "批量导入", "成员管理")), - ("技能图谱", ("技能图谱", "技能标签", "能力图谱", "雷达图")), - ("工作量管理", ("工作量", "负载", "产能", "workload")), - ("SSTC 工作流", ("sstc", "charter", "signal", "task", "execution", "release", "review", "工作流")), - ("AI 能力编排", ("ai能力", "智能", "自动化", "推荐", "编排", "agent", "llm")), - ("信号源接入", ("信号源", "source", "onboard", "接入")), - ("飞书集成", ("飞书", "feishu", "群聊", "机器人")), - ("消息台与详情页", ("消息台", "详情页", "展开详情", "摘要", "时间戳", "按钮")), -) -POLICY_GATE_RULES: tuple[tuple[str, tuple[str, ...]], ...] = ( - ("delete_or_archive", ("删除项目", "删除信号", "归档项目", "归档", "archive", "清空项目")), - ("budget_overrun", ("超预算", "突破预算", "额外预算", "加预算")), - ("cross_project_staffing", ("跨项目抢人", "抽调", "抢占关键人力", "挪人")), - ("charter_rewrite", ("改写charter", "success criteria", "成功标准改", "范围重大变更")), - ("critical_path_change", ("关键路径", "里程碑改动", "影响多个项目", "跨项目依赖调整")), -) BOOL_TRUE_VALUES = {"1", "true", "yes", "y", "on", "是"} SESSION_PROJECT_INHERIT_WINDOW_SECONDS = 30 * 60 INTENT_LLM_TIMEOUT_DEFAULT_SECONDS = 30.0 diff --git a/backend/app/services/ai_pmo/ai_pmo_kernel_ingress_flow/mixin_entry.py b/backend/app/services/ai_pmo/ai_pmo_kernel_ingress_flow/mixin_entry.py index e2826739..000d4cb8 100644 --- a/backend/app/services/ai_pmo/ai_pmo_kernel_ingress_flow/mixin_entry.py +++ b/backend/app/services/ai_pmo/ai_pmo_kernel_ingress_flow/mixin_entry.py @@ -1,6 +1,7 @@ from __future__ import annotations from .shared import * +from app.utils.thread_context import build_feishu_conversation_scope_key class KernelIngressFlowEntryMixin: _MIXED_HINT_CONNECTORS = ("顺便", "另外", "同时", "并且", "还有", "再问") @@ -30,6 +31,8 @@ class KernelIngressFlowEntryMixin: source_system: str, source_message_id: str, channel_ref: Optional[str], + source_sender_open_id: Optional[str], + thread_context: Optional[dict[str, Any]], message_text: str, project_hint_id: Optional[int], ) -> tuple[str, dict[str, Any]]: @@ -58,13 +61,23 @@ class KernelIngressFlowEntryMixin: signal_part = str(intent_result.get("statement_part") or "").strip() or str(message_text or "").strip() sidecar_answer = "" try: + conversation_key = source_message_id + if str(source_system or "").strip().lower() == "feishu": + conversation_key = build_feishu_conversation_scope_key( + source_chat_id=channel_ref, + source_sender_open_id=source_sender_open_id, + sender=None, + ) or source_message_id rag_result = await rag_service.answer_question( question=question_part, asked_by=None, asked_via=source_system, project_id=None, source_chat_id=channel_ref, - conversation_key=source_message_id, + source_message_id=source_message_id, + conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, message_intent="mixed", mixed_signal_part=signal_part, ) @@ -203,6 +216,8 @@ class KernelIngressFlowEntryMixin: source_system=source_system, source_message_id=synthetic_message_id, channel_ref=channel_ref, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, message_text=clean_text, project_hint_id=project_hint_id, ) diff --git a/backend/app/services/ai_pmo/ai_pmo_typed_executor_execute/mixin_execute_query_project.py b/backend/app/services/ai_pmo/ai_pmo_typed_executor_execute/mixin_execute_query_project.py index 749fd880..93c402bd 100644 --- a/backend/app/services/ai_pmo/ai_pmo_typed_executor_execute/mixin_execute_query_project.py +++ b/backend/app/services/ai_pmo/ai_pmo_typed_executor_execute/mixin_execute_query_project.py @@ -8,7 +8,7 @@ from ...adaptive_rag_service import AdaptiveRAGService from ...context_cache_service import context_cache_service from ...sstc_service_core import ALIGNED_STATUSES from ...task_persistence_core import build_task_create_draft, persist_task -from app.utils.thread_context import build_feishu_thread_key +from app.utils.thread_context import build_feishu_conversation_scope_key, build_feishu_thread_key class ExecuteQueryProjectMixin: @@ -45,6 +45,7 @@ class ExecuteQueryProjectMixin: mixed_signal_part = str(rag_request_context.get("mixed_signal_part") or "").strip() or None else: thread_context = metadata.get("thread_context") if isinstance(metadata.get("thread_context"), dict) else None + source_sender_open_id = str(metadata.get("source_sender_open_id") or "").strip() or None is_feishu_source = str(source_system or "").strip().lower() == "feishu" if is_feishu_source: asked_by = None @@ -55,12 +56,10 @@ class ExecuteQueryProjectMixin: requested_project_id = None source_chat_id = None conversation_key = ( - build_feishu_thread_key( + build_feishu_conversation_scope_key( source_chat_id=None, - source_sender_open_id=None, + source_sender_open_id=source_sender_open_id, sender=None, - source_message_id=source_message_id, - thread_context=thread_context, ) if is_feishu_source else source_message_id @@ -72,13 +71,19 @@ class ExecuteQueryProjectMixin: sync_requirement = False message_intent = None mixed_signal_part = None + if isinstance(rag_request_context, dict): + source_sender_open_id = str(rag_request_context.get("source_sender_open_id") or "").strip() or None + thread_context = rag_request_context.get("thread_context") if isinstance(rag_request_context.get("thread_context"), dict) else None rag_kwargs: dict[str, Any] = { "question": message_text, "asked_by": asked_by, "asked_via": asked_via, "project_id": requested_project_id if requested_project_id is not None else intent.project_id, "source_chat_id": source_chat_id, + "source_message_id": source_message_id, "conversation_key": conversation_key, + "source_sender_open_id": source_sender_open_id, + "thread_context": thread_context, "action_mode": action_mode, "sync_requirement": sync_requirement, "message_intent": message_intent, diff --git a/backend/app/services/ai_pmo/draft_confirm_handler.py b/backend/app/services/ai_pmo/draft_confirm_handler.py index e73cbdfa..457b7652 100644 --- a/backend/app/services/ai_pmo/draft_confirm_handler.py +++ b/backend/app/services/ai_pmo/draft_confirm_handler.py @@ -12,6 +12,7 @@ for _name, _value in vars(_common).items(): globals()[_name] = _value from ..ai_steward_service import AIStewardService +from .workflow_semantic_planner import WorkflowSemanticPlanner from ..signal.draft_generator_service import DraftGeneratorService from ...models.feishu_reply_outbox import FeishuReplyOutbox @@ -24,10 +25,6 @@ class DraftConfirmHandler: _ACTION_CANCEL = "cancel" _ACTION_UNKNOWN = "unknown" - _CONFIRM_HINTS = ("确认", "好的", "就这样", "行", "ok", "okay", "同意", "没问题") - _REVISE_HINTS = ("修改", "改成", "改为", "改", "换成") - _CANCEL_HINTS = ("取消", "不要", "算了", "放弃") - _WORK_ITEM_ID_RE = re.compile(r"(?:work[_ -]?item|工作项|草稿)\s*(?:id|ID)?\s*[:#：]?\s*(\d+)", re.IGNORECASE) def __init__(self, kernel: Any) -> None: @@ -38,15 +35,8 @@ class DraftConfirmHandler: @classmethod def parse_action_from_text(cls, *, message_text: str) -> tuple[str, str]: - text = str(message_text or "").strip() - lowered = text.lower() - if any(hint in text for hint in cls._REVISE_HINTS): - return cls._ACTION_REVISE, cls._extract_revision_note(text) - if any(hint in text for hint in cls._CANCEL_HINTS): - return cls._ACTION_CANCEL, "" - if any(hint in text for hint in cls._CONFIRM_HINTS) or lowered in {"y", "yes"}: - return cls._ACTION_CONFIRM, "" - return cls._ACTION_UNKNOWN, "" + action, note = WorkflowSemanticPlanner.parse_draft_action(message_text=message_text) + return action, note async def handle_text_reply( self, @@ -812,12 +802,10 @@ class DraftConfirmHandler: @classmethod def _extract_revision_note(cls, text: str) -> str: - normalized = str(text or "").strip() - for hint in cls._REVISE_HINTS: - if normalized.startswith(hint): - note = normalized[len(hint):].strip(" ：:") - return note[:500] - return "" + action, note = WorkflowSemanticPlanner.parse_draft_action(message_text=text) + if action != cls._ACTION_REVISE: + return "" + return str(note or "")[:500] @staticmethod def _safe_float(value: Any) -> Optional[float]: diff --git a/backend/app/services/ai_pmo/workflow_semantic_planner/__init__.py b/backend/app/services/ai_pmo/workflow_semantic_planner/__init__.py new file mode 100644 index 00000000..65ecc2ea --- /dev/null +++ b/backend/app/services/ai_pmo/workflow_semantic_planner/__init__.py @@ -0,0 +1,12 @@ +from .constants import * +from .models import ReplyContract, WorkflowBundle, WorkflowPlan, WorkflowSlot, workflow_slot +from .service import WorkflowSemanticPlanner + +__all__ = [ + "ReplyContract", + "WorkflowBundle", + "WorkflowPlan", + "WorkflowSlot", + "WorkflowSemanticPlanner", + "workflow_slot", +] diff --git a/backend/app/services/ai_pmo/workflow_semantic_planner/constants.py b/backend/app/services/ai_pmo/workflow_semantic_planner/constants.py new file mode 100644 index 00000000..846a2afe --- /dev/null +++ b/backend/app/services/ai_pmo/workflow_semantic_planner/constants.py @@ -0,0 +1,319 @@ +from __future__ import annotations + +import re + +SEMANTIC_VERSION = "2026-03-27.workflow-v1" + +INTENT_QUERY = "query.read_only" +INTENT_PROJECT_CREATE = "project.create" +INTENT_PROJECT_UPDATE = "project.update" +INTENT_PROJECT_ARCHIVE = "project.archive" +INTENT_PROJECT_REOPEN = "project.reopen" +INTENT_PROJECT_DELETE = "project.delete" +INTENT_TASK_CREATE = "task.create" +INTENT_TASK_UPDATE = "task.update" +INTENT_TASK_ASSIGN = "task.assign" +INTENT_TASK_PRIORITIZE = "task.prioritize" +INTENT_TASK_STATUS_TRANSITION = "task.status_transition" +INTENT_TASK_DELETE = "task.delete" +INTENT_SIGNAL_CREATE = "signal.create" +INTENT_SIGNAL_SOURCE_ONBOARD = "signal_source.onboard" +INTENT_FOLLOWUP_CONFIRM = "followup.confirm" +INTENT_FOLLOWUP_CONTINUE = "followup.continue" +INTENT_IGNORE = "ignore" + +ROUTE_QUERY_ANSWER = "query.answer" +ROUTE_PROJECT_CREATE = "project_create.create" +ROUTE_TASK_CREATE = "task.create" +ROUTE_SIGNAL_SOURCE_ONBOARD = "signal_source.onboard" +ROUTE_PROJECT_SIGNAL_CREATE = "project_signal.create" +ROUTE_PROJECT_SIGNAL_DISCOVER = "project_signal.discover" +ROUTE_PROJECT_SIGNAL_COMMIT = "project_signal.commit" +ROUTE_PROJECT_SIGNAL_CANCEL = "project_signal.cancel" +ROUTE_PROJECT_SIGNAL_REFRESH = "project_signal.refresh" +ROUTE_FOLLOWUP_CONFIRM = "followup.confirm" +ROUTE_FOLLOWUP_CONTINUE = "followup.continue" + +WORKFLOW_QUERY = "query_flow" +WORKFLOW_NEW_PROJECT = "new_project_flow" +WORKFLOW_PROJECT = "project_flow" +WORKFLOW_TASK = "task_flow" +WORKFLOW_PROJECT_SIGNAL = "project_signal_flow" +WORKFLOW_SIGNAL_SOURCE = "signal_source_flow" +WORKFLOW_FOLLOWUP = "followup_flow" + +MESSAGE_GATE_AUTO = "auto_execute" +MESSAGE_GATE_PENDING = "pending_confirmation" +MESSAGE_GATE_FAILED_SAFE = "failed_safe" + +REPLY_MODE_CARD = "aggregate_card" +REPLY_MODE_TEXT = "aggregate_text" + +BACKGROUND_MARKERS = ("因为", "所以", "用来", "为了", "方便", "希望", "背景", "场景") +MULTI_SEGMENT_MARKERS = (",", "，", "、", ";", "；", "并且", "同时", "然后") + +INTENT_GROUP_KEYWORDS: dict[str, tuple[str, ...]] = { + "project": ("项目", "立项", "创建项目", "新增项目", "新建项目"), + "signal": ("信号", "信号源", "接入", "onboard", "source"), + "task": ("任务", "分配", "指派", "执行", "部署"), + "change": ("修改", "更新", "改为", "改成", "撤销", "回滚", "归档"), +} + +CORRECTION_ACTION_PATTERNS: tuple[tuple[str, tuple[str, ...]], ...] = ( + ("undo_last", ("撤销", "撤回", "undo", "作废上一步", "取消上一步")), + ("rollback", ("回滚", "恢复到", "还原", "回退")), + ("replace_target", ("改为", "改成", "替换为", "不是", "不对", "纠正")), + ("reroute", ("重新识别", "重新判断", "重新路由", "再判断一次")), +) + +TRANSPORT_MODE_CORRECTION_HINTS = ( + "不是", + "不再", + "改为", + "改成", + "替换为", + "取代", + "现在都", + "现在是", +) + +CONTEXTUAL_CONFIRM_HINTS = ( + "来吧", + "那就", + "就这么办", + "就按这个", + "可以", + "好的", + "不错", + "开始吧", + "行", + "没问题", + "同意", + "确认", +) +CONTEXTUAL_DEICTIC_HINTS = ( + "这个", + "这个项目", + "这条", + "它", + "按这个", + "照这个", +) +CONTEXTUAL_WRITE_ACTION_HINTS = ( + "创建", + "新建", + "新增", + "增加", + "添加", + "执行", + "开始", + "继续处理", + "继续执行", + "推进", + "落地", +) + +GENERIC_SIGNAL_SOURCE_MESSAGE_RE = re.compile( + r"^(?:请)?(?:按|按照)?(?:这个|上述|这条)?(?:分步|步骤)?(?:骤)?(?:把|将)?(?:它|该需求|这条需求)?(?:加入|接入|录入).{0,24}信号源(?:中)?$", + re.IGNORECASE, +) + +SOURCE_ONBOARDING_ACTION_RE = re.compile( + r"(新增|增加|添加|接入|配置|注册|建立|加个|加一个|加).{0,8}(信号源|来源|监控源|channel|source|webhook|飞书|github|url|rss)", + re.IGNORECASE, +) + +MODULE_KEYWORD_RULES: tuple[tuple[str, tuple[str, ...]], ...] = ( + ("用户管理与权限", ("用户管理", "角色权限", "crud", "批量导入", "成员管理")), + ("技能图谱", ("技能图谱", "技能标签", "能力图谱", "雷达图")), + ("工作量管理", ("工作量", "负载", "产能", "workload")), + ("SSTC 工作流", ("sstc", "charter", "signal", "task", "execution", "release", "review", "工作流")), + ("AI 能力编排", ("ai能力", "智能", "自动化", "推荐", "编排", "agent", "llm")), + ("信号源接入", ("信号源", "source", "onboard", "接入")), + ("飞书集成", ("飞书", "feishu", "群聊", "机器人")), + ("消息台与详情页", ("消息台", "详情页", "展开详情", "摘要", "时间戳", "按钮")), +) + +POLICY_GATE_RULES: tuple[tuple[str, tuple[str, ...]], ...] = ( + ("delete_or_archive", ("删除项目", "删除信号", "归档项目", "归档", "archive", "清空项目")), + ("budget_overrun", ("超预算", "突破预算", "额外预算", "加预算")), + ("cross_project_staffing", ("跨项目抢人", "抽调", "抢占关键人力", "挪人")), + ("charter_rewrite", ("改写charter", "success criteria", "成功标准改", "范围重大变更")), + ("critical_path_change", ("关键路径", "里程碑改动", "影响多个项目", "跨项目依赖调整")), +) + +PROJECT_SIGNAL_DISCOVER_HINTS = ( + "候选", + "先分析", + "先看候选", + "给我确认", + "待确认", + "再让我确认", + "确认后入库", + "先不要入库", + "先别入库", +) +FOLLOWUP_REFRESH_HINTS = ("换一批", "再来一批", "刷新候选", "重新找", "再找一组", "换一组") +FOLLOWUP_CANCEL_HINTS = ("取消", "先不做", "先别做", "不要了", "算了", "reject", "驳回") +FOLLOWUP_COMMIT_HINTS = ("确认", "继续处理", "继续执行", "同意", "批准", "approve") +FOLLOWUP_CONFIRM_HINTS = ("确认归属", "确认项目", "确认到项目", "确认关联", "确认这条") +FOLLOWUP_CONTINUE_HINTS = ("继续处理", "继续执行", "接着处理", "往下做", "继续推进") +FOLLOWUP_WORK_ITEM_ID_RE = re.compile(r"(?:work[_ -]?item|工作项|队列项|草稿)\s*(?:id|ID)?\s*[:#：]?\s*(\d+)", re.IGNORECASE) +FOLLOWUP_CONTINUE_RE = re.compile(r"(继续处理|继续推进|继续执行|接着处理|继续跑)", re.IGNORECASE) +FOLLOWUP_CREATE_CONTINUE_RE = re.compile(r"(继续创建|接着创建|继续建|接着建)", re.IGNORECASE) +FOLLOWUP_STATUS_RE = re.compile( + r"(进度|状态|处理到哪|处理了吗|现在怎么样|怎么样了|结果呢|是否已经创建|已经创建了吗|创建了吗|创建成功了吗|建好了吗|建成了吗)", + re.IGNORECASE, +) +FOLLOWUP_REFERENCE_RE = re.compile( + r"(刚才|刚刚|前面|之前|上次|上一条|我刚才要求|我刚才说|我说的|那个)", + re.IGNORECASE, +) + +QUESTION_HINTS = ( + "?", + "？", + "怎么", + "如何", + "为何", + "为什么", + "什么", + "是什么", + "哪些", + "有哪些", + "特点", + "技术特点", + "能力", + "介绍", + "说明", + "多少", + "是否", + "帮我看", + "状态", + "风险", + "能做什么", + "可以做什么", +) +OBVIOUS_QUESTION_RE = re.compile( + r"([?？]$|吗$|呢$|呀$|吧$|怎么|如何|为什么|多少|几号|几点|周几|有没有|是否|是不是|是什么|什么|哪些|有哪些|在哪|哪一个|哪几个|特点|能力|介绍|说明|风险)", + re.IGNORECASE, +) +QUERY_INTENT_RE = re.compile( + r"(哪些|有哪些|特点|技术特点|能力|介绍|说明|怎么|如何|是什么|什么|能做什么|可以做什么|项目有哪些风险)", + re.IGNORECASE, +) +SMALLTALK_EXACT = { + "收到", + "收到啦", + "好的", + "ok", + "okk", + "yes", + "no", + "谢谢", + "thanks", + "thx", + "在吗", + "在不在", + "怎么样了", + "咋样了", + "辛苦了", +} +SMALLTALK_SHORT_HINTS = ("怎么样了", "咋样了", "在吗", "辛苦了", "收到", "谢谢", "ok") +SMALLTALK_STRUCTURED_HINTS = ("项目", "信号", "任务", "风险", "进度", "状态", "work_item", "工作项", "#") + +SIGNAL_CREATE_HINTS = ("新增一个信号", "新增一条信号", "增加一个信号", "录入一个信号", "关注", "跟踪") +TASK_CREATE_HINTS = ( + "创建任务", + "新建任务", + "新增任务", + "增加任务", + "添加任务", + "加个任务", + "加一个任务", + "安排任务", + "分配任务", + "派个任务", +) +PROJECT_CREATE_HINTS = ( + "创建项目", + "新建项目", + "建立项目", + "做个项目", + "立项", + "开个项目", + "新增项目", + "新增个项目", + "新增一个项目", + "增加项目", + "增加个项目", + "增加一个项目", + "添加项目", + "添加一个项目", + "加个项目", + "加一个项目", +) +SHORT_CONFIRM_HINTS = ( + "是", + "好", + "对", + "确认", + "新增", + "加", + "嗯", + "yes", + "ok", + "好的", + "是的", + "行", + "可以", + "没问题", +) +HEALTHCHECK_RE = re.compile( + r"^(?:ping|pong|health(?:check)?|在线吗|活着吗|存活吗|还在吗|服务正常吗)\??$", + re.IGNORECASE, +) +SHORT_CONFIRM_RE = re.compile( + r"^(?:收到|好的|好|ok|okay|明白|了解|知道了|收到啦|嗯嗯|行|辛苦了|thanks?|thx)[!！.。]?$", + re.IGNORECASE, +) + +PROJECT_CREATE_REGEX = re.compile( + r"(?:新增|增加|添加|新建|创建|建立|开个|开一个|建个|建一个|做个|做一个|加个|加一个|立项)(?:一个|个)?(?:[^，。！？,.!?]{0,24})项目", + re.IGNORECASE, +) +TASK_CREATE_REGEX = re.compile( + r"(?:给|帮|请).{0,24}(?:新增|增加|添加|创建|新建|加).{0,16}(?:任务|工单|待办)", + re.IGNORECASE, +) +SIGNAL_CREATE_REGEX = re.compile( + r"(?:给|帮|请).{0,20}(?:新增|增加|添加|补充|加).{0,20}(?:信号|需求|事项)", + re.IGNORECASE, +) +PROJECT_LIST_QUERY_RE = re.compile( + r"(现在|当前|目前|系统里|系统中|项目里|项目中)?.{0,4}(有哪些项目|项目列表|项目清单|哪(些|几个)项目)", + re.IGNORECASE, +) +PROJECT_ID_QUERY_RE = re.compile( + r"项目\s*id\s*[:：]?\s*(\d+).{0,12}(有吗|存在吗|还在吗|是否存在|是不是)", + re.IGNORECASE, +) +LEGACY_COMMAND_PROJECT_CREATE_RE = re.compile( + r"(创建|新建|建立|开个|开一个|建个|建一个|做个|做一个).{0,6}项目", + re.IGNORECASE, +) +LEGACY_COMMAND_VERB_RE = re.compile( + r"(创建|新建|建立|开个|开一个|建个|建一个|做个|做一个|修改|更新|改成|改为|设为|设成|分配|指派|归档|重开|重新打开|恢复|标记完成|完成|提醒|通知|调整工时|调整工作量)", + re.IGNORECASE, +) +LEGACY_COMMAND_OBJECT_RE = re.compile( + r"(项目|任务|负责人|优先级|状态|通知|提醒|工时|工作量)", + re.IGNORECASE, +) +CREATE_ACTION_RE = re.compile(r"(新增|新建|创建|建立|接入|配置|录入|加入|放到|放进|立项)", re.IGNORECASE) +EXTERNAL_INTEGRATION_RE = re.compile( + r"(github|gitlab|jira|slack|webhook|飞书|企业微信|企微|lark|api|接入|授权|同步)", + re.IGNORECASE, +) + +__all__ = [name for name in globals() if not name.startswith("__")] diff --git a/backend/app/services/ai_pmo/workflow_semantic_planner/models.py b/backend/app/services/ai_pmo/workflow_semantic_planner/models.py new file mode 100644 index 00000000..e34e73a6 --- /dev/null +++ b/backend/app/services/ai_pmo/workflow_semantic_planner/models.py @@ -0,0 +1,74 @@ +from __future__ import annotations + +from dataclasses import asdict, dataclass, field +from typing import Any, Optional + + +@dataclass(slots=True) +class WorkflowSlot: + name: str + value: Any + source: str = "semantic_planner" + + +@dataclass(slots=True) +class WorkflowPlan: + workflow_type: str + workflow_action: str + target_scope: str + operation_codes: list[str] + requires_confirmation: bool + confidence: float + slots: list[WorkflowSlot] = field(default_factory=list) + clarification_needed: bool = False + metadata: dict[str, Any] = field(default_factory=dict) + + def to_dict(self) -> dict[str, Any]: + payload = asdict(self) + payload["slots"] = [asdict(slot) for slot in self.slots] + return payload + + +@dataclass(slots=True) +class ReplyContract: + mode: str + template_key: str = "workflow_bundle" + summary: str = "" + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +@dataclass(slots=True) +class WorkflowBundle: + bundle_id: str + semantic_version: str + source_system: str + primary_workflow: str + workflows: list[WorkflowPlan] + message_gate: str + reply_contract: ReplyContract + diagnostics: dict[str, Any] = field(default_factory=dict) + + def to_dict(self) -> dict[str, Any]: + return { + "bundle_id": self.bundle_id, + "semantic_version": self.semantic_version, + "source_system": self.source_system, + "primary_workflow": self.primary_workflow, + "workflows": [item.to_dict() for item in self.workflows], + "message_gate": self.message_gate, + "reply_contract": self.reply_contract.to_dict(), + "diagnostics": dict(self.diagnostics or {}), + } + + +def workflow_slot(name: str, value: Any, *, source: str = "semantic_planner") -> Optional[WorkflowSlot]: + if value is None: + return None + if isinstance(value, str) and not value.strip(): + return None + return WorkflowSlot(name=name, value=value, source=source) + + +__all__ = ["ReplyContract", "WorkflowBundle", "WorkflowPlan", "WorkflowSlot", "workflow_slot"] diff --git a/backend/app/services/ai_pmo/workflow_semantic_planner/service.py b/backend/app/services/ai_pmo/workflow_semantic_planner/service.py new file mode 100644 index 00000000..9185fb38 --- /dev/null +++ b/backend/app/services/ai_pmo/workflow_semantic_planner/service.py @@ -0,0 +1,747 @@ +from __future__ import annotations + +import hashlib +import re +from typing import Any, Iterable, Optional + +from .constants import ( + CONTEXTUAL_CONFIRM_HINTS, + CONTEXTUAL_DEICTIC_HINTS, + CONTEXTUAL_WRITE_ACTION_HINTS, + CREATE_ACTION_RE, + EXTERNAL_INTEGRATION_RE, + FOLLOWUP_CANCEL_HINTS, + FOLLOWUP_CREATE_CONTINUE_RE, + FOLLOWUP_COMMIT_HINTS, + FOLLOWUP_CONFIRM_HINTS, + FOLLOWUP_CONTINUE_HINTS, + FOLLOWUP_CONTINUE_RE, + FOLLOWUP_REFERENCE_RE, + FOLLOWUP_REFRESH_HINTS, + FOLLOWUP_STATUS_RE, + FOLLOWUP_WORK_ITEM_ID_RE, + GENERIC_SIGNAL_SOURCE_MESSAGE_RE, + HEALTHCHECK_RE, + INTENT_FOLLOWUP_CONFIRM, + INTENT_FOLLOWUP_CONTINUE, + INTENT_IGNORE, + INTENT_PROJECT_ARCHIVE, + INTENT_PROJECT_CREATE, + INTENT_PROJECT_DELETE, + INTENT_PROJECT_REOPEN, + INTENT_PROJECT_UPDATE, + INTENT_QUERY, + INTENT_SIGNAL_CREATE, + INTENT_SIGNAL_SOURCE_ONBOARD, + INTENT_TASK_ASSIGN, + INTENT_TASK_CREATE, + INTENT_TASK_DELETE, + INTENT_TASK_PRIORITIZE, + INTENT_TASK_STATUS_TRANSITION, + INTENT_TASK_UPDATE, + MESSAGE_GATE_AUTO, + MESSAGE_GATE_PENDING, + PROJECT_CREATE_HINTS, + PROJECT_CREATE_REGEX, + PROJECT_ID_QUERY_RE, + PROJECT_LIST_QUERY_RE, + PROJECT_SIGNAL_DISCOVER_HINTS, + QUESTION_HINTS, + REPLY_MODE_CARD, + REPLY_MODE_TEXT, + ROUTE_FOLLOWUP_CONFIRM, + ROUTE_FOLLOWUP_CONTINUE, + ROUTE_PROJECT_CREATE, + ROUTE_PROJECT_SIGNAL_CANCEL, + ROUTE_PROJECT_SIGNAL_COMMIT, + ROUTE_PROJECT_SIGNAL_CREATE, + ROUTE_PROJECT_SIGNAL_DISCOVER, + ROUTE_PROJECT_SIGNAL_REFRESH, + ROUTE_QUERY_ANSWER, + ROUTE_SIGNAL_SOURCE_ONBOARD, + ROUTE_TASK_CREATE, + SEMANTIC_VERSION, + SIGNAL_CREATE_HINTS, + SIGNAL_CREATE_REGEX, + SHORT_CONFIRM_RE, + SMALLTALK_EXACT, + SMALLTALK_SHORT_HINTS, + SMALLTALK_STRUCTURED_HINTS, + SOURCE_ONBOARDING_ACTION_RE, + TASK_CREATE_HINTS, + TASK_CREATE_REGEX, + LEGACY_COMMAND_OBJECT_RE, + LEGACY_COMMAND_PROJECT_CREATE_RE, + LEGACY_COMMAND_VERB_RE, + OBVIOUS_QUESTION_RE, + QUERY_INTENT_RE, + WORKFLOW_FOLLOWUP, + WORKFLOW_NEW_PROJECT, + WORKFLOW_PROJECT, + WORKFLOW_PROJECT_SIGNAL, + WORKFLOW_QUERY, + WORKFLOW_SIGNAL_SOURCE, + WORKFLOW_TASK, +) +from .models import ReplyContract, WorkflowBundle, WorkflowPlan, workflow_slot + + +class WorkflowSemanticPlanner: + _WRITE_VERBS = ( + "新增", + "增加", + "添加", + "加", + "新建", + "创建", + "建立", + "立项", + "接入", + "修复", + "优化", + "改成", + "改为", + "更新", + "分配", + "指派", + "归档", + "执行", + ) + _FOLLOWUP_ALLOWED_ACTIONS = ("continue", "confirm", "commit", "cancel", "refresh") + _FOLLOWUP_CONTEXT_KEYS = ("target_work_item_id", "followup_allowed_actions", "reply_to_message_id", "thread_anchor") + + @staticmethod + def _normalize_text(text: str) -> str: + return re.sub(r"\s+", "", str(text or "")).lower() + + @classmethod + def _has_question_structure(cls, text: str) -> bool: + normalized = cls._normalize_text(text) + if not normalized: + return False + return "?" in normalized or "？" in normalized or any(token in normalized for token in QUESTION_HINTS) + + @classmethod + def _is_smalltalk_message(cls, text: str) -> bool: + compact = re.sub(r"[\s\?？!！,，。~～、]+", "", str(text or "")).strip().lower() + if not compact: + return True + if any(keyword in compact for keyword in SMALLTALK_STRUCTURED_HINTS): + return False + if compact in SMALLTALK_EXACT: + return True + if len(compact) <= 8 and any(keyword in compact for keyword in SMALLTALK_SHORT_HINTS): + return True + return False + + @classmethod + def _looks_like_project_create(cls, text: str) -> bool: + normalized = cls._normalize_text(text) + return any(token in normalized for token in PROJECT_CREATE_HINTS) or bool(PROJECT_CREATE_REGEX.search(normalized)) + + @classmethod + def _looks_like_task_create(cls, text: str) -> bool: + normalized = cls._normalize_text(text) + return any(token in normalized for token in TASK_CREATE_HINTS) or bool(TASK_CREATE_REGEX.search(normalized)) + + @classmethod + def _looks_like_signal_create(cls, text: str) -> bool: + normalized = cls._normalize_text(text) + if any(token in normalized for token in PROJECT_SIGNAL_DISCOVER_HINTS): + return True + return any(token in normalized for token in SIGNAL_CREATE_HINTS) or bool(SIGNAL_CREATE_REGEX.search(normalized)) + + @classmethod + def looks_like_project_create_request(cls, text: str) -> bool: + return cls._looks_like_project_create(text) + + @classmethod + def looks_like_task_create_request(cls, text: str) -> bool: + return cls._looks_like_task_create(text) + + @classmethod + def looks_like_signal_create_request(cls, text: str) -> bool: + return cls._looks_like_signal_create(text) + + @classmethod + def looks_like_signal_source_request(cls, text: str) -> bool: + normalized = cls._normalize_text(text) + if len(normalized) < 3: + return False + if GENERIC_SIGNAL_SOURCE_MESSAGE_RE.search(normalized): + return True + return bool(SOURCE_ONBOARDING_ACTION_RE.search(normalized)) + + @staticmethod + def is_healthcheck_message(text: str) -> bool: + return bool(HEALTHCHECK_RE.search(str(text or "").strip())) + + @staticmethod + def is_short_confirmation_noise(text: str) -> bool: + return bool(SHORT_CONFIRM_RE.search(str(text or "").strip())) + + @classmethod + def wants_followup_continue(cls, text: str) -> bool: + raw = str(text or "").strip() + if not raw: + return False + if FOLLOWUP_CREATE_CONTINUE_RE.search(raw): + return bool(FOLLOWUP_REFERENCE_RE.search(raw)) + return bool(FOLLOWUP_CONTINUE_RE.search(raw)) + + @staticmethod + def wants_followup_status(text: str) -> bool: + return bool(FOLLOWUP_STATUS_RE.search(str(text or ""))) + + @classmethod + def looks_like_external_connect_request(cls, text: str) -> bool: + raw = str(text or "").strip() + if not raw: + return False + return bool(CREATE_ACTION_RE.search(raw) and EXTERNAL_INTEGRATION_RE.search(raw)) + + @classmethod + def is_legacy_business_command(cls, text: str) -> bool: + raw = str(text or "").strip() + if not raw: + return False + if cls.is_query_like_question(raw): + return False + if LEGACY_COMMAND_PROJECT_CREATE_RE.search(raw): + return True + return bool(LEGACY_COMMAND_VERB_RE.search(raw) and LEGACY_COMMAND_OBJECT_RE.search(raw)) + + @classmethod + def looks_like_project_lookup_question(cls, text: str) -> bool: + raw = str(text or "").strip() + if not raw: + return False + if cls.is_legacy_business_command(raw): + return False + normalized = cls._normalize_text(raw) + if PROJECT_LIST_QUERY_RE.search(raw): + return True + if PROJECT_ID_QUERY_RE.search(raw): + return True + if "项目" not in normalized: + return False + return any(token in normalized for token in ("有吗", "有没有", "有无", "是否有", "是否存在", "存在吗", "是什么", "哪些")) + + @staticmethod + def extract_project_lookup_keyword(text: str) -> str: + raw = str(text or "").strip() + if not raw: + return "" + cleaned = re.sub( + r"(请问|麻烦问下|问下|现在|当前|目前|系统里|系统中|项目里|项目中|有没有|有无|有吗|是否有|是否存在|存在吗|这个|那个|一个|个|项目|列表|清单|有|吗|呢|呀|啊|么)", + " ", + raw, + flags=re.IGNORECASE, + ) + cleaned = re.sub(r"[，。,.;；:：!?？（）()\\[\\]【】]+", " ", cleaned) + cleaned = re.sub(r"\s+", " ", cleaned).strip(" ?？") + return cleaned[:40] + + @classmethod + def is_query_like_question(cls, text: str) -> bool: + raw = str(text or "").strip() + if not raw: + return False + normalized = cls._normalize_text(raw) + has_question_structure = bool(OBVIOUS_QUESTION_RE.search(raw) or QUERY_INTENT_RE.search(raw)) + if not has_question_structure: + return False + has_operation_verb = bool(LEGACY_COMMAND_VERB_RE.search(raw)) + imperative_tokens = ("帮我", "请", "麻烦", "直接", "立刻", "马上", "执行", "处理", "安排") + has_imperative = any(token in normalized for token in imperative_tokens) + return not has_operation_verb and not has_imperative + + @classmethod + def is_obvious_question(cls, text: str) -> bool: + raw = str(text or "").strip() + if not raw: + return False + if cls.is_query_like_question(raw): + return True + if cls.is_legacy_business_command(raw): + return False + if cls.looks_like_project_lookup_question(raw): + return True + return bool(OBVIOUS_QUESTION_RE.search(raw)) + + @classmethod + def looks_like_contextual_write_confirmation(cls, text: str) -> bool: + normalized = cls._normalize_text(text) + if not normalized: + return False + if cls._has_question_structure(text): + return False + has_write_action = any(token in normalized for token in CONTEXTUAL_WRITE_ACTION_HINTS) + if not has_write_action: + return False + has_confirm = any(token in normalized for token in CONTEXTUAL_CONFIRM_HINTS) + has_deictic = any(token in normalized for token in CONTEXTUAL_DEICTIC_HINTS) + return has_confirm or has_deictic + + @classmethod + def _looks_like_followup(cls, text: str, *, metadata: Optional[dict[str, Any]] = None) -> bool: + payload = metadata if isinstance(metadata, dict) else {} + if any(str(payload.get(key) or "").strip() for key in cls._FOLLOWUP_CONTEXT_KEYS): + return True + if FOLLOWUP_WORK_ITEM_ID_RE.search(str(text or "")): + return True + normalized = cls._normalize_text(text) + followup_tokens = (*FOLLOWUP_CONFIRM_HINTS, *FOLLOWUP_CONTINUE_HINTS, *FOLLOWUP_CANCEL_HINTS, *FOLLOWUP_REFRESH_HINTS) + return any(token in normalized for token in followup_tokens) or cls.wants_followup_continue(text) or cls.wants_followup_status(text) + + @classmethod + def parse_followup_action( + cls, + *, + metadata: Optional[dict[str, Any]] = None, + canonical_intent: str, + message_text: str = "", + ) -> str: + payload = metadata if isinstance(metadata, dict) else {} + explicit_action = str(payload.get("followup_action") or payload.get("action") or "").strip().lower() + if explicit_action in cls._FOLLOWUP_ALLOWED_ACTIONS: + return explicit_action + followup_context_present = bool( + payload.get("followup_context_present") + or payload.get("target_work_item_id") + or payload.get("followup_allowed_actions") + or payload.get("reply_to_message_id") + or payload.get("thread_anchor") + ) + if followup_context_present: + normalized = cls._normalize_text(message_text) + if any(token in normalized for token in FOLLOWUP_REFRESH_HINTS): + return "refresh" + if any(token in normalized for token in FOLLOWUP_CANCEL_HINTS): + return "cancel" + if any(token in normalized for token in FOLLOWUP_COMMIT_HINTS): + return "commit" + if canonical_intent == INTENT_FOLLOWUP_CONFIRM: + return "confirm" + return "continue" + + @classmethod + def parse_draft_action(cls, *, message_text: str) -> tuple[str, str]: + text = str(message_text or "").strip() + lowered = text.lower() + if any(hint in text for hint in ("修改", "改成", "改为", "改", "换成")): + note = re.sub(r"^(?:修改|改成|改为|改|换成)\s*", "", text).strip() + return "revise", note + if any(hint in text for hint in FOLLOWUP_CANCEL_HINTS): + return "cancel", "" + if any(hint in text for hint in ("确认", "好的", "就这样", "行", "ok", "okay", "同意", "没问题")) or lowered in {"y", "yes"}: + return "confirm", "" + return "unknown", "" + + @classmethod + def _bundle_id( + cls, + *, + source_system: str, + message_text: str, + workflows: Iterable[WorkflowPlan], + ) -> str: + basis = "|".join( + [ + str(source_system or "").strip().lower(), + str(message_text or "").strip(), + ",".join(f"{item.workflow_type}:{item.workflow_action}" for item in workflows), + ] + ) + digest = hashlib.sha1(basis.encode("utf-8"), usedforsecurity=False).hexdigest() + return f"semantic-{digest[:16]}" + + @classmethod + def _reply_contract(cls, *, source_system: str, primary_workflow: str) -> ReplyContract: + mode = REPLY_MODE_CARD if str(source_system or "").strip().lower() == "feishu" else REPLY_MODE_TEXT + return ReplyContract(mode=mode, template_key="workflow_bundle", summary=primary_workflow) + + @classmethod + def _gate_for_workflows(cls, workflows: list[WorkflowPlan]) -> str: + if any(item.requires_confirmation or item.clarification_needed for item in workflows): + return MESSAGE_GATE_PENDING + return MESSAGE_GATE_AUTO + + @classmethod + def _plan_from_intent( + cls, + *, + intent_name: str, + message_text: str, + source_system: str, + workflow_route: str = "", + project_id: Optional[int] = None, + metadata: Optional[dict[str, Any]] = None, + ) -> WorkflowBundle: + payload = dict(metadata or {}) + normalized_route = str(workflow_route or payload.get("workflow_route") or "").strip().lower() + workflows: list[WorkflowPlan] = [] + slots = [slot for slot in [workflow_slot("project_id", project_id)] if slot is not None] + if intent_name == INTENT_QUERY: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_QUERY, + workflow_action="answer", + target_scope="project" if project_id is not None else "global", + operation_codes=[ROUTE_QUERY_ANSWER], + requires_confirmation=False, + confidence=0.88, + slots=slots, + ) + ) + elif intent_name == INTENT_PROJECT_CREATE: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_NEW_PROJECT, + workflow_action="create", + target_scope="global", + operation_codes=["project.create"], + requires_confirmation=bool(payload.get("requires_confirmation")), + confidence=float(payload.get("confidence") or 0.9), + slots=slots, + ) + ) + elif intent_name in {INTENT_PROJECT_UPDATE, INTENT_PROJECT_ARCHIVE, INTENT_PROJECT_REOPEN, INTENT_PROJECT_DELETE}: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_PROJECT, + workflow_action=str(intent_name.split(".", 1)[1] if "." in intent_name else "update"), + target_scope="project", + operation_codes=[intent_name], + requires_confirmation=bool(payload.get("requires_confirmation")), + confidence=float(payload.get("confidence") or 0.82), + slots=slots, + ) + ) + elif intent_name in {INTENT_TASK_CREATE, INTENT_TASK_UPDATE, INTENT_TASK_ASSIGN, INTENT_TASK_PRIORITIZE, INTENT_TASK_STATUS_TRANSITION, INTENT_TASK_DELETE}: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_TASK, + workflow_action=str(intent_name.split(".", 1)[1] if "." in intent_name else "create"), + target_scope="project" if project_id is not None else "global", + operation_codes=[intent_name if intent_name != INTENT_TASK_CREATE else ROUTE_TASK_CREATE], + requires_confirmation=bool(payload.get("requires_confirmation")), + confidence=float(payload.get("confidence") or 0.82), + slots=slots, + ) + ) + elif intent_name == INTENT_SIGNAL_SOURCE_ONBOARD: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_SIGNAL_SOURCE, + workflow_action="onboard", + target_scope="project" if project_id is not None else "global", + operation_codes=[ROUTE_SIGNAL_SOURCE_ONBOARD], + requires_confirmation=bool(payload.get("requires_confirmation")), + confidence=float(payload.get("confidence") or 0.92), + slots=slots, + ) + ) + elif intent_name == INTENT_SIGNAL_CREATE: + route_to_action = { + ROUTE_PROJECT_SIGNAL_DISCOVER: "discover", + ROUTE_PROJECT_SIGNAL_COMMIT: "commit", + ROUTE_PROJECT_SIGNAL_CANCEL: "cancel", + ROUTE_PROJECT_SIGNAL_REFRESH: "refresh", + } + workflow_action = route_to_action.get(normalized_route, "create") + operation_codes = [normalized_route or ROUTE_PROJECT_SIGNAL_CREATE] + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_PROJECT_SIGNAL, + workflow_action=workflow_action, + target_scope="project" if project_id is not None else "global", + operation_codes=operation_codes, + requires_confirmation=workflow_action in {"discover", "commit", "cancel", "refresh"} or bool(payload.get("requires_confirmation")), + confidence=float(payload.get("confidence") or 0.8), + slots=slots, + ) + ) + elif intent_name in {INTENT_FOLLOWUP_CONFIRM, INTENT_FOLLOWUP_CONTINUE}: + followup_action = cls.parse_followup_action( + metadata={**payload, "followup_context_present": True}, + canonical_intent=intent_name, + message_text=message_text, + ) + work_item_id = payload.get("target_work_item_id") + followup_slots = [slot for slot in [*slots, workflow_slot("target_work_item_id", work_item_id)] if slot is not None] + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_FOLLOWUP, + workflow_action=followup_action, + target_scope="thread", + operation_codes=[ROUTE_FOLLOWUP_CONFIRM if followup_action == "confirm" else ROUTE_FOLLOWUP_CONTINUE], + requires_confirmation=False, + confidence=float(payload.get("confidence") or 0.82), + slots=followup_slots, + ) + ) + else: + return cls.plan_message(message_text=message_text, source_system=source_system, metadata=payload) + primary_workflow = workflows[0].workflow_type + return WorkflowBundle( + bundle_id=cls._bundle_id(source_system=source_system, message_text=message_text, workflows=workflows), + semantic_version=SEMANTIC_VERSION, + source_system=str(source_system or "").strip().lower() or "unknown", + primary_workflow=primary_workflow, + workflows=workflows, + message_gate=cls._gate_for_workflows(workflows), + reply_contract=cls._reply_contract(source_system=source_system, primary_workflow=primary_workflow), + diagnostics={"intent_name": intent_name, "workflow_route": normalized_route or None}, + ) + + @classmethod + def plan_message( + cls, + *, + message_text: str, + source_system: str, + metadata: Optional[dict[str, Any]] = None, + ) -> WorkflowBundle: + text = str(message_text or "").strip() + payload = dict(metadata or {}) + normalized = cls._normalize_text(text) + workflows: list[WorkflowPlan] = [] + if not text or cls._is_smalltalk_message(text): + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_QUERY, + workflow_action="answer", + target_scope="global", + operation_codes=[ROUTE_QUERY_ANSWER], + requires_confirmation=False, + confidence=0.55, + clarification_needed=False, + ) + ) + elif cls._looks_like_followup(text, metadata=payload): + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_FOLLOWUP, + workflow_action=cls.parse_followup_action( + metadata={**payload, "followup_context_present": True}, + canonical_intent=str(payload.get("intent_name") or INTENT_FOLLOWUP_CONTINUE), + message_text=text, + ), + target_scope="thread", + operation_codes=[ROUTE_FOLLOWUP_CONTINUE], + requires_confirmation=False, + confidence=0.84, + slots=[ + slot + for slot in [ + workflow_slot( + "target_work_item_id", + int(FOLLOWUP_WORK_ITEM_ID_RE.search(text).group(1)) + if FOLLOWUP_WORK_ITEM_ID_RE.search(text) + else payload.get("target_work_item_id"), + ) + ] + if slot is not None + ], + ) + ) + else: + project_like = cls._looks_like_project_create(text) + signal_source_like = cls.looks_like_signal_source_request(text) + task_like = cls._looks_like_task_create(text) + signal_like = cls._looks_like_signal_create(text) + question_like = cls._has_question_structure(text) + if project_like: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_NEW_PROJECT, + workflow_action="create", + target_scope="global", + operation_codes=["project.create"], + requires_confirmation=False, + confidence=0.9, + ) + ) + if signal_source_like: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_SIGNAL_SOURCE, + workflow_action="onboard", + target_scope="project" if project_like else "global", + operation_codes=[ROUTE_SIGNAL_SOURCE_ONBOARD], + requires_confirmation=False, + confidence=0.92, + ) + ) + if task_like and not project_like: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_TASK, + workflow_action="create", + target_scope="project", + operation_codes=[ROUTE_TASK_CREATE], + requires_confirmation=False, + confidence=0.82, + ) + ) + if signal_like and not signal_source_like: + workflow_action = "discover" if any(token in normalized for token in PROJECT_SIGNAL_DISCOVER_HINTS) else "create" + route_code = ROUTE_PROJECT_SIGNAL_DISCOVER if workflow_action == "discover" else ROUTE_PROJECT_SIGNAL_CREATE + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_PROJECT_SIGNAL, + workflow_action=workflow_action, + target_scope="project", + operation_codes=[route_code], + requires_confirmation=workflow_action == "discover", + confidence=0.78, + ) + ) + if not workflows: + workflows.append( + WorkflowPlan( + workflow_type=WORKFLOW_QUERY if question_like or not any(token in normalized for token in cls._WRITE_VERBS) else WORKFLOW_QUERY, + workflow_action="answer", + target_scope="global", + operation_codes=[ROUTE_QUERY_ANSWER], + requires_confirmation=False, + confidence=0.88 if question_like else 0.6, + ) + ) + primary_workflow = workflows[0].workflow_type + return WorkflowBundle( + bundle_id=cls._bundle_id(source_system=source_system, message_text=text, workflows=workflows), + semantic_version=SEMANTIC_VERSION, + source_system=str(source_system or "").strip().lower() or "unknown", + primary_workflow=primary_workflow, + workflows=workflows, + message_gate=cls._gate_for_workflows(workflows), + reply_contract=cls._reply_contract(source_system=source_system, primary_workflow=primary_workflow), + diagnostics={}, + ) + + @classmethod + def plan_from_intent( + cls, + *, + intent_name: str, + message_text: str, + source_system: str, + workflow_route: str = "", + project_id: Optional[int] = None, + metadata: Optional[dict[str, Any]] = None, + ) -> WorkflowBundle: + return cls._plan_from_intent( + intent_name=intent_name, + message_text=message_text, + source_system=source_system, + workflow_route=workflow_route, + project_id=project_id, + metadata=metadata, + ) + + @classmethod + def deserialize_bundle(cls, value: Any) -> Optional[WorkflowBundle]: + if not isinstance(value, dict): + return None + workflows_raw = value.get("workflows") + reply_contract_raw = value.get("reply_contract") + if not isinstance(workflows_raw, list) or not isinstance(reply_contract_raw, dict): + return None + workflows: list[WorkflowPlan] = [] + for item in workflows_raw: + if not isinstance(item, dict): + continue + slots_raw = item.get("slots") + workflows.append( + WorkflowPlan( + workflow_type=str(item.get("workflow_type") or "").strip(), + workflow_action=str(item.get("workflow_action") or "").strip(), + target_scope=str(item.get("target_scope") or "").strip(), + operation_codes=[str(code) for code in item.get("operation_codes") or [] if str(code).strip()], + requires_confirmation=bool(item.get("requires_confirmation")), + confidence=float(item.get("confidence") or 0.0), + slots=[ + workflow_slot(str(slot.get("name") or "").strip(), slot.get("value"), source=str(slot.get("source") or "semantic_planner")) + for slot in (slots_raw if isinstance(slots_raw, list) else []) + if isinstance(slot, dict) and workflow_slot(str(slot.get("name") or "").strip(), slot.get("value"), source=str(slot.get("source") or "semantic_planner")) is not None + ], + clarification_needed=bool(item.get("clarification_needed")), + metadata=dict(item.get("metadata") or {}), + ) + ) + return WorkflowBundle( + bundle_id=str(value.get("bundle_id") or "").strip(), + semantic_version=str(value.get("semantic_version") or SEMANTIC_VERSION).strip(), + source_system=str(value.get("source_system") or "").strip(), + primary_workflow=str(value.get("primary_workflow") or "").strip(), + workflows=workflows, + message_gate=str(value.get("message_gate") or MESSAGE_GATE_AUTO).strip(), + reply_contract=ReplyContract( + mode=str(reply_contract_raw.get("mode") or REPLY_MODE_TEXT).strip(), + template_key=str(reply_contract_raw.get("template_key") or "workflow_bundle").strip(), + summary=str(reply_contract_raw.get("summary") or "").strip(), + ), + diagnostics=dict(value.get("diagnostics") or {}), + ) + + @classmethod + def classify_scene(cls, *, capture_result: dict[str, Any]) -> str: + bundle = cls.deserialize_bundle(capture_result.get("semantic_bundle")) + if bundle is not None and bundle.workflows: + if any(item.workflow_type != WORKFLOW_QUERY for item in bundle.workflows): + return "execute" + return "qa" + status = str(capture_result.get("status") or "").strip().lower() + classification = str(capture_result.get("classification") or "").strip().lower() + intent = str(capture_result.get("intent") or "").strip().lower() + workflow_route = str(capture_result.get("workflow_route") or "").strip().lower() + execute_intents = { + INTENT_PROJECT_CREATE, + INTENT_PROJECT_UPDATE, + INTENT_PROJECT_ARCHIVE, + INTENT_PROJECT_REOPEN, + INTENT_PROJECT_DELETE, + INTENT_TASK_CREATE, + INTENT_TASK_UPDATE, + INTENT_TASK_ASSIGN, + INTENT_TASK_PRIORITIZE, + INTENT_TASK_STATUS_TRANSITION, + INTENT_TASK_DELETE, + INTENT_SIGNAL_CREATE, + INTENT_SIGNAL_SOURCE_ONBOARD, + INTENT_FOLLOWUP_CONFIRM, + INTENT_FOLLOWUP_CONTINUE, + } + execute_routes = { + ROUTE_PROJECT_CREATE, + ROUTE_TASK_CREATE, + ROUTE_SIGNAL_SOURCE_ONBOARD, + ROUTE_PROJECT_SIGNAL_CREATE, + ROUTE_PROJECT_SIGNAL_DISCOVER, + ROUTE_PROJECT_SIGNAL_COMMIT, + ROUTE_PROJECT_SIGNAL_CANCEL, + ROUTE_PROJECT_SIGNAL_REFRESH, + ROUTE_FOLLOWUP_CONFIRM, + ROUTE_FOLLOWUP_CONTINUE, + } + if intent in execute_intents or workflow_route in execute_routes or classification in {"project", "signal", "command", "new_project", "project_signal"}: + return "execute" + if status == "error" or classification == "error": + return "error" + if status == "answered" or classification in {"question", "qa"}: + return "qa" + if status in {"captured", "ignored"}: + return "execute" + return "qa" + + @classmethod + def is_action_request_capture(cls, *, capture_result: dict[str, Any]) -> bool: + bundle = cls.deserialize_bundle(capture_result.get("semantic_bundle")) + if bundle is not None and bundle.workflows: + return any(item.workflow_type != WORKFLOW_QUERY for item in bundle.workflows) + return False + + +__all__ = ["WorkflowSemanticPlanner"] diff --git a/backend/app/services/integrations/feishu_integration_service/mixin_receive_capture_flow.py b/backend/app/services/integrations/feishu_integration_service/mixin_receive_capture_flow.py index cd07850f..0165e593 100644 --- a/backend/app/services/integrations/feishu_integration_service/mixin_receive_capture_flow.py +++ b/backend/app/services/integrations/feishu_integration_service/mixin_receive_capture_flow.py @@ -158,5 +158,8 @@ class FeishuReceiveCaptureFlowMixin: "ai_trace_id": result.get("ai_trace_id"), "state_trace_id": state_trace_id, "scene": scene, + "semantic_bundle_id": result.get("semantic_bundle_id"), + "semantic_version": result.get("semantic_version"), + "semantic_source": result.get("semantic_source"), }, } diff --git a/backend/app/services/integrations/feishu_integration_service/mixin_receive_routing.py b/backend/app/services/integrations/feishu_integration_service/mixin_receive_routing.py index 6787d5aa..07c578f9 100644 --- a/backend/app/services/integrations/feishu_integration_service/mixin_receive_routing.py +++ b/backend/app/services/integrations/feishu_integration_service/mixin_receive_routing.py @@ -1,7 +1,7 @@ from __future__ import annotations from .shared import * -from ...ai_pmo.ai_pmo_intent import IntentResolver +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class FeishuReceiveRoutingMixin: async def _route_scene_reply( @@ -151,48 +151,8 @@ class FeishuReceiveRoutingMixin: def _classify_message_scene(*, capture_result: Dict[str, Any], message_content: str = "") -> str: if not isinstance(capture_result, dict): return "error" - intent = str(capture_result.get("intent") or "").strip().lower() - status = str(capture_result.get("status") or "").strip().lower() - classification = str(capture_result.get("classification") or "").strip().lower() - execute_intents = { - "project.create", - "project.update", - "project.archive", - "project.reopen", - "project.delete", - "task.create", - "task.update", - "task.assign", - "task.prioritize", - "task.status_transition", - "task.delete", - "personnel.role_update", - "personnel.workload_update", - "personnel.availability_update", - "knowledge.doc_upsert", - "knowledge.chunk_upsert", - "knowledge.link_upsert", - "knowledge.reindex", - "notification.create", - "notification.ack", - "notification.close", - "signal.create", - "signal_source.onboard", - "followup.confirm", - "followup.continue", - } - raw_intent = str(IntentResolver.resolve(text=message_content, project_id=None).name or "").strip().lower() - if raw_intent in execute_intents or raw_intent in {"project", "signal", "command", "new_project", "project_signal"}: - return "execute" - if intent in execute_intents or classification in {"project", "signal", "command", "new_project", "project_signal"}: - return "execute" - if status in {"captured", "ignored"}: - return "execute" - if status == "answered" or classification in {"question", "qa"}: - return "qa" - if status == "error" or classification == "error": - return "error" - return "qa" + _ = message_content + return WorkflowSemanticPlanner.classify_scene(capture_result=capture_result) @staticmethod def _build_error_reply_text() -> str: diff --git a/backend/app/services/integrations/feishu_integration_service/mixin_reply_llm_core.py b/backend/app/services/integrations/feishu_integration_service/mixin_reply_llm_core.py index e85d1111..34580836 100644 --- a/backend/app/services/integrations/feishu_integration_service/mixin_reply_llm_core.py +++ b/backend/app/services/integrations/feishu_integration_service/mixin_reply_llm_core.py @@ -1,6 +1,7 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class FeishuReplyLLMCoreMixin: async def _reply_with_active_role_prompt( @@ -221,22 +222,13 @@ class FeishuReplyLLMCoreMixin: "你直接说目标、对象和期望动作即可。" ) - @staticmethod - def _is_action_request_message(message_content: Optional[str]) -> bool: - normalized = re.sub(r"\s+", "", str(message_content or "").lower()) - if not normalized: - return False - action_tokens = ( - "创建项目", - "新建项目", - "立项", - "创建信号", - "创建信号源", - "新增信号源", - "接入信号源", - "信号源接入", - ) - return any(token in normalized for token in action_tokens) + @classmethod + def _is_action_request_message( + cls, + *, + capture_result: Dict[str, Any], + ) -> bool: + return WorkflowSemanticPlanner.is_action_request_capture(capture_result=capture_result) @classmethod def _build_action_request_ack_reply( @@ -245,11 +237,13 @@ class FeishuReplyLLMCoreMixin: message_content: Optional[str], capture_result: Dict[str, Any], ) -> Optional[str]: - if not cls._is_action_request_message(message_content): + _ = message_content + if not cls._is_action_request_message(capture_result=capture_result): return None - normalized = re.sub(r"\s+", "", str(message_content or "").lower()) - project_like = any(token in normalized for token in ("创建项目", "新建项目", "立项")) - signal_like = any(token in normalized for token in ("创建信号", "创建信号源", "新增信号源", "接入信号源", "信号源接入")) + bundle = WorkflowSemanticPlanner.deserialize_bundle(capture_result.get("semantic_bundle")) + workflow_types = [item.workflow_type for item in (bundle.workflows if bundle is not None else [])] + project_like = "new_project_flow" in workflow_types or "project_flow" in workflow_types + signal_like = "signal_source_flow" in workflow_types or "project_signal_flow" in workflow_types if project_like and signal_like: return "已收到，项目创建和信号源接入请求已记录。" if project_like: diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_context_prefill_a.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_context_prefill_a.py index dc8e20e0..16ec94cb 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_context_prefill_a.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_context_prefill_a.py @@ -33,7 +33,7 @@ class FeishuPipelineContextPrefillAMixin: ) @staticmethod - def _looks_like_project_request_artifact(text: str) -> bool: + def _looks_like_project_request_artifact(text: str) -> bool: # semantic-lint: ignore - project context artifact detector, not workflow routing normalized = re.sub(r"\s+", "", str(text or "")).lower() if not normalized: return False diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_core_base.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_core_base.py index 58c977aa..88a40231 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_core_base.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_core_base.py @@ -2,6 +2,7 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class FeishuPipelineCoreBaseMixin: @@ -33,11 +34,11 @@ class FeishuPipelineCoreBaseMixin: @staticmethod def _is_healthcheck_message(message: str) -> bool: - return bool(HEALTHCHECK_RE.search(str(message or "").strip())) + return WorkflowSemanticPlanner.is_healthcheck_message(message) @staticmethod def _is_short_confirmation_message(message: str) -> bool: - return bool(SHORT_CONFIRM_RE.search(str(message or "").strip())) + return WorkflowSemanticPlanner.is_short_confirmation_noise(message) @staticmethod def _is_correction_message(message: str) -> bool: @@ -45,32 +46,19 @@ class FeishuPipelineCoreBaseMixin: @staticmethod def _looks_like_continue_followup(message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - if FOLLOWUP_CREATE_CONTINUE_RE.search(text): - return bool(FOLLOWUP_REFERENCE_RE.search(text)) - return bool(FOLLOWUP_CONTINUE_RE.search(text)) + return WorkflowSemanticPlanner.wants_followup_continue(message) @staticmethod - def _looks_like_task_create_request(message: str) -> bool: - return bool(TASK_CREATE_RE.search(str(message or "").strip())) + def _looks_like_task_create_request(message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_task_create_request(message) @staticmethod - def _looks_like_project_create_request(message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - if PROJECT_CREATE_GATE_RE.search(text): - return True - return bool(LEGACY_COMMAND_PROJECT_CREATE_RE.search(text)) + def _looks_like_project_create_request(message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_project_create_request(message) @staticmethod - def _looks_like_external_connect_request(message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - return bool(CREATE_ACTION_RE.search(text) and EXTERNAL_INTEGRATION_RE.search(text)) + def _looks_like_external_connect_request(message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_external_connect_request(message) @staticmethod def _can_execute_high_value_action(user: Optional[User]) -> bool: @@ -169,4 +157,3 @@ class FeishuPipelineCoreBaseMixin: if signal.matched_project_id is not None: result["project_id"] = int(signal.matched_project_id) return result - diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_followup_a.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_followup_a.py index 65cb07f0..fc8f427d 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_followup_a.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_followup_a.py @@ -2,6 +2,7 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner from app.utils.thread_context import extract_thread_anchor @@ -20,7 +21,7 @@ class FeishuPipelineFollowupAMixin: if not source_chat_id: return None wants_continue = self._looks_like_continue_followup(message) - wants_status = bool(FOLLOWUP_STATUS_RE.search(message)) + wants_status = WorkflowSemanticPlanner.wants_followup_status(message) if not wants_continue and not wants_status: return None diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_gate_dispatch.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_gate_dispatch.py index 22fa3a50..ed78ffe0 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_gate_dispatch.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_gate_dispatch.py @@ -176,7 +176,10 @@ class FeishuPipelineGateDispatchMixin: asked_via="feishu", project_id=None, source_chat_id=source_chat_id, + source_message_id=feishu_message_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, ) qa_capture = await self._build_direct_qa_capture( message=message, diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_intent_gate_core.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_intent_gate_core.py index f61fb9cd..46ea2629 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_intent_gate_core.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_intent_gate_core.py @@ -257,7 +257,7 @@ class FeishuPipelineIntentGateCoreMixin: } @staticmethod - def _looks_like_contextual_project_request(message: str) -> bool: + def _looks_like_contextual_project_request(message: str) -> bool: # semantic-lint: ignore - context prefill helper for missing fields only normalized = re.sub(r"\s+", "", str(message or "")).lower() if not normalized: return False diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_lookup_and_block.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_lookup_and_block.py index 6c3a06e4..879649fc 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_lookup_and_block.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_lookup_and_block.py @@ -2,39 +2,21 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class FeishuPipelineLookupAndBlockMixin: @staticmethod - def _looks_like_project_create_command(message: str) -> bool: - return bool(LEGACY_COMMAND_PROJECT_CREATE_RE.search(str(message or ""))) + def _looks_like_project_create_command(message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_project_create_request(message) @classmethod - def _looks_like_project_lookup_question(cls, message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - if cls._is_legacy_business_command(text): - return False - normalized = re.sub(r"\s+", "", text.lower()) - if PROJECT_LIST_QUERY_RE.search(text): - return True - if PROJECT_ID_QUERY_RE.search(text): - return True - if "项目" not in normalized: - return False - return any(token in normalized for token in ("有吗", "有没有", "有无", "是否有", "是否存在", "存在吗", "是什么", "哪些")) + def _looks_like_project_lookup_question(cls, message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_project_lookup_question(message) @classmethod def _is_legacy_business_command(cls, message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - if cls._is_query_like_question(message): - return False - if cls._looks_like_project_create_command(text): - return True - return bool(LEGACY_COMMAND_VERB_RE.search(text) and LEGACY_COMMAND_OBJECT_RE.search(text)) + return WorkflowSemanticPlanner.is_legacy_business_command(message) async def _maybe_block_legacy_command_request( self, @@ -89,7 +71,7 @@ class FeishuPipelineLookupAndBlockMixin: reply_text = self._format_project_lookup_hit_rows(projects[:8], prefix="当前项目") linked_project_ids = [int(item["id"]) for item in projects[:8] if _safe_int(item.get("id"))] else: - keyword = self._extract_project_lookup_keyword(message) + keyword = WorkflowSemanticPlanner.extract_project_lookup_keyword(message) matched_rows = self._match_projects_by_keyword(projects=projects, keyword=keyword) if matched_rows: linked_project_ids = [int(item["id"]) for item in matched_rows if _safe_int(item.get("id"))] @@ -177,21 +159,6 @@ class FeishuPipelineLookupAndBlockMixin: "command_result": None, } - @staticmethod - def _extract_project_lookup_keyword(message: str) -> str: - text = str(message or "").strip() - if not text: - return "" - cleaned = re.sub( - r"(请问|麻烦问下|问下|现在|当前|目前|系统里|系统中|项目里|项目中|有没有|有无|有吗|是否有|是否存在|存在吗|这个|那个|一个|个|项目|列表|清单|有|吗|呢|呀|啊|么)", - " ", - text, - flags=re.IGNORECASE, - ) - cleaned = re.sub(r"[，。,.;；:：!?？（）()\\[\\]【】]+", " ", cleaned) - cleaned = re.sub(r"\s+", " ", cleaned).strip() - return cleaned[:40] - @staticmethod def _match_projects_by_keyword(*, projects: list[dict[str, Any]], keyword: str) -> list[dict[str, Any]]: normalized_keyword = re.sub(r"\s+", "", str(keyword or "")).lower() @@ -235,4 +202,3 @@ class FeishuPipelineLookupAndBlockMixin: if "长连接" in normalized and any(token in normalized for token in ("已通", "都已通", "正常", "在线", "已恢复")): return True return False - diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_message_utils_a.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_message_utils_a.py index 667c200b..9dd66471 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_message_utils_a.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_message_utils_a.py @@ -2,7 +2,7 @@ from __future__ import annotations from .shared import * -from app.utils.thread_context import build_feishu_thread_key +from app.utils.thread_context import build_feishu_conversation_scope_key class FeishuPipelineMessageUtilsAMixin: @@ -79,12 +79,10 @@ class FeishuPipelineMessageUtilsAMixin: source_message_id: Optional[str] = None, thread_context: Optional[dict[str, Any]] = None, ) -> str: - return build_feishu_thread_key( + return build_feishu_conversation_scope_key( source_chat_id=source_chat_id, source_sender_open_id=source_sender_open_id, sender=sender, - source_message_id=source_message_id, - thread_context=thread_context, ) @staticmethod diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_default.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_default.py index ce933a49..1a5b69ac 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_default.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_default.py @@ -59,7 +59,10 @@ class FeishuPipelineProcessMessageDefaultMixin: asked_via="feishu", project_id=None, source_chat_id=source_chat_id, + source_message_id=feishu_message_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, message_intent="mixed", mixed_signal_part=mixed_signal_part, ) @@ -74,7 +77,10 @@ class FeishuPipelineProcessMessageDefaultMixin: asked_via="feishu", project_id=None, source_chat_id=source_chat_id, + source_message_id=feishu_message_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, ) return await self._finalize_direct_qa_capture_result( message=message, @@ -108,7 +114,10 @@ class FeishuPipelineProcessMessageDefaultMixin: asked_via="feishu", project_id=None, source_chat_id=source_chat_id, + source_message_id=feishu_message_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, message_intent="mixed", mixed_signal_part=mixed_signal_part, ) @@ -123,7 +132,10 @@ class FeishuPipelineProcessMessageDefaultMixin: asked_via="feishu", project_id=None, source_chat_id=source_chat_id, + source_message_id=feishu_message_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, ) return await self._finalize_direct_qa_capture_result( message=message, @@ -150,7 +162,10 @@ class FeishuPipelineProcessMessageDefaultMixin: asked_via="feishu", project_id=None, source_chat_id=source_chat_id, + source_message_id=feishu_message_id, conversation_key=conversation_key, + source_sender_open_id=source_sender_open_id, + thread_context=thread_context, message_intent="mixed", mixed_signal_part=mixed_signal_part, ) diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_a.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_a.py index 94c25775..270593ca 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_a.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_a.py @@ -2,6 +2,7 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class FeishuPipelineProcessMessageHelpersAMixin: @@ -176,29 +177,9 @@ class FeishuPipelineProcessMessageHelpersAMixin: return text[:2000] @classmethod - def _is_obvious_question(cls, message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - if cls._is_query_like_question(message): - return True - if cls._is_legacy_business_command(text): - return False - if cls._looks_like_project_lookup_question(text): - return True - return bool(OBVIOUS_QUESTION_RE.search(text)) + def _is_obvious_question(cls, message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.is_obvious_question(message) @classmethod - def _is_query_like_question(cls, message: str) -> bool: - text = str(message or "").strip() - if not text: - return False - normalized = re.sub(r"\s+", "", text.lower()) - has_question_structure = bool(OBVIOUS_QUESTION_RE.search(text) or QUERY_INTENT_RE.search(text)) - if not has_question_structure: - return False - has_operation_verb = bool(LEGACY_COMMAND_VERB_RE.search(text)) - imperative_tokens = ("帮我", "请", "麻烦", "直接", "立刻", "马上", "执行", "处理", "安排") - has_imperative = any(token in normalized for token in imperative_tokens) - return not has_operation_verb and not has_imperative - + def _is_query_like_question(cls, message: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.is_query_like_question(message) diff --git a/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_b.py b/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_b.py index 714b2ca9..584d9ce0 100644 --- a/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_b.py +++ b/backend/app/services/integrations/feishu_signal_pipeline/mixin_process_message_helpers_b.py @@ -190,9 +190,23 @@ class FeishuPipelineProcessMessageHelpersBMixin: "ai_trace_id": f"feishu-qa-{(feishu_message_id or 'noid')[:32]}", "results": [], "rag_result": rag_result, + "clarification_code": str(rag_result.get("clarification_code") or "").strip() or None, + "clarification_candidates": ( + rag_result.get("clarification_candidates") + if isinstance(rag_result.get("clarification_candidates"), list) + else [] + ), + "reason_code": str(rag_result.get("reason_code") or "").strip() or None, + "anchor_kind": str(rag_result.get("anchor_kind") or "").strip() or None, + "anchor_mode": str(rag_result.get("anchor_mode") or "").strip() or None, + "meta_followup_kind": str(rag_result.get("meta_followup_kind") or "").strip() or None, "direct_reply_required": True, - "direct_reply_text": self._build_rag_reply_text( - answer=str(rag_result.get("answer") or ""), - sources=rag_result.get("sources") or [], + "direct_reply_text": ( + str(rag_result.get("answer") or "").strip() + if str(rag_result.get("clarification_code") or "").strip() + else self._build_rag_reply_text( + answer=str(rag_result.get("answer") or ""), + sources=rag_result.get("sources") or [], + ) ), } diff --git a/backend/app/services/llm_service/mixin_prompt_profile_runtime.py b/backend/app/services/llm_service/mixin_prompt_profile_runtime.py index 2f3237ad..c9c45fe2 100644 --- a/backend/app/services/llm_service/mixin_prompt_profile_runtime.py +++ b/backend/app/services/llm_service/mixin_prompt_profile_runtime.py @@ -169,6 +169,15 @@ class LLMPromptProfileRuntimeMixin: "routing_config_version": meta.get("routing_config_version") or None, "routing_config_updated_at": meta.get("routing_config_updated_at") or None, } + self._last_ai_call_summary = { + "function_name": function_name, + "status": status, + "planned_tier": meta.get("planned_tier") or None, + "executed_tier": meta.get("executed_tier") or None, + "route_source": meta.get("route_source") or None, + "route_rule_name": meta.get("route_rule_name") or None, + "routing_decision": meta.get("routing_decision") or None, + } async with AsyncSessionLocal() as session: for attempt in range(2): try: diff --git a/backend/app/services/prompt_release/__init__.py b/backend/app/services/prompt_release/__init__.py new file mode 100644 index 00000000..78246758 --- /dev/null +++ b/backend/app/services/prompt_release/__init__.py @@ -0,0 +1,3 @@ +from .service import PromptReleaseService + +__all__ = ["PromptReleaseService"] diff --git a/backend/app/services/prompt_release/service.py b/backend/app/services/prompt_release/service.py new file mode 100644 index 00000000..d3b03f7e --- /dev/null +++ b/backend/app/services/prompt_release/service.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +from typing import Any, Optional + +from sqlalchemy import func, select +from sqlalchemy.ext.asyncio import AsyncSession + +from ...config.ai_prompt_registry import get_prompt_registry_entry +from ...models import PromptRelease +from ...utils.timezone import now_cn_naive + + +class PromptReleaseService: + def __init__(self, db: AsyncSession): + self.db = db + + @staticmethod + def _snapshot(row: PromptRelease) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "prompt_key": row.prompt_key, + "version": int(row.version), + "body_snapshot": row.body_snapshot, + "status": row.status, + "notes": row.notes, + "created_by": int(row.created_by) if row.created_by is not None else None, + "activated_by": int(row.activated_by) if row.activated_by is not None else None, + "activated_at": row.activated_at, + } + + async def create_release( + self, + *, + tenant_id: int, + prompt_key: str, + body_snapshot: str, + created_by: Optional[int], + notes: Optional[str] = None, + ) -> dict[str, Any]: + prompt_key = str(prompt_key or "").strip() + if not prompt_key: + raise ValueError("prompt_key is required") + if get_prompt_registry_entry(prompt_key) is None: + raise ValueError("unsupported prompt_key") + body_snapshot = str(body_snapshot or "").strip() + if not body_snapshot: + raise ValueError("body_snapshot is required") + current_max = ( + await self.db.execute( + select(func.max(PromptRelease.version)).where( + PromptRelease.tenant_id == int(tenant_id), + PromptRelease.prompt_key == prompt_key, + ) + ) + ).scalar_one_or_none() + row = PromptRelease( + tenant_id=int(tenant_id), + prompt_key=prompt_key, + version=int(current_max or 0) + 1, + body_snapshot=body_snapshot, + status="draft", + notes=str(notes or "").strip() or None, + created_by=created_by, + ) + self.db.add(row) + await self.db.commit() + await self.db.refresh(row) + return self._snapshot(row) + + async def activate_release( + self, + *, + tenant_id: int, + release_id: int, + actor_id: Optional[int], + ) -> dict[str, Any]: + row = ( + await self.db.execute( + select(PromptRelease).where( + PromptRelease.tenant_id == int(tenant_id), + PromptRelease.id == int(release_id), + ) + ) + ).scalar_one_or_none() + if row is None: + raise ValueError("prompt release not found") + previous = ( + await self.db.execute( + select(PromptRelease).where( + PromptRelease.tenant_id == int(tenant_id), + PromptRelease.prompt_key == row.prompt_key, + PromptRelease.status == "active", + ) + ) + ).scalars().all() + for item in previous: + item.status = "archived" + row.status = "active" + row.activated_by = actor_id + row.activated_at = now_cn_naive().isoformat() + await self.db.commit() + await self.db.refresh(row) + return self._snapshot(row) + + async def list_releases( + self, + *, + tenant_id: int, + prompt_key: Optional[str] = None, + ) -> dict[str, Any]: + stmt = select(PromptRelease).where(PromptRelease.tenant_id == int(tenant_id)) + if prompt_key: + stmt = stmt.where(PromptRelease.prompt_key == str(prompt_key).strip()) + rows = ( + await self.db.execute( + stmt.order_by(PromptRelease.prompt_key.asc(), PromptRelease.version.desc(), PromptRelease.id.desc()) + ) + ).scalars().all() + return {"items": [self._snapshot(row) for row in rows], "total": len(rows)} + + async def get_active_template( + self, + *, + tenant_id: int, + prompt_key: str, + ) -> Optional[str]: + row = ( + await self.db.execute( + select(PromptRelease.body_snapshot).where( + PromptRelease.tenant_id == int(tenant_id), + PromptRelease.prompt_key == str(prompt_key or "").strip(), + PromptRelease.status == "active", + ) + ) + ).scalar_one_or_none() + return str(row).strip() if row else None + + async def render_prompt( + self, + *, + tenant_id: int, + prompt_key: str, + fallback_template: str, + _override_template: Optional[str] = None, + **kwargs: Any, + ) -> str: + template = str(_override_template or "").strip() if _override_template is not None else "" + if not template: + template = str(await self.get_active_template(tenant_id=tenant_id, prompt_key=prompt_key) or "").strip() + if not template: + template = str(fallback_template or "") + try: + return str(template).format(**kwargs).strip() + except Exception: + return str(fallback_template or "").format(**kwargs).strip() diff --git a/backend/app/services/reply_iteration/__init__.py b/backend/app/services/reply_iteration/__init__.py new file mode 100644 index 00000000..8aacde78 --- /dev/null +++ b/backend/app/services/reply_iteration/__init__.py @@ -0,0 +1,3 @@ +from .service import ReplyIterationService + +__all__ = ["ReplyIterationService"] diff --git a/backend/app/services/reply_iteration/service.py b/backend/app/services/reply_iteration/service.py new file mode 100644 index 00000000..c9b23050 --- /dev/null +++ b/backend/app/services/reply_iteration/service.py @@ -0,0 +1,511 @@ +from __future__ import annotations + +import re +from typing import Any, Optional + +from sqlalchemy import and_, select +from sqlalchemy.ext.asyncio import AsyncSession + +from ...models import ( + Experiment, + FeedbackCenterRecord, + JudgeRun, + OptimizerCandidate, + PromptRelease, + QARecord, + QualityAsset, + QualityAssetPair, +) +from ...utils.timezone import now_cn_naive + + +PROCESS_TALK_PREFIXES = ("让我先", "我先", "我来看看", "我先看", "让我看") +EXECUTION_CLAIM_TOKENS = ("通过 API", "帮你创建", "我先检查", "后端服务", "已帮你") + + +class ReplyIterationService: + def __init__(self, db: AsyncSession): + self.db = db + + @staticmethod + def _asset_snapshot(row: QualityAsset) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "project_id": int(row.project_id) if row.project_id is not None else None, + "asset_type": row.asset_type, + "status": row.status, + "source_feedback_record_id": int(row.source_feedback_record_id) if row.source_feedback_record_id is not None else None, + "qa_record_id": int(row.qa_record_id) if row.qa_record_id is not None else None, + "ai_call_log_id": int(row.ai_call_log_id) if row.ai_call_log_id is not None else None, + "prompt_key": row.prompt_key, + "workflow_type": row.workflow_type, + "asked_via": row.asked_via, + "planned_tier": row.planned_tier, + "executed_tier": row.executed_tier, + "route_source": row.route_source, + "route_rule_name": row.route_rule_name, + "question_text": row.question_text, + "answer_text": row.answer_text, + "corrected_answer": row.corrected_answer, + "source_snapshot": row.source_snapshot or {}, + "tags": row.tags or [], + "notes": row.notes, + "approved_by": int(row.approved_by) if row.approved_by is not None else None, + "approved_at": row.approved_at, + } + + @staticmethod + def _pair_snapshot(row: QualityAssetPair) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "project_id": int(row.project_id) if row.project_id is not None else None, + "pair_type": row.pair_type, + "status": row.status, + "chosen_asset_id": int(row.chosen_asset_id), + "rejected_asset_id": int(row.rejected_asset_id), + "reason_text": row.reason_text, + "approved_by": int(row.approved_by) if row.approved_by is not None else None, + "approved_at": row.approved_at, + } + + @staticmethod + def _judge_snapshot(row: JudgeRun) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "project_id": int(row.project_id) if row.project_id is not None else None, + "asset_id": int(row.asset_id) if row.asset_id is not None else None, + "pair_id": int(row.pair_id) if row.pair_id is not None else None, + "prompt_key": row.prompt_key, + "workflow_type": row.workflow_type, + "asked_via": row.asked_via, + "planned_tier": row.planned_tier, + "executed_tier": row.executed_tier, + "route_rule_name": row.route_rule_name, + "judge_status": row.judge_status, + "bucket_key": row.bucket_key, + "rule_score": float(row.rule_score or 0.0) if row.rule_score is not None else None, + "llm_score": float(row.llm_score or 0.0) if row.llm_score is not None else None, + "overall_score": float(row.overall_score or 0.0) if row.overall_score is not None else None, + "findings": row.findings or [], + "metadata_json": row.metadata_json or {}, + } + + @staticmethod + def _candidate_snapshot(row: OptimizerCandidate) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "project_id": int(row.project_id) if row.project_id is not None else None, + "judge_run_id": int(row.judge_run_id), + "candidate_type": row.candidate_type, + "target_type": row.target_type, + "target_ref": row.target_ref, + "status": row.status, + "suggestion": row.suggestion or {}, + "evidence": row.evidence or {}, + "notes": row.notes, + } + + @staticmethod + def _experiment_snapshot(row: Experiment) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "title": row.title, + "hypothesis": row.hypothesis, + "status": row.status, + "target_metric": row.target_metric, + "current_score": float(row.current_score or 0.0) if row.current_score is not None else None, + "experiment_type": row.experiment_type, + "baseline_release_id": int(row.baseline_release_id) if row.baseline_release_id is not None else None, + "candidate_release_id": int(row.candidate_release_id) if row.candidate_release_id is not None else None, + "scope_json": row.scope_json or {}, + "result_summary": row.result_summary or {}, + "decision": row.decision, + "project_id": int(row.project_id) if row.project_id is not None else None, + } + + async def promote_feedback_record( + self, + *, + tenant_id: int, + record_id: int, + actor_id: Optional[int], + asset_type: str, + prompt_key: Optional[str] = None, + workflow_type: Optional[str] = None, + notes: Optional[str] = None, + pair_with_asset_id: Optional[int] = None, + pair_role: Optional[str] = None, + pair_reason: Optional[str] = None, + ) -> dict[str, Any]: + record = ( + await self.db.execute( + select(FeedbackCenterRecord).where( + FeedbackCenterRecord.tenant_id == int(tenant_id), + FeedbackCenterRecord.id == int(record_id), + ) + ) + ).scalar_one_or_none() + if record is None: + raise ValueError("feedback record not found") + + qa_record = None + if str(record.object_type or "").strip() == "qa_record" and record.object_id is not None: + qa_record = ( + await self.db.execute( + select(QARecord).where( + and_( + QARecord.tenant_id == int(tenant_id), + QARecord.id == int(record.object_id), + ) + ) + ) + ).scalar_one_or_none() + + before = record.before_value if isinstance(record.before_value, dict) else {} + after = record.after_value if isinstance(record.after_value, dict) else {} + ai_snapshot = record.ai_snapshot if isinstance(record.ai_snapshot, dict) else {} + routing_snapshot = ( + qa_record.routing_snapshot + if qa_record is not None and isinstance(qa_record.routing_snapshot, dict) + else {} + ) + + asset = QualityAsset( + tenant_id=int(tenant_id), + project_id=int(record.project_id) if record.project_id is not None else None, + asset_type=str(asset_type or "").strip().lower(), + status="approved", + source_feedback_record_id=int(record.id), + qa_record_id=int(qa_record.id) if qa_record is not None else None, + prompt_key=str(prompt_key or ai_snapshot.get("prompt_key") or "").strip() or None, + workflow_type=str(workflow_type or ai_snapshot.get("workflow_type") or "query.read_only").strip() or None, + asked_via=str(getattr(qa_record, "asked_via", "") or "").strip() or None, + planned_tier=str(routing_snapshot.get("planned_tier") or "").strip() or None, + executed_tier=str(routing_snapshot.get("executed_tier") or "").strip() or None, + route_source=str(routing_snapshot.get("route_source") or "").strip() or None, + route_rule_name=str(routing_snapshot.get("route_rule_name") or "").strip() or None, + question_text=str(before.get("question") or getattr(qa_record, "question", "") or "").strip(), + answer_text=str(before.get("answer") or getattr(qa_record, "answer", "") or "").strip(), + corrected_answer=str(after.get("correct_answer") or record.reason_text or "").strip() or None, + source_snapshot={ + "feedback_record_id": int(record.id), + "reason_code": record.reason_code, + "review_status": record.review_status, + "routing_snapshot": routing_snapshot, + }, + tags=[ + code + for code in ( + str(record.reason_code or "").strip(), + str(after.get("rating") or "").strip(), + ) + if code + ], + notes=str(notes or "").strip() or None, + approved_by=actor_id, + approved_at=now_cn_naive().isoformat(), + ) + if not asset.question_text or not asset.answer_text: + raise ValueError("feedback record missing question/answer evidence") + self.db.add(asset) + await self.db.flush() + + pair_payload = None + if pair_with_asset_id is not None: + paired_asset = ( + await self.db.execute( + select(QualityAsset).where( + QualityAsset.tenant_id == int(tenant_id), + QualityAsset.id == int(pair_with_asset_id), + ) + ) + ).scalar_one_or_none() + if paired_asset is None: + raise ValueError("paired quality asset not found") + role = str(pair_role or "chosen").strip().lower() + chosen_id = int(asset.id) if role == "chosen" else int(paired_asset.id) + rejected_id = int(paired_asset.id) if role == "chosen" else int(asset.id) + pair = QualityAssetPair( + tenant_id=int(tenant_id), + project_id=int(record.project_id) if record.project_id is not None else None, + pair_type="preference", + status="approved", + chosen_asset_id=chosen_id, + rejected_asset_id=rejected_id, + reason_text=str(pair_reason or "").strip() or None, + approved_by=actor_id, + approved_at=now_cn_naive().isoformat(), + ) + self.db.add(pair) + await self.db.flush() + pair_payload = self._pair_snapshot(pair) + + await self.db.commit() + await self.db.refresh(asset) + return {"asset": self._asset_snapshot(asset), "pair": pair_payload} + + async def list_assets( + self, + *, + tenant_id: int, + asset_type: Optional[str] = None, + prompt_key: Optional[str] = None, + limit: int = 20, + offset: int = 0, + ) -> dict[str, Any]: + stmt = select(QualityAsset).where(QualityAsset.tenant_id == int(tenant_id)) + if asset_type: + stmt = stmt.where(QualityAsset.asset_type == str(asset_type).strip().lower()) + if prompt_key: + stmt = stmt.where(QualityAsset.prompt_key == str(prompt_key).strip()) + rows = ( + await self.db.execute( + stmt.order_by(QualityAsset.id.desc()).offset(int(offset)).limit(int(limit)) + ) + ).scalars().all() + return { + "items": [self._asset_snapshot(row) for row in rows], + "total": len(rows), + "limit": int(limit), + "offset": int(offset), + } + + @staticmethod + def _build_rule_findings(asset: QualityAsset) -> list[dict[str, Any]]: + findings: list[dict[str, Any]] = [] + answer = str(asset.answer_text or "").strip() + normalized = re.sub(r"\s+", "", answer) + if any(answer.startswith(prefix) for prefix in PROCESS_TALK_PREFIXES): + findings.append({"code": "process_talk_prefix", "severity": "warning", "message": "存在过程话术前缀"}) + if any(token in normalized for token in [re.sub(r"\s+", "", token) for token in EXECUTION_CLAIM_TOKENS]): + findings.append({"code": "execution_claim_prefix", "severity": "warning", "message": "存在执行型兜底话术"}) + if str(asset.planned_tier or "").strip() == "low" and str(asset.executed_tier or "").strip() == "high": + findings.append({"code": "tier_escalation", "severity": "info", "message": "存在 low -> high 升级"}) + return findings + + async def create_judge_run( + self, + *, + tenant_id: int, + asset_id: int, + actor_id: Optional[int], + ) -> dict[str, Any]: + _ = actor_id + asset = ( + await self.db.execute( + select(QualityAsset).where( + QualityAsset.tenant_id == int(tenant_id), + QualityAsset.id == int(asset_id), + ) + ) + ).scalar_one_or_none() + if asset is None: + raise ValueError("quality asset not found") + findings = self._build_rule_findings(asset) + penalty = min(0.8, 0.25 * len(findings)) + score = round(max(0.0, 1.0 - penalty), 4) + bucket_key = "|".join( + [ + str(asset.prompt_key or "unknown"), + str(asset.workflow_type or "unknown"), + str(asset.asked_via or "unknown"), + str(asset.planned_tier or "unknown"), + str(asset.executed_tier or "unknown"), + ] + ) + judge = JudgeRun( + tenant_id=int(tenant_id), + project_id=int(asset.project_id) if asset.project_id is not None else None, + asset_id=int(asset.id), + prompt_key=asset.prompt_key, + workflow_type=asset.workflow_type, + asked_via=asset.asked_via, + planned_tier=asset.planned_tier, + executed_tier=asset.executed_tier, + route_rule_name=asset.route_rule_name, + judge_status="completed", + bucket_key=bucket_key, + rule_score=score, + llm_score=None, + overall_score=score, + findings=findings, + metadata_json={"llm_status": "pending", "asset_type": asset.asset_type}, + ) + self.db.add(judge) + await self.db.commit() + await self.db.refresh(judge) + return self._judge_snapshot(judge) + + async def list_judge_runs(self, *, tenant_id: int, limit: int = 20, offset: int = 0) -> dict[str, Any]: + rows = ( + await self.db.execute( + select(JudgeRun) + .where(JudgeRun.tenant_id == int(tenant_id)) + .order_by(JudgeRun.id.desc()) + .offset(int(offset)) + .limit(int(limit)) + ) + ).scalars().all() + return {"items": [self._judge_snapshot(row) for row in rows], "total": len(rows), "limit": int(limit), "offset": int(offset)} + + async def create_optimizer_candidate( + self, + *, + tenant_id: int, + judge_run_id: int, + actor_id: Optional[int], + ) -> dict[str, Any]: + _ = actor_id + judge = ( + await self.db.execute( + select(JudgeRun).where( + JudgeRun.tenant_id == int(tenant_id), + JudgeRun.id == int(judge_run_id), + ) + ) + ).scalar_one_or_none() + if judge is None: + raise ValueError("judge run not found") + findings = judge.findings if isinstance(judge.findings, list) else [] + finding_codes = {str(item.get("code") or "").strip() for item in findings if isinstance(item, dict)} + if {"process_talk_prefix", "execution_claim_prefix"}.intersection(finding_codes): + candidate_type = "renderer_policy_change" + target_type = "renderer_policy" + target_ref = "reply_renderer" + summary = "收紧过程话术和执行型前缀" + elif "tier_escalation" in finding_codes: + candidate_type = "routing_policy_change" + target_type = "routing_policy" + target_ref = "model_routing" + summary = "复核 low/high 路由升级门槛" + else: + candidate_type = "prompt_change" + target_type = "prompt_key" + target_ref = str(judge.prompt_key or "unknown") + summary = "优化回答提示词结构" + row = OptimizerCandidate( + tenant_id=int(tenant_id), + project_id=int(judge.project_id) if judge.project_id is not None else None, + judge_run_id=int(judge.id), + candidate_type=candidate_type, + target_type=target_type, + target_ref=target_ref, + status="draft", + suggestion={"summary": summary, "bucket_key": judge.bucket_key}, + evidence={"findings": findings, "overall_score": judge.overall_score}, + ) + self.db.add(row) + await self.db.commit() + await self.db.refresh(row) + return self._candidate_snapshot(row) + + async def list_candidates(self, *, tenant_id: int, limit: int = 20, offset: int = 0) -> dict[str, Any]: + rows = ( + await self.db.execute( + select(OptimizerCandidate) + .where(OptimizerCandidate.tenant_id == int(tenant_id)) + .order_by(OptimizerCandidate.id.desc()) + .offset(int(offset)) + .limit(int(limit)) + ) + ).scalars().all() + return {"items": [self._candidate_snapshot(row) for row in rows], "total": len(rows), "limit": int(limit), "offset": int(offset)} + + async def list_trials(self, *, tenant_id: int, limit: int = 20, offset: int = 0) -> dict[str, Any]: + rows = ( + await self.db.execute( + select(Experiment) + .where( + Experiment.tenant_id == int(tenant_id), + Experiment.experiment_type == "prompt_release_trial", + ) + .order_by(Experiment.id.desc()) + .offset(int(offset)) + .limit(int(limit)) + ) + ).scalars().all() + return {"items": [self._experiment_snapshot(row) for row in rows], "total": len(rows), "limit": int(limit), "offset": int(offset)} + + async def create_trial( + self, + *, + tenant_id: int, + actor_id: Optional[int], + title: str, + hypothesis: str, + target_metric: str, + prompt_key: str, + baseline_release_id: int, + candidate_release_id: int, + scope_json: Optional[dict[str, Any]], + ) -> dict[str, Any]: + for release_id in (baseline_release_id, candidate_release_id): + release = ( + await self.db.execute( + select(PromptRelease).where( + PromptRelease.tenant_id == int(tenant_id), + PromptRelease.id == int(release_id), + PromptRelease.prompt_key == str(prompt_key or "").strip(), + ) + ) + ).scalar_one_or_none() + if release is None: + raise ValueError("prompt release not found for trial") + row = Experiment( + tenant_id=int(tenant_id), + title=str(title or "").strip(), + hypothesis=str(hypothesis or "").strip() or None, + status="running", + target_metric=str(target_metric or "").strip() or None, + experiment_type="prompt_release_trial", + baseline_release_id=int(baseline_release_id), + candidate_release_id=int(candidate_release_id), + scope_json=scope_json or {}, + decision=None, + ) + row.linked_context_nodes = {"prompt_key": str(prompt_key or "").strip(), "actor_id": actor_id} + self.db.add(row) + await self.db.commit() + await self.db.refresh(row) + return self._experiment_snapshot(row) + + async def decide_trial( + self, + *, + tenant_id: int, + trial_id: int, + actor_id: Optional[int], + decision: str, + result_summary: Optional[dict[str, Any]], + ) -> dict[str, Any]: + row = ( + await self.db.execute( + select(Experiment).where( + Experiment.tenant_id == int(tenant_id), + Experiment.id == int(trial_id), + Experiment.experiment_type == "prompt_release_trial", + ) + ) + ).scalar_one_or_none() + if row is None: + raise ValueError("prompt release trial not found") + normalized = str(decision or "").strip().lower() + if normalized not in {"accepted", "rejected", "rolled_back"}: + raise ValueError("unsupported decision") + row.decision = normalized + row.status = "success" if normalized == "accepted" else "failed" + row.result_summary = result_summary or {} + row.current_score = float((result_summary or {}).get("accepted_rate") or 0.0) if result_summary else row.current_score + row.linked_context_nodes = { + **(row.linked_context_nodes if isinstance(row.linked_context_nodes, dict) else {}), + "decision_actor_id": actor_id, + "decided_at": now_cn_naive().isoformat(), + } + await self.db.commit() + await self.db.refresh(row) + return self._experiment_snapshot(row) diff --git a/backend/app/services/signal/signal_capture_service/mixin_capture_entry.py b/backend/app/services/signal/signal_capture_service/mixin_capture_entry.py index 93b3cf82..00fd0fcc 100644 --- a/backend/app/services/signal/signal_capture_service/mixin_capture_entry.py +++ b/backend/app/services/signal/signal_capture_service/mixin_capture_entry.py @@ -1,7 +1,8 @@ from __future__ import annotations from .shared import * -from ...ai_pmo.ai_pmo_intent import INTENT_IGNORE, INTENT_QUERY, IntentResolver +from ...ai_pmo.ai_pmo_intent import INTENT_QUERY +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class SignalCaptureEntryMixin: def __init__(self, db: AsyncSession): @@ -18,10 +19,15 @@ class SignalCaptureEntryMixin: if not clean_text: return False, "empty" - resolved_intent = IntentResolver.resolve(text=clean_text, project_id=None) - resolved_name = str(resolved_intent.name or "").strip().lower() - if resolved_name in {INTENT_QUERY, INTENT_IGNORE}: - return True, f"intent:{resolved_name}" + bundle = WorkflowSemanticPlanner.plan_message( + message_text=clean_text, + source_system="feishu", + ) + workflow_types = [item.workflow_type for item in bundle.workflows] + if workflow_types == ["query_flow"]: + return True, "semantic:query_flow" + if workflow_types == ["followup_flow"]: + return True, "semantic:followup_flow" if cls._is_question_like(clean_text): return True, "question_like" return False, "async_queue" diff --git a/backend/app/services/signal/signal_capture_service/mixin_pipeline_cache.py b/backend/app/services/signal/signal_capture_service/mixin_pipeline_cache.py index 7a4b4cef..af1526ba 100644 --- a/backend/app/services/signal/signal_capture_service/mixin_pipeline_cache.py +++ b/backend/app/services/signal/signal_capture_service/mixin_pipeline_cache.py @@ -1,6 +1,7 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class SignalCapturePipelineCacheMixin: async def _sync_feishu_recent_cache( @@ -110,7 +111,7 @@ class SignalCapturePipelineCacheMixin: return pipeline_result source_orchestration_result: Optional[Dict[str, Any]] = None - if SignalSourceOrchestrationService.looks_like_signal_source_request(cleaned_message): + if WorkflowSemanticPlanner.looks_like_signal_source_request(cleaned_message): try: source_orchestration_result = await SignalSourceOrchestrationService(self.db).orchestrate_from_signal( tenant_id=tenant_id, diff --git a/backend/app/services/signal/signal_source_orchestration/mixin_entry_orchestrate.py b/backend/app/services/signal/signal_source_orchestration/mixin_entry_orchestrate.py index 7fb9adff..55c196c0 100644 --- a/backend/app/services/signal/signal_source_orchestration/mixin_entry_orchestrate.py +++ b/backend/app/services/signal/signal_source_orchestration/mixin_entry_orchestrate.py @@ -1,22 +1,15 @@ from __future__ import annotations from .shared import * +from ...ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner class SignalSourceEntryOrchestrateMixin: def __init__(self, db: AsyncSession) -> None: self.db = db @classmethod - def looks_like_signal_source_request(cls, text: str) -> bool: - normalized = re.sub(r"\s+", "", str(text or "")) - if len(normalized) < 3: - return False - if "信号源" in normalized and any( - token in normalized - for token in ("新增", "增加", "添加", "接入", "配置", "注册", "建立", "加个", "加一个", "加") - ): - return True - return bool(SOURCE_ONBOARDING_ACTION_RE.search(normalized)) + def looks_like_signal_source_request(cls, text: str) -> bool: # semantic-lint: ignore - compat wrapper over workflow_semantic_planner + return WorkflowSemanticPlanner.looks_like_signal_source_request(text) async def orchestrate_from_signal( self, @@ -202,4 +195,3 @@ class SignalSourceEntryOrchestrateMixin: base_result=base_result, run_service=run_service, ) - diff --git a/backend/app/services/signal/signal_source_orchestration/shared.py b/backend/app/services/signal/signal_source_orchestration/shared.py index e634a082..4af989f4 100644 --- a/backend/app/services/signal/signal_source_orchestration/shared.py +++ b/backend/app/services/signal/signal_source_orchestration/shared.py @@ -33,10 +33,8 @@ from ...model.prompt_profile import prompt_profile_service from ...llm_service import llm_service from ....utils.timezone import now_cn_naive -SOURCE_ONBOARDING_ACTION_RE = re.compile( - r"(新增|增加|添加|接入|配置|注册|建立|加个|加一个|加).{0,8}(信号源|来源|监控源|channel|source|webhook|飞书|github|url|rss)", - re.IGNORECASE, -) +from ...ai_pmo.workflow_semantic_planner.constants import SOURCE_ONBOARDING_ACTION_RE + SOURCE_KIND_HINTS: tuple[tuple[str, tuple[str, ...]], ...] = ( ("feishu", ("飞书", "lark", "群聊", "chat")), ("github", ("github", "repo", "仓库", "pull request", "issue")), diff --git a/backend/app/services/training_pipeline/__init__.py b/backend/app/services/training_pipeline/__init__.py new file mode 100644 index 00000000..bee99f6c --- /dev/null +++ b/backend/app/services/training_pipeline/__init__.py @@ -0,0 +1,3 @@ +from .service import TrainingPipelineService + +__all__ = ["TrainingPipelineService"] diff --git a/backend/app/services/training_pipeline/service.py b/backend/app/services/training_pipeline/service.py new file mode 100644 index 00000000..b4007d82 --- /dev/null +++ b/backend/app/services/training_pipeline/service.py @@ -0,0 +1,422 @@ +from __future__ import annotations + +from typing import Any, Optional + +from sqlalchemy import and_, select +from sqlalchemy.ext.asyncio import AsyncSession + +from ...models import ( + QualityAsset, + QualityAssetPair, + TrainedModelArtifact, + TrainedModelDeployment, + TrainingDataset, + TrainingDatasetItem, + TrainingEvaluation, + TrainingJob, + TrainingJobRun, +) +from ...utils.timezone import now_cn_naive + + +EVALUATION_TYPES = ("offline_judge", "structure_compliance", "shadow_replay") + + +class TrainingPipelineService: + def __init__(self, db: AsyncSession): + self.db = db + + @staticmethod + def _dataset_snapshot(row: TrainingDataset) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "project_id": int(row.project_id) if row.project_id is not None else None, + "dataset_type": row.dataset_type, + "version": row.version, + "status": row.status, + "sample_count": int(row.sample_count or 0), + "selection_rules": row.selection_rules or {}, + "channel_scope": row.channel_scope or {}, + "notes": row.notes, + } + + def _job_snapshot(self, row: TrainingJob, *, artifact: Optional[TrainedModelArtifact] = None) -> dict[str, Any]: + payload = { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "project_id": int(row.project_id) if row.project_id is not None else None, + "dataset_id": int(row.dataset_id), + "job_type": row.job_type, + "base_model_family": row.base_model_family, + "target_slot": row.target_slot, + "status": row.status, + "provider_backend": row.provider_backend, + "artifact_ref": row.artifact_ref, + "metrics_json": row.metrics_json or {}, + } + if artifact is not None: + payload["artifact"] = self._artifact_snapshot(artifact) + return payload + + @staticmethod + def _artifact_snapshot(row: TrainedModelArtifact) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "training_job_id": int(row.training_job_id), + "artifact_ref": row.artifact_ref, + "base_model_family": row.base_model_family, + "target_slot": row.target_slot, + "status": row.status, + "metrics_json": row.metrics_json or {}, + } + + @staticmethod + def _deployment_snapshot(row: TrainedModelDeployment) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "artifact_id": int(row.artifact_id), + "deployment_status": row.deployment_status, + "bound_tier": row.bound_tier, + "effective_scope": row.effective_scope or {}, + "decision": row.decision, + "notes": row.notes, + "decided_by": int(row.decided_by) if row.decided_by is not None else None, + "decided_at": row.decided_at, + } + + @staticmethod + def _evaluation_snapshot(row: TrainingEvaluation) -> dict[str, Any]: + return { + "id": int(row.id), + "tenant_id": int(row.tenant_id), + "training_job_id": int(row.training_job_id), + "evaluation_type": row.evaluation_type, + "status": row.status, + "score": float(row.score or 0.0) if row.score is not None else None, + "evaluation_summary": row.evaluation_summary or {}, + } + + async def create_dataset( + self, + *, + tenant_id: int, + actor_id: Optional[int], + dataset_type: str, + version: str, + asset_ids: list[int], + pair_ids: list[int], + selection_rules: Optional[dict[str, Any]], + notes: Optional[str], + ) -> dict[str, Any]: + dataset_type = str(dataset_type or "").strip().lower() + if dataset_type not in {"sft", "preference", "eval"}: + raise ValueError("unsupported dataset_type") + asset_ids = [int(x) for x in asset_ids or []] + pair_ids = [int(x) for x in pair_ids or []] + + assets = [] + if asset_ids: + assets = ( + await self.db.execute( + select(QualityAsset).where( + QualityAsset.tenant_id == int(tenant_id), + QualityAsset.id.in_(asset_ids), + ) + ) + ).scalars().all() + pairs = [] + if pair_ids: + pairs = ( + await self.db.execute( + select(QualityAssetPair).where( + QualityAssetPair.tenant_id == int(tenant_id), + QualityAssetPair.id.in_(pair_ids), + ) + ) + ).scalars().all() + + if dataset_type == "sft": + if not assets or any(asset.asset_type != "golden" or asset.status != "approved" for asset in assets): + raise ValueError("SFT dataset only accepts approved golden assets") + if dataset_type == "preference": + if not pairs or any(pair.status != "approved" for pair in pairs): + raise ValueError("Preference dataset only accepts approved asset pairs") + if dataset_type == "eval" and not (assets or pairs): + raise ValueError("Eval dataset requires assets or pairs") + + project_id = None + if assets: + project_id = assets[0].project_id + elif pairs: + project_id = pairs[0].project_id + dataset = TrainingDataset( + tenant_id=int(tenant_id), + project_id=int(project_id) if project_id is not None else None, + dataset_type=dataset_type, + version=str(version or "").strip() or f"{dataset_type}-v1", + status="ready", + sample_count=len(assets) + len(pairs), + selection_rules=selection_rules or {}, + channel_scope={}, + notes=str(notes or "").strip() or None, + created_by=actor_id, + ) + self.db.add(dataset) + await self.db.flush() + + for asset in assets: + self.db.add( + TrainingDatasetItem( + tenant_id=int(tenant_id), + dataset_id=int(dataset.id), + quality_asset_id=int(asset.id), + redacted_snapshot={ + "question_text": asset.question_text, + "answer_text": asset.answer_text, + "corrected_answer": asset.corrected_answer, + "prompt_key": asset.prompt_key, + }, + ) + ) + for pair in pairs: + self.db.add( + TrainingDatasetItem( + tenant_id=int(tenant_id), + dataset_id=int(dataset.id), + quality_asset_pair_id=int(pair.id), + redacted_snapshot={ + "pair_type": pair.pair_type, + "reason_text": pair.reason_text, + }, + ) + ) + await self.db.commit() + await self.db.refresh(dataset) + return self._dataset_snapshot(dataset) + + async def create_job( + self, + *, + tenant_id: int, + actor_id: Optional[int], + dataset_id: int, + job_type: str, + base_model_family: str, + target_slot: str, + provider_backend: str, + ) -> dict[str, Any]: + normalized_job_type = str(job_type or "").strip().lower() + if normalized_job_type not in {"sft", "preference"}: + raise ValueError("unsupported training job_type") + normalized_target_slot = str(target_slot or "").strip().lower() + if normalized_target_slot not in {"low", "high"}: + raise ValueError("unsupported target_slot") + dataset = ( + await self.db.execute( + select(TrainingDataset).where( + TrainingDataset.tenant_id == int(tenant_id), + TrainingDataset.id == int(dataset_id), + ) + ) + ).scalar_one_or_none() + if dataset is None: + raise ValueError("training dataset not found") + + job = TrainingJob( + tenant_id=int(tenant_id), + project_id=int(dataset.project_id) if dataset.project_id is not None else None, + dataset_id=int(dataset.id), + job_type=normalized_job_type, + base_model_family=str(base_model_family or "").strip(), + target_slot=normalized_target_slot, + status="queued", + provider_backend=str(provider_backend or "").strip(), + artifact_ref=None, + metrics_json={}, + created_by=actor_id, + ) + self.db.add(job) + await self.db.flush() + + run = TrainingJobRun( + tenant_id=int(tenant_id), + training_job_id=int(job.id), + status="queued", + provider_run_ref=None, + metrics_json={}, + ) + self.db.add(run) + + artifact = TrainedModelArtifact( + tenant_id=int(tenant_id), + training_job_id=int(job.id), + artifact_ref=f"artifact:{job.job_type}:{job.id}", + base_model_family=job.base_model_family, + target_slot=job.target_slot, + status="pending_eval", + metrics_json={}, + ) + self.db.add(artifact) + await self.db.flush() + job.artifact_ref = artifact.artifact_ref + + for evaluation_type in EVALUATION_TYPES: + self.db.add( + TrainingEvaluation( + tenant_id=int(tenant_id), + training_job_id=int(job.id), + evaluation_type=evaluation_type, + status="pending", + score=None, + evaluation_summary={}, + ) + ) + + await self.db.commit() + await self.db.refresh(job) + await self.db.refresh(artifact) + return self._job_snapshot(job, artifact=artifact) + + async def list_datasets( + self, + *, + tenant_id: int, + dataset_type: Optional[str] = None, + limit: int = 20, + offset: int = 0, + ) -> dict[str, Any]: + stmt = select(TrainingDataset).where(TrainingDataset.tenant_id == int(tenant_id)) + if dataset_type: + stmt = stmt.where(TrainingDataset.dataset_type == str(dataset_type).strip().lower()) + rows = ( + await self.db.execute( + stmt.order_by(TrainingDataset.id.desc()).offset(int(offset)).limit(int(limit)) + ) + ).scalars().all() + return {"items": [self._dataset_snapshot(row) for row in rows], "total": len(rows), "limit": int(limit), "offset": int(offset)} + + async def list_jobs( + self, + *, + tenant_id: int, + status: Optional[str] = None, + limit: int = 20, + offset: int = 0, + ) -> dict[str, Any]: + stmt = select(TrainingJob).where(TrainingJob.tenant_id == int(tenant_id)) + if status: + stmt = stmt.where(TrainingJob.status == str(status).strip().lower()) + rows = ( + await self.db.execute( + stmt.order_by(TrainingJob.id.desc()).offset(int(offset)).limit(int(limit)) + ) + ).scalars().all() + return {"items": [self._job_snapshot(row) for row in rows], "total": len(rows), "limit": int(limit), "offset": int(offset)} + + async def list_evaluations(self, *, tenant_id: int, job_id: int) -> dict[str, Any]: + rows = ( + await self.db.execute( + select(TrainingEvaluation) + .where( + TrainingEvaluation.tenant_id == int(tenant_id), + TrainingEvaluation.training_job_id == int(job_id), + ) + .order_by(TrainingEvaluation.id.asc()) + ) + ).scalars().all() + return {"items": [self._evaluation_snapshot(row) for row in rows], "total": len(rows)} + + async def promote_artifact( + self, + *, + tenant_id: int, + artifact_id: int, + actor_id: Optional[int], + ) -> dict[str, Any]: + artifact = ( + await self.db.execute( + select(TrainedModelArtifact).where( + TrainedModelArtifact.tenant_id == int(tenant_id), + TrainedModelArtifact.id == int(artifact_id), + ) + ) + ).scalar_one_or_none() + if artifact is None: + raise ValueError("trained model artifact not found") + artifact.status = "candidate" + row = TrainedModelDeployment( + tenant_id=int(tenant_id), + artifact_id=int(artifact.id), + deployment_status="candidate", + bound_tier=str(artifact.target_slot or "").strip().lower() or "low", + effective_scope={}, + decision=None, + notes=None, + decided_by=actor_id, + decided_at=now_cn_naive().isoformat(), + ) + self.db.add(row) + await self.db.commit() + await self.db.refresh(row) + return self._deployment_snapshot(row) + + async def decide_deployment( + self, + *, + tenant_id: int, + deployment_id: int, + actor_id: Optional[int], + decision: str, + notes: Optional[str], + ) -> dict[str, Any]: + row = ( + await self.db.execute( + select(TrainedModelDeployment).where( + and_( + TrainedModelDeployment.tenant_id == int(tenant_id), + TrainedModelDeployment.id == int(deployment_id), + ) + ) + ) + ).scalar_one_or_none() + if row is None: + raise ValueError("trained model deployment not found") + normalized = str(decision or "").strip().lower() + if normalized not in {"accepted", "rejected", "rolled_back"}: + raise ValueError("unsupported decision") + row.decision = normalized + row.notes = str(notes or "").strip() or None + row.decided_by = actor_id + row.decided_at = now_cn_naive().isoformat() + row.deployment_status = "active" if normalized == "accepted" else "rollback" + await self.db.commit() + await self.db.refresh(row) + return self._deployment_snapshot(row) + + async def list_deployments( + self, + *, + tenant_id: int, + deployment_status: Optional[str] = None, + limit: int = 20, + offset: int = 0, + ) -> dict[str, Any]: + stmt = select(TrainedModelDeployment).where(TrainedModelDeployment.tenant_id == int(tenant_id)) + if deployment_status: + stmt = stmt.where( + TrainedModelDeployment.deployment_status == str(deployment_status).strip().lower() + ) + rows = ( + await self.db.execute( + stmt.order_by(TrainedModelDeployment.id.desc()).offset(int(offset)).limit(int(limit)) + ) + ).scalars().all() + return { + "items": [self._deployment_snapshot(row) for row in rows], + "total": len(rows), + "limit": int(limit), + "offset": int(offset), + } diff --git a/backend/app/utils/thread_context.py b/backend/app/utils/thread_context.py index e8ab8d32..33f06035 100644 --- a/backend/app/utils/thread_context.py +++ b/backend/app/utils/thread_context.py @@ -44,3 +44,21 @@ def build_feishu_thread_key( return f"feishu:{chat}:{actor}" if chat else f"feishu:{actor}" return "" + +def build_feishu_conversation_scope_key( + *, + source_chat_id: Optional[str], + source_sender_open_id: Optional[str], + sender: Optional[str], +) -> str: + chat = _normalize_token(source_chat_id) + actor = _normalize_token(source_sender_open_id) + if not actor: + actor = _normalize_token(sender).lower() + if chat and actor: + return f"feishu:{chat}:{actor}" + if actor: + return f"feishu:{actor}" + if chat: + return f"feishu:{chat}" + return "" diff --git a/backend/tests/test_adaptive_rag_external_followup_contract.py b/backend/tests/test_adaptive_rag_external_followup_contract.py new file mode 100644 index 00000000..94aafb64 --- /dev/null +++ b/backend/tests/test_adaptive_rag_external_followup_contract.py @@ -0,0 +1,484 @@ +from __future__ import annotations + +from datetime import timedelta + +import pytest +import pytest_asyncio +from sqlalchemy import JSON +from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine + +from app.models.base import Base +from app.models.feishu_reply_outbox import FeishuReplyOutbox +from app.models.ingest_event import IngestEvent +from app.models.qa_record import QARecord +from app.models.qa_session import QASession +from app.models.qa_session_state import QASessionState +from app.services.adaptive_rag_service.mixin_core_intent import AdaptiveRAGCoreIntentMixin +from app.services.adaptive_rag_service.mixin_followup_anchor import ( + AdaptiveRAGFollowupAnchorMixin, + FollowupAnchorResolution, +) +from app.services.adaptive_rag_service.mixin_qa_session_core import AdaptiveRAGQASessionCoreMixin +from app.services.adaptive_rag_service.mixin_session_state import AdaptiveRAGSessionStateMixin +from app.utils.timezone import now_cn_naive + + +def _use_sqlite_json_types() -> None: + for table in (QARecord.__table__, QASessionState.__table__, IngestEvent.__table__): + for column in table.columns: + if column.name in { + "sources", + "domains_used", + "last_entity_ids", + "rewrite_history", + "pending_clarification", + "routing_snapshot", + }: + column.type = JSON() + if table.name == "ingest_events" and column.name == "payload": + column.type = JSON() + + +@pytest_asyncio.fixture +async def db_session(): + engine = create_async_engine("sqlite+aiosqlite:///:memory:") + _use_sqlite_json_types() + async with engine.begin() as conn: + await conn.run_sync( + lambda sync_conn: Base.metadata.create_all( + sync_conn, + tables=[ + QASession.__table__, + QASessionState.__table__, + QARecord.__table__, + FeishuReplyOutbox.__table__, + IngestEvent.__table__, + ], + ) + ) + maker = async_sessionmaker(engine, expire_on_commit=False) + async with maker() as session: + yield session + await engine.dispose() + + +class _FakeContextCache: + async def get_session_messages(self, *, tenant_id: int, session_id: int | None): + _ = (tenant_id, session_id) + return [] + + async def append_session_messages(self, *, tenant_id: int, session_id: int | None, question: str, answer: str): + _ = (tenant_id, session_id, question, answer) + return None + + @staticmethod + def messages_to_turns(messages): + _ = messages + return [] + + +class _Harness( + AdaptiveRAGCoreIntentMixin, + AdaptiveRAGQASessionCoreMixin, + AdaptiveRAGSessionStateMixin, + AdaptiveRAGFollowupAnchorMixin, +): + def __init__(self, db) -> None: + super().__init__(db, tenant_id=1) + self.context_cache = _FakeContextCache() + + +@pytest.mark.asyncio +async def test_external_conversation_key_creates_and_reuses_real_qa_session(db_session) -> None: + service = _Harness(db_session) + + session_id, turn_index = await service._touch_session_for_new_record( + asked_by=None, + asked_via="feishu", + project_id=None, + question="帮我解释下系统架构", + external_conversation_key="feishu:chat-1:root-1", + ) + + assert session_id is not None + assert turn_index == 1 + + reused_session_id, reused_turn_index = await service._touch_session_for_new_record( + asked_by=None, + asked_via="feishu", + project_id=None, + question="系统有什么模型？", + external_conversation_key="feishu:chat-1:root-1", + ) + + assert reused_session_id == session_id + assert reused_turn_index == 2 + + row = await db_session.get(QASession, int(session_id)) + assert row is not None + assert row.user_id is None + assert row.external_conversation_key == "feishu:chat-1:root-1" + + +@pytest.mark.asyncio +async def test_meta_followup_prefers_single_recent_reply_candidate(db_session) -> None: + service = _Harness(db_session) + session = QASession( + tenant_id=1, + user_id=None, + title="系统架构", + external_conversation_key="feishu:chat-1:root-1", + started_at=now_cn_naive(), + last_message_at=now_cn_naive(), + message_count=1, + ) + db_session.add(session) + await db_session.flush() + db_session.add( + QARecord( + tenant_id=1, + question="帮我解释下系统的架构", + answer="PMFlow 系统采用前后端分离架构。", + sources=[], + intent="question", + domains_used=[], + response_time_ms=10, + asked_by=None, + asked_via="feishu", + project_id=None, + session_id=int(session.id), + turn_index=1, + ) + ) + await db_session.commit() + + state = await service._ensure_session_state(session_id=int(session.id)) + resolution = await service._resolve_followup_anchor( + question="我问你这个是哪个模型执行回复的？", + session_id=int(session.id), + context_session_id=int(session.id), + session_state=state, + ) + + assert resolution.anchor_mode == "implicit_recent_reply" + assert resolution.anchor_reply_id is not None + assert resolution.is_meta_followup is True + assert resolution.candidate_replies == [] + + +@pytest.mark.asyncio +async def test_ambiguous_recent_reply_returns_numbered_candidates(db_session) -> None: + service = _Harness(db_session) + now = now_cn_naive() + session = QASession( + tenant_id=1, + user_id=None, + title="新会话", + external_conversation_key="feishu:chat-1:root-1", + started_at=now, + last_message_at=now, + message_count=2, + ) + db_session.add(session) + await db_session.flush() + db_session.add_all( + [ + QARecord( + tenant_id=1, + question="帮我解释下系统架构", + answer="PMFlow 系统采用前后端分离架构。", + sources=[], + intent="question", + domains_used=[], + response_time_ms=10, + asked_by=None, + asked_via="feishu", + project_id=None, + session_id=int(session.id), + turn_index=1, + created_at=now - timedelta(minutes=1), + ), + QARecord( + tenant_id=1, + question="系统有什么模型？", + answer="当前有 low/high 两层模型路由。", + sources=[], + intent="question", + domains_used=[], + response_time_ms=12, + asked_by=None, + asked_via="feishu", + project_id=None, + session_id=int(session.id), + turn_index=2, + created_at=now, + ), + ] + ) + await db_session.commit() + + state = await service._ensure_session_state(session_id=int(session.id)) + resolution = await service._resolve_followup_anchor( + question="那你刚才那条是哪个模型回复的？", + session_id=int(session.id), + context_session_id=int(session.id), + session_state=state, + ) + + assert resolution.anchor_mode == "ambiguous_candidates" + assert resolution.anchor_reply_id is None + assert len(resolution.candidate_replies) == 2 + assert resolution.candidate_replies[0]["index"] == 1 + assert resolution.candidate_replies[1]["index"] == 2 + + +@pytest.mark.asyncio +async def test_pending_clarification_selection_restores_original_question(db_session) -> None: + service = _Harness(db_session) + session = QASession( + tenant_id=1, + user_id=None, + title="新会话", + external_conversation_key="feishu:chat-1:root-1", + started_at=now_cn_naive(), + last_message_at=now_cn_naive(), + message_count=1, + ) + db_session.add(session) + await db_session.flush() + state = await service._ensure_session_state(session_id=int(session.id)) + state.pending_clarification = { + "kind": "followup_anchor_selection", + "original_question": "我问你这个是哪个模型执行回复的？", + "candidates": [ + {"index": 1, "qa_id": 101, "label": "系统架构那条"}, + {"index": 2, "qa_id": 102, "label": "系统模型那条"}, + ], + } + await db_session.commit() + + resolved = service._consume_pending_clarification_selection( + question="第二条", + session_state=state, + ) + + assert resolved is not None + assert resolved["selected_qa_id"] == 102 + assert resolved["effective_question"] == "我问你这个是哪个模型执行回复的？" + + +@pytest.mark.asyncio +async def test_explicit_reply_to_message_id_resolves_anchor_without_session_history(db_session) -> None: + service = _Harness(db_session) + now = now_cn_naive() + db_session.add( + IngestEvent( + tenant_id=1, + channel="feishu_message", + event_key="om_user_message_1", + status="done", + payload={"message_text": "帮我解释下系统的架构"}, + ) + ) + db_session.add( + FeishuReplyOutbox( + tenant_id=1, + trace_id="trace-1", + source_message_id="om_user_message_1", + sent_message_id="om_bot_reply_1", + chat_id="oc-chat-1", + message_text='林宇航 PMFlow 系统采用前后端分离架构。', + status="sent", + created_at=now - timedelta(minutes=1), + sent_at=now - timedelta(minutes=1), + ) + ) + await db_session.commit() + + resolution = await service._resolve_followup_anchor( + question="这个是哪个模型去回复我问题的？", + session_id=None, + context_session_id=None, + session_state=None, + thread_context={"reply_to_message_id": "om_bot_reply_1"}, + ) + + assert resolution.anchor_mode == "explicit" + assert resolution.is_meta_followup is True + assert resolution.anchor_reply is not None + assert resolution.anchor_reply["question"] == "帮我解释下系统的架构" + assert "前后端分离架构" in resolution.anchor_reply["anchor_reply_preview"] + + +@pytest.mark.asyncio +async def test_explicit_reply_falls_back_to_current_ingest_closure_turns_when_outbox_mapping_missing(db_session) -> None: + service = _Harness(db_session) + db_session.add( + IngestEvent( + tenant_id=1, + channel="feishu_message", + event_key="om_current_message_1", + status="done", + payload={ + "message_text": "这个是哪个模型去回复我问题的？", + "closure_turns": [ + {"role": "user", "text": "帮我解释下系统的架构"}, + {"role": "assistant", "text": "PMFlow 系统采用前后端分离架构。"}, + {"role": "user", "text": "这个是哪个模型去回复我问题的？"}, + ], + }, + ) + ) + await db_session.commit() + + resolution = await service._resolve_followup_anchor( + question="这个是哪个模型去回复我问题的？", + session_id=None, + context_session_id=None, + session_state=None, + source_message_id="om_current_message_1", + thread_context={"reply_to_message_id": "om_unmapped_reply"}, + ) + + assert resolution.anchor_mode == "explicit" + assert resolution.is_meta_followup is True + assert resolution.anchor_reply is not None + assert resolution.anchor_reply["question"] == "帮我解释下系统的架构" + assert "前后端分离架构" in resolution.anchor_reply["anchor_reply_preview"] + + +@pytest.mark.asyncio +async def test_recent_followup_candidates_can_cross_sessions_by_conversation_scope_key(db_session) -> None: + service = _Harness(db_session) + now = now_cn_naive() + previous_session = QASession( + tenant_id=1, + user_id=None, + title="旧会话", + external_conversation_key="feishu:msg-old-1", + started_at=now - timedelta(minutes=2), + last_message_at=now - timedelta(minutes=1), + message_count=1, + ) + current_session = QASession( + tenant_id=1, + user_id=None, + title="新会话", + external_conversation_key="feishu:msg-new-1", + started_at=now, + last_message_at=now, + message_count=1, + ) + db_session.add_all([previous_session, current_session]) + await db_session.flush() + db_session.add( + QARecord( + tenant_id=1, + question="帮我解释下系统架构", + answer="PMFlow 系统采用前后端分离架构。", + sources=[], + intent="question", + domains_used=[], + response_time_ms=10, + asked_by=None, + asked_via="feishu", + project_id=None, + session_id=int(previous_session.id), + turn_index=1, + conversation_scope_key="feishu:chat-1:ou-1", + source_chat_id="chat-1", + source_sender_open_id="ou-1", + source_message_id="om_user_1", + created_at=now - timedelta(minutes=1), + ) + ) + await db_session.commit() + + state = await service._ensure_session_state(session_id=int(current_session.id)) + resolution = await service._resolve_followup_anchor( + question="这个是哪个模型回复的？", + session_id=int(current_session.id), + context_session_id=int(current_session.id), + session_state=state, + conversation_scope_key="feishu:chat-1:ou-1", + source_chat_id="chat-1", + source_sender_open_id="ou-1", + ) + + assert resolution.anchor_mode == "implicit_recent_reply" + assert resolution.anchor_reply_id is not None + assert resolution.anchor_kind == "meta_recent_reply" + assert resolution.anchor_reply is not None + assert resolution.anchor_reply["question"] == "帮我解释下系统架构" + + +@pytest.mark.asyncio +async def test_meta_followup_model_identity_reads_routing_snapshot_and_hides_real_model(db_session) -> None: + service = _Harness(db_session) + now = now_cn_naive() + session = QASession( + tenant_id=1, + user_id=None, + title="系统架构", + external_conversation_key="feishu:chat-1:ou-1", + started_at=now, + last_message_at=now, + message_count=1, + ) + db_session.add(session) + await db_session.flush() + qa = QARecord( + tenant_id=1, + question="帮我解释下系统架构", + answer="PMFlow 系统采用前后端分离架构。", + sources=[], + intent="question", + domains_used=[], + response_time_ms=12, + asked_by=None, + asked_via="feishu", + project_id=None, + session_id=int(session.id), + turn_index=1, + conversation_scope_key="feishu:chat-1:ou-1", + source_chat_id="chat-1", + source_sender_open_id="ou-1", + source_message_id="om_user_1", + routing_snapshot={ + "planned_tier": "low", + "executed_tier": "high", + "route_source": "default", + "route_rule_name": "engine_high_reasoning_glm5", + "routing_decision": "low_to_high_escalated", + "provider": "openai", + "model": "GLM-5", + }, + ) + db_session.add(qa) + await db_session.commit() + + payload = await service._build_meta_followup_payload( + question="这个是哪个模型回复的？", + anchor_resolution=FollowupAnchorResolution( + anchor_mode="implicit_recent_reply", + anchor_reply_id=int(qa.id), + anchor_session_id=int(session.id), + anchor_kind="meta_recent_reply", + is_meta_followup=True, + anchor_reply={ + "qa_id": int(qa.id), + "question": "帮我解释下系统架构", + "anchor_reply_preview": "PMFlow 系统采用前后端分离架构。", + "source_message_id": "om_user_1", + }, + ), + conversation_scope_key="feishu:chat-1:ou-1", + ) + + assert payload is not None + assert payload["meta_followup_kind"] == "reply_model_identity" + assert payload["reason_code"] == "meta_followup_answered" + assert "planned_tier=low" in payload["answer"] + assert "executed_tier=high" in payload["answer"] + assert "engine_high_reasoning_glm5" in payload["answer"] + assert "glm-5" not in payload["answer"].lower() diff --git a/backend/tests/test_ai_pmo_ingress_mainline.py b/backend/tests/test_ai_pmo_ingress_mainline.py index 41285880..1c8b34bc 100644 --- a/backend/tests/test_ai_pmo_ingress_mainline.py +++ b/backend/tests/test_ai_pmo_ingress_mainline.py @@ -18,7 +18,7 @@ from app.services.ai_pmo.ai_pmo_intent import CanonicalIntent from app.services.llm_service import ChatCompletionResult, StructuredExtractionResult from app.services.llm_service import mixin_tier_escalation from app.services.llm_service.mixin_tier_escalation import LLMTierEscalationMixin -from app.utils.thread_context import build_feishu_thread_key +from app.utils.thread_context import build_feishu_conversation_scope_key, build_feishu_thread_key @pytest.mark.asyncio @@ -128,6 +128,8 @@ async def test_prepare_mixed_sidecar_context_passes_mixed_contract(monkeypatch) source_system="pmflow_manual", source_message_id="manual-msg-2", channel_ref="pmflow-chat", + source_sender_open_id="ou-pmflow-1", + thread_context={"reply_to_message_id": "reply-1"}, message_text="顺便问下现在进展如何，并且新增任务确认流", project_hint_id=22, ) @@ -142,6 +144,8 @@ async def test_prepare_mixed_sidecar_context_passes_mixed_contract(monkeypatch) assert answer_kwargs["asked_via"] == "pmflow_manual" assert answer_kwargs["project_id"] is None assert answer_kwargs["message_intent"] == "mixed" + assert answer_kwargs["source_sender_open_id"] == "ou-pmflow-1" + assert answer_kwargs["thread_context"] == {"reply_to_message_id": "reply-1"} assert answer_kwargs["mixed_signal_part"] == "新增任务确认流" assert answer_kwargs["conversation_key"] == "manual-msg-2" @@ -543,7 +547,13 @@ async def test_execute_query_intent_feishu_fallback_uses_thread_key(monkeypatch) monkeypatch.setattr(mixin_execute_query_project, "AdaptiveRAGService", FakeAdaptiveRAGService) executor = FakeExecutor() - intent = SimpleNamespace(project_id=None, metadata={"thread_context": {"root_message_id": "root-1"}}) + intent = SimpleNamespace( + project_id=None, + metadata={ + "thread_context": {"root_message_id": "root-1"}, + "source_sender_open_id": "ou-feishu-99", + }, + ) result = await executor._execute_query_intent( intent=intent, message_text="最近AI行业有什么动态", @@ -558,12 +568,12 @@ async def test_execute_query_intent_feishu_fallback_uses_thread_key(monkeypatch) assert answer_kwargs["asked_by"] is None assert answer_kwargs["asked_via"] == "feishu" assert answer_kwargs["source_chat_id"] is None - assert answer_kwargs["conversation_key"] == build_feishu_thread_key( + assert answer_kwargs["source_sender_open_id"] == "ou-feishu-99" + assert answer_kwargs["thread_context"] == {"root_message_id": "root-1"} + assert answer_kwargs["conversation_key"] == build_feishu_conversation_scope_key( source_chat_id=None, - source_sender_open_id=None, + source_sender_open_id="ou-feishu-99", sender=None, - source_message_id="msg-feishu-1", - thread_context={"root_message_id": "root-1"}, ) diff --git a/backend/tests/test_ai_pmo_task_intent_contract.py b/backend/tests/test_ai_pmo_task_intent_contract.py index b72945a0..08eb396f 100644 --- a/backend/tests/test_ai_pmo_task_intent_contract.py +++ b/backend/tests/test_ai_pmo_task_intent_contract.py @@ -6,6 +6,7 @@ from app.services.ai_pmo.ai_pmo_intent import ( INTENT_TASK_CREATE, ROUTE_ACTION_ANSWER, ROUTE_ACTION_CANCEL, + ROUTE_ACTION_CONTINUE, ROUTE_ACTION_CREATE, ROUTE_FAMILY_QUERY, ROUTE_FAMILY_TASK, @@ -72,11 +73,20 @@ def test_route_resolver_builds_query_answer_route() -> None: assert route.key == ROUTE_QUERY_ANSWER -def test_route_resolver_followup_action_supports_message_text_fallback() -> None: +def test_route_resolver_followup_action_requires_structured_metadata() -> None: action = RouteResolver.parse_followup_action( canonical_intent=INTENT_FOLLOWUP_CONTINUE, message_text="先取消这个工作项", ) + assert action == ROUTE_ACTION_CONTINUE + + +def test_route_resolver_followup_action_allows_message_parsing_with_context() -> None: + action = RouteResolver.parse_followup_action( + canonical_intent=INTENT_FOLLOWUP_CONTINUE, + message_text="先取消这个工作项", + metadata={"followup_context_present": True, "target_work_item_id": 8}, + ) assert action == ROUTE_ACTION_CANCEL diff --git a/backend/tests/test_draft_confirm_handler.py b/backend/tests/test_draft_confirm_handler.py index be8b526e..a0341e86 100644 --- a/backend/tests/test_draft_confirm_handler.py +++ b/backend/tests/test_draft_confirm_handler.py @@ -115,6 +115,54 @@ def test_feishu_reply_llm_core_strips_action_process_prefaces() -> None: assert FeishuReplyLLMCoreMixin._strip_leading_thinking_paragraphs(reply) == "" +def test_feishu_reply_llm_core_action_ack_uses_semantic_bundle_only() -> None: + ack = FeishuReplyLLMCoreMixin._build_action_request_ack_reply( + message_content="随便一句不带动作的话", + capture_result={ + "status": "captured", + "semantic_bundle": { + "bundle_id": "semantic-1", + "semantic_version": "2026-03-27.workflow-v1", + "source_system": "feishu", + "primary_workflow": "new_project_flow", + "workflows": [ + { + "workflow_type": "new_project_flow", + "workflow_action": "create", + "target_scope": "global", + "operation_codes": ["project.create"], + "requires_confirmation": False, + "confidence": 0.9, + "slots": [], + "clarification_needed": False, + "metadata": {}, + }, + { + "workflow_type": "signal_source_flow", + "workflow_action": "onboard", + "target_scope": "global", + "operation_codes": ["signal_source.onboard"], + "requires_confirmation": False, + "confidence": 0.92, + "slots": [], + "clarification_needed": False, + "metadata": {}, + }, + ], + "message_gate": "auto_execute", + "reply_contract": { + "mode": "aggregate_card", + "template_key": "workflow_bundle", + "summary": "new_project_flow", + }, + "diagnostics": {}, + }, + }, + ) + + assert ack == "已收到，项目创建和信号源接入请求已记录。" + + @pytest.mark.asyncio async def test_draft_confirm_handler_repeated_confirm_returns_inbox_success_copy() -> None: class _FakeResult: diff --git a/backend/tests/test_external_qa_followup_migration.py b/backend/tests/test_external_qa_followup_migration.py new file mode 100644 index 00000000..c3ef0dca --- /dev/null +++ b/backend/tests/test_external_qa_followup_migration.py @@ -0,0 +1,96 @@ +from __future__ import annotations + +import importlib.util +from pathlib import Path + +import sqlalchemy as sa +from alembic.migration import MigrationContext +from alembic.operations import Operations + + +def _load_migration_module(): + path = ( + Path(__file__).resolve().parents[1] + / "alembic" + / "versions" + / "20260327_add_external_qa_followup_state.py" + ) + spec = importlib.util.spec_from_file_location("external_qa_followup_state_migration", path) + module = importlib.util.module_from_spec(spec) + assert spec is not None + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +def _create_qa_tables(metadata: sa.MetaData) -> None: + sa.Table( + "qa_sessions", + metadata, + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False), + sa.Column("user_id", sa.BigInteger(), nullable=True), + sa.Column("title", sa.String(length=120), nullable=False), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("started_at", sa.TIMESTAMP(), nullable=True), + sa.Column("last_message_at", sa.TIMESTAMP(), nullable=True), + sa.Column("message_count", sa.Integer(), nullable=False), + ) + sa.Table( + "qa_session_states", + metadata, + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False), + sa.Column("session_id", sa.Integer(), nullable=False), + sa.Column("last_subject", sa.String(length=255), nullable=True), + sa.Column("last_entity_ids", sa.JSON(), nullable=True), + sa.Column("last_intent", sa.String(length=20), nullable=True), + sa.Column("ambiguity", sa.String(length=20), nullable=True), + sa.Column("rewrite_history", sa.JSON(), nullable=True), + ) + + +def test_external_qa_followup_migration_adds_and_removes_columns_and_indexes() -> None: + migration = _load_migration_module() + engine = sa.create_engine("sqlite:///:memory:") + metadata = sa.MetaData() + _create_qa_tables(metadata) + metadata.create_all(engine) + + with engine.begin() as conn: + context = MigrationContext.configure(conn) + migration.op = Operations(context) + migration.upgrade() + + inspector = sa.inspect(conn) + session_columns = {column["name"] for column in inspector.get_columns("qa_sessions")} + state_columns = {column["name"] for column in inspector.get_columns("qa_session_states")} + session_indexes = {index["name"]: index for index in inspector.get_indexes("qa_sessions")} + state_indexes = {index["name"]: index for index in inspector.get_indexes("qa_session_states")} + + assert "external_conversation_key" in session_columns + assert "pending_clarification" in state_columns + assert "pending_clarification_expires_at" in state_columns + assert "ix_qa_sessions_external_conversation_key" in session_indexes + assert "uq_qa_sessions_tenant_external_conversation_key" in session_indexes + assert bool(session_indexes["uq_qa_sessions_tenant_external_conversation_key"]["unique"]) is True + assert "ix_qa_session_states_pending_clarification_expires_at" in state_indexes + + migration.downgrade() + + inspector = sa.inspect(conn) + session_columns = {column["name"] for column in inspector.get_columns("qa_sessions")} + state_columns = {column["name"] for column in inspector.get_columns("qa_session_states")} + session_indexes = {index["name"] for index in inspector.get_indexes("qa_sessions")} + state_indexes = {index["name"] for index in inspector.get_indexes("qa_session_states")} + + assert "external_conversation_key" not in session_columns + assert "pending_clarification" not in state_columns + assert "pending_clarification_expires_at" not in state_columns + assert "ix_qa_sessions_external_conversation_key" not in session_indexes + assert "uq_qa_sessions_tenant_external_conversation_key" not in session_indexes + assert "ix_qa_session_states_pending_clarification_expires_at" not in state_indexes diff --git a/backend/tests/test_feishu_pipeline_queue_contract.py b/backend/tests/test_feishu_pipeline_queue_contract.py index af35af1f..186f566b 100644 --- a/backend/tests/test_feishu_pipeline_queue_contract.py +++ b/backend/tests/test_feishu_pipeline_queue_contract.py @@ -33,6 +33,9 @@ from app.services.integrations.feishu_signal_pipeline.mixin_item_finalize_routin from app.services.integrations.feishu_signal_pipeline.mixin_message_utils_b import ( FeishuPipelineMessageUtilsBMixin, ) +from app.services.integrations.feishu_signal_pipeline.mixin_message_utils_a import ( + FeishuPipelineMessageUtilsAMixin, +) from app.services.integrations.feishu_signal_pipeline.mixin_process_message_helpers_b import ( FeishuPipelineProcessMessageHelpersBMixin, ) @@ -212,6 +215,56 @@ def test_decorate_capture_result_adds_queue_action_card_metadata() -> None: assert result["queue_item_id"] == 301 +def test_rag_conversation_key_uses_stable_scope_without_reply_anchor() -> None: + key = FeishuPipelineMessageUtilsAMixin._build_rag_conversation_key( + source_chat_id="chat-1", + source_sender_open_id="ou-1", + sender="测试用户", + source_message_id="msg-123", + thread_context=None, + ) + + assert key == "feishu:chat-1:ou-1" + + +@pytest.mark.asyncio +async def test_build_direct_qa_capture_exposes_reason_code_and_anchor_kind() -> None: + class _FakeHelpers(FeishuPipelineProcessMessageHelpersBMixin): + def __init__(self) -> None: + self.db = object() + self.tenant_id = 1 + + async def _write_processing_log(self, **kwargs): + _ = kwargs + + def _build_rag_reply_text(self, *, answer: str, sources: list[dict[str, object]]) -> str: + _ = sources + return answer + + helpers = _FakeHelpers() + + capture = await helpers._build_direct_qa_capture( + message="这个是哪个模型回复的？", + rag_result={ + "answer": "这条回复命中的逻辑层是 low。", + "clarification_code": None, + "reason_code": "meta_followup_answered", + "anchor_kind": "meta_recent_reply", + "meta_followup_kind": "reply_model_identity", + "sources": [], + }, + inferred_project_id=None, + feishu_message_id="msg-1", + process_started_at=0.0, + route_reason="direct qa", + intent_label="question", + ) + + assert capture["reason_code"] == "meta_followup_answered" + assert capture["anchor_kind"] == "meta_recent_reply" + assert capture["meta_followup_kind"] == "reply_model_identity" + + @pytest.mark.asyncio async def test_intent_gate_query_does_not_inherit_project_context(monkeypatch) -> None: captured: dict[str, object] = {} @@ -272,6 +325,8 @@ async def test_intent_gate_query_does_not_inherit_project_context(monkeypatch) - assert isinstance(result, dict) assert result["linked_project_ids"] == [] assert captured["answer_kwargs"]["project_id"] is None + assert captured["answer_kwargs"]["source_sender_open_id"] == "ou-1" + assert captured["answer_kwargs"]["thread_context"] == {"reply_to_message_id": "msg-root-1"} @pytest.mark.asyncio diff --git a/backend/tests/test_feishu_receive_orchestration_contract.py b/backend/tests/test_feishu_receive_orchestration_contract.py index a1535db5..29f444d5 100644 --- a/backend/tests/test_feishu_receive_orchestration_contract.py +++ b/backend/tests/test_feishu_receive_orchestration_contract.py @@ -58,7 +58,7 @@ async def test_handle_message_receive_routes_empty_text_branch(monkeypatch) -> N assert called["empty_reply"]["chat_id"] == "chat-empty" -def test_classify_message_scene_prefers_execute_for_action_like_raw_text() -> None: +def test_classify_message_scene_does_not_infer_execute_from_raw_text_only() -> None: scene = FeishuIntegrationService._classify_message_scene( capture_result={ "status": "answered", @@ -68,7 +68,7 @@ def test_classify_message_scene_prefers_execute_for_action_like_raw_text() -> No message_content="帮我创建项目和信号源", ) - assert scene == "execute" + assert scene == "qa" @pytest.mark.asyncio diff --git a/backend/tests/test_qa_record_followup_anchor_migration.py b/backend/tests/test_qa_record_followup_anchor_migration.py new file mode 100644 index 00000000..ee7f7f59 --- /dev/null +++ b/backend/tests/test_qa_record_followup_anchor_migration.py @@ -0,0 +1,92 @@ +from __future__ import annotations + +import importlib.util +from pathlib import Path + +import sqlalchemy as sa +from alembic.migration import MigrationContext +from alembic.operations import Operations + + +def _load_migration_module(): + path = ( + Path(__file__).resolve().parents[1] + / "alembic" + / "versions" + / "20260327_add_qa_record_followup_anchor_fields.py" + ) + spec = importlib.util.spec_from_file_location("qa_record_followup_anchor_migration", path) + module = importlib.util.module_from_spec(spec) + assert spec is not None + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +def _create_qa_record_table(metadata: sa.MetaData) -> None: + sa.Table( + "qa_records", + metadata, + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False), + sa.Column("question", sa.Text(), nullable=False), + sa.Column("answer", sa.Text(), nullable=False), + sa.Column("sources", sa.JSON(), nullable=True), + sa.Column("intent", sa.String(length=20), nullable=False), + sa.Column("domains_used", sa.JSON(), nullable=True), + sa.Column("response_time_ms", sa.Integer(), nullable=True), + sa.Column("asked_by", sa.BigInteger(), nullable=True), + sa.Column("asked_via", sa.String(length=20), nullable=False), + sa.Column("project_id", sa.BigInteger(), nullable=True), + sa.Column("session_id", sa.Integer(), nullable=True), + sa.Column("turn_index", sa.Integer(), nullable=False), + ) + + +def test_qa_record_followup_anchor_migration_adds_and_removes_columns_and_indexes() -> None: + migration = _load_migration_module() + engine = sa.create_engine("sqlite:///:memory:") + metadata = sa.MetaData() + _create_qa_record_table(metadata) + metadata.create_all(engine) + + with engine.begin() as conn: + context = MigrationContext.configure(conn) + migration.op = Operations(context) + migration.upgrade() + + inspector = sa.inspect(conn) + record_columns = {column["name"] for column in inspector.get_columns("qa_records")} + record_indexes = {index["name"] for index in inspector.get_indexes("qa_records")} + + assert "source_message_id" in record_columns + assert "source_chat_id" in record_columns + assert "source_sender_open_id" in record_columns + assert "reply_to_message_id" in record_columns + assert "root_message_id" in record_columns + assert "conversation_scope_key" in record_columns + assert "anchor_kind" in record_columns + assert "anchor_ref" in record_columns + assert "routing_snapshot" in record_columns + assert "ix_qa_records_source_message_id" in record_indexes + assert "ix_qa_records_conversation_scope_key" in record_indexes + + migration.downgrade() + + inspector = sa.inspect(conn) + record_columns = {column["name"] for column in inspector.get_columns("qa_records")} + record_indexes = {index["name"] for index in inspector.get_indexes("qa_records")} + + assert "source_message_id" not in record_columns + assert "source_chat_id" not in record_columns + assert "source_sender_open_id" not in record_columns + assert "reply_to_message_id" not in record_columns + assert "root_message_id" not in record_columns + assert "conversation_scope_key" not in record_columns + assert "anchor_kind" not in record_columns + assert "anchor_ref" not in record_columns + assert "routing_snapshot" not in record_columns + assert "ix_qa_records_source_message_id" not in record_indexes + assert "ix_qa_records_conversation_scope_key" not in record_indexes diff --git a/backend/tests/test_reply_iteration_api.py b/backend/tests/test_reply_iteration_api.py new file mode 100644 index 00000000..03792b21 --- /dev/null +++ b/backend/tests/test_reply_iteration_api.py @@ -0,0 +1,283 @@ +from __future__ import annotations + +import os +from types import SimpleNamespace + +import pytest +import pytest_asyncio +from fastapi import FastAPI +from httpx import ASGITransport, AsyncClient +from sqlalchemy import JSON +from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine + +os.environ["DATABASE_URL"] = "postgresql+asyncpg://tester:tester@localhost:5432/pmflow_test" + +from app.api.ai_steward_api import routes_feedback_center, routes_reply_iteration, routes_training_pipeline +from app.core.database import get_db +from app.dependencies.auth import get_current_user +from app.dependencies.tenant import get_tenant_id +from app.models.base import Base +from app.models.experiment import Experiment +from app.models.feedback_center import FeedbackCenterRecord +from app.models.qa_record import QARecord +from app.models.reply_iteration import ( + JudgeRun, + OptimizerCandidate, + PromptRelease, + QualityAsset, + QualityAssetPair, +) +from app.models.training_pipeline import ( + TrainedModelArtifact, + TrainedModelDeployment, + TrainingDataset, + TrainingDatasetItem, + TrainingEvaluation, + TrainingJob, + TrainingJobRun, +) + + +def _use_sqlite_json_types() -> None: + for table in ( + FeedbackCenterRecord.__table__, + QARecord.__table__, + QualityAsset.__table__, + QualityAssetPair.__table__, + JudgeRun.__table__, + OptimizerCandidate.__table__, + PromptRelease.__table__, + Experiment.__table__, + TrainingDataset.__table__, + TrainingDatasetItem.__table__, + TrainingJob.__table__, + TrainingJobRun.__table__, + TrainingEvaluation.__table__, + TrainedModelArtifact.__table__, + TrainedModelDeployment.__table__, + ): + for column in table.columns: + if column.name in { + "before_value", + "after_value", + "ai_snapshot", + "reason_candidates", + "sources", + "domains_used", + "routing_snapshot", + "evidence", + "source_snapshot", + "tags", + "metadata_json", + "findings", + "llm_evidence", + "suggestion", + "scope_json", + "linked_context_nodes", + "result_summary", + "selection_rules", + "channel_scope", + "redacted_snapshot", + "metrics_json", + "evaluation_summary", + "effective_scope", + }: + column.type = JSON() + + +@pytest_asyncio.fixture +async def db_session(): + engine = create_async_engine("sqlite+aiosqlite:///:memory:") + _use_sqlite_json_types() + async with engine.begin() as conn: + await conn.run_sync( + lambda sync_conn: Base.metadata.create_all( + sync_conn, + tables=[ + FeedbackCenterRecord.__table__, + QARecord.__table__, + QualityAsset.__table__, + QualityAssetPair.__table__, + JudgeRun.__table__, + OptimizerCandidate.__table__, + PromptRelease.__table__, + Experiment.__table__, + TrainingDataset.__table__, + TrainingDatasetItem.__table__, + TrainingJob.__table__, + TrainingJobRun.__table__, + TrainingEvaluation.__table__, + TrainedModelArtifact.__table__, + TrainedModelDeployment.__table__, + ], + ) + ) + maker = async_sessionmaker(engine, expire_on_commit=False) + async with maker() as session: + yield session + await engine.dispose() + + +def _build_app(db_session): + app = FastAPI() + app.include_router(routes_feedback_center.router) + app.include_router(routes_reply_iteration.router) + app.include_router(routes_training_pipeline.router) + + async def _fake_get_db(): + yield db_session + + app.dependency_overrides[get_db] = _fake_get_db + app.dependency_overrides[get_tenant_id] = lambda: 1 + app.dependency_overrides[get_current_user] = lambda: SimpleNamespace( + id=9001, + tenant_id=1, + role="ADMIN", + name="管理员", + username="admin", + ) + return app + + +@pytest.mark.asyncio +async def test_reply_iteration_and_training_admin_routes(db_session) -> None: + qa_record = QARecord( + tenant_id=1, + question="这个回复为什么不对", + answer="让我先看一下。", + sources=[], + intent="question", + domains_used=[], + asked_via="feishu", + project_id=7, + turn_index=1, + routing_snapshot={ + "planned_tier": "low", + "executed_tier": "high", + "route_source": "default", + "route_rule_name": "engine_high_answer", + }, + ) + db_session.add(qa_record) + await db_session.flush() + feedback = FeedbackCenterRecord( + tenant_id=1, + project_id=7, + source_type="qa_feedback", + source_id=501, + object_type="qa_record", + object_id=qa_record.id, + field_name="qa_feedback", + before_value={"question": qa_record.question, "answer": qa_record.answer}, + after_value={"rating": "negative", "correct_answer": "这条回复实际走的是 high。"}, + ai_snapshot={"prompt_key": "PROMPT_FEISHU_DIRECT_QA"}, + review_status="accepted", + ) + db_session.add(feedback) + await db_session.commit() + + app = _build_app(db_session) + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as client: + promote_resp = await client.post( + f"/ai-steward/feedback-center/items/{feedback.id}/promote", + json={ + "asset_type": "failure", + "prompt_key": "PROMPT_FEISHU_DIRECT_QA", + "workflow_type": "query.read_only", + }, + ) + assert promote_resp.status_code == 200 + asset_id = promote_resp.json()["data"]["asset"]["id"] + + judge_resp = await client.post( + "/ai-steward/reply-iteration/judge-runs", + json={"asset_id": asset_id}, + ) + assert judge_resp.status_code == 200 + judge_id = judge_resp.json()["data"]["id"] + + candidate_resp = await client.post( + "/ai-steward/reply-iteration/candidates", + json={"judge_run_id": judge_id}, + ) + assert candidate_resp.status_code == 200 + + release_resp = await client.post( + "/ai-steward/reply-iteration/prompt-releases", + json={ + "prompt_key": "PROMPT_FEISHU_DIRECT_QA", + "body_snapshot": "【试验版】{question}", + "notes": "试验候选", + }, + ) + assert release_resp.status_code == 200 + candidate_release_id = release_resp.json()["data"]["id"] + + activate_resp = await client.post( + f"/ai-steward/reply-iteration/prompt-releases/{candidate_release_id}/activate", + ) + assert activate_resp.status_code == 200 + + trial_resp = await client.post( + "/ai-steward/reply-iteration/trials", + json={ + "title": "回复质量试验", + "hypothesis": "试验 prompt 能减少过程话术", + "target_metric": "accepted_rate", + "prompt_key": "PROMPT_FEISHU_DIRECT_QA", + "baseline_release_id": candidate_release_id, + "candidate_release_id": candidate_release_id, + "scope_json": {"asked_via": ["feishu"]}, + }, + ) + assert trial_resp.status_code == 200 + trial_id = trial_resp.json()["data"]["id"] + + trial_decision_resp = await client.post( + f"/ai-steward/reply-iteration/trials/{trial_id}/decision", + json={"decision": "accepted", "result_summary": {"accepted_rate": 0.91}}, + ) + assert trial_decision_resp.status_code == 200 + + dataset_resp = await client.post( + "/ai-steward/training/datasets", + json={ + "dataset_type": "eval", + "version": "eval-v1", + "asset_ids": [asset_id], + "pair_ids": [], + "selection_rules": {"scope": "reply_iteration"}, + "notes": "评测集", + }, + ) + assert dataset_resp.status_code == 200 + dataset_id = dataset_resp.json()["data"]["id"] + + job_resp = await client.post( + "/ai-steward/training/jobs", + json={ + "dataset_id": dataset_id, + "job_type": "sft", + "base_model_family": "glm", + "target_slot": "high", + "provider_backend": "openclaw-training", + }, + ) + assert job_resp.status_code == 200 + job_id = job_resp.json()["data"]["id"] + artifact_id = job_resp.json()["data"]["artifact"]["id"] + + eval_resp = await client.get(f"/ai-steward/training/jobs/{job_id}/evaluations") + promote_artifact_resp = await client.post(f"/ai-steward/training/artifacts/{artifact_id}/promote") + deployment_id = promote_artifact_resp.json()["data"]["id"] + deployment_decision_resp = await client.post( + f"/ai-steward/training/deployments/{deployment_id}/decision", + json={"decision": "accepted", "notes": "允许候选部署"}, + ) + + assert judge_resp.json()["code"] == 0 + assert candidate_resp.json()["data"]["status"] == "draft" + assert trial_decision_resp.json()["data"]["decision"] == "accepted" + assert eval_resp.json()["data"]["items"] + assert deployment_decision_resp.json()["data"]["deployment_status"] == "active" diff --git a/backend/tests/test_reply_iteration_service.py b/backend/tests/test_reply_iteration_service.py new file mode 100644 index 00000000..bceb58b6 --- /dev/null +++ b/backend/tests/test_reply_iteration_service.py @@ -0,0 +1,253 @@ +from __future__ import annotations + +import os + +import pytest +import pytest_asyncio +from sqlalchemy import JSON +from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine + +os.environ["DATABASE_URL"] = "sqlite+aiosqlite:///:memory:" + +from app.models.base import Base +from app.models.experiment import Experiment +from app.models.feedback_center import FeedbackCenterRecord +from app.models.qa_record import QARecord +from app.models.reply_iteration import ( + JudgeRun, + OptimizerCandidate, + PromptRelease, + QualityAsset, + QualityAssetPair, +) +from app.services.prompt_release.service import PromptReleaseService +from app.services.reply_iteration.service import ReplyIterationService + + +def _use_sqlite_json_types() -> None: + for table in ( + FeedbackCenterRecord.__table__, + QARecord.__table__, + QualityAsset.__table__, + QualityAssetPair.__table__, + JudgeRun.__table__, + OptimizerCandidate.__table__, + PromptRelease.__table__, + Experiment.__table__, + ): + for column in table.columns: + if column.name in { + "before_value", + "after_value", + "ai_snapshot", + "reason_candidates", + "sources", + "domains_used", + "routing_snapshot", + "evidence", + "source_snapshot", + "tags", + "metadata_json", + "findings", + "llm_evidence", + "suggestion", + "scope_json", + "linked_context_nodes", + "result_summary", + }: + column.type = JSON() + + +@pytest_asyncio.fixture +async def db_session(): + engine = create_async_engine("sqlite+aiosqlite:///:memory:") + _use_sqlite_json_types() + async with engine.begin() as conn: + await conn.run_sync( + lambda sync_conn: Base.metadata.create_all( + sync_conn, + tables=[ + FeedbackCenterRecord.__table__, + QARecord.__table__, + QualityAsset.__table__, + QualityAssetPair.__table__, + JudgeRun.__table__, + OptimizerCandidate.__table__, + PromptRelease.__table__, + Experiment.__table__, + ], + ) + ) + maker = async_sessionmaker(engine, expire_on_commit=False) + async with maker() as session: + yield session + await engine.dispose() + + +@pytest.mark.asyncio +async def test_promote_feedback_record_builds_asset_and_preference_pair(db_session) -> None: + qa_record = QARecord( + tenant_id=1, + question="这个回复为什么不对", + answer="让我先看一下你的情况，再帮你判断。", + sources=[], + intent="question", + domains_used=[], + response_time_ms=120, + asked_by=None, + asked_via="feishu", + project_id=8, + turn_index=1, + routing_snapshot={ + "planned_tier": "low", + "executed_tier": "high", + "route_source": "default", + "route_rule_name": "engine_high_answer", + }, + ) + db_session.add(qa_record) + await db_session.flush() + + failure_record = FeedbackCenterRecord( + tenant_id=1, + project_id=8, + source_type="qa_feedback", + source_id=101, + object_type="qa_record", + object_id=qa_record.id, + field_name="qa_feedback", + source_title="飞书问答反馈", + object_title="问答修正", + before_value={"question": qa_record.question, "answer": qa_record.answer}, + after_value={"rating": "negative", "correct_answer": "上一条回复走的是 high 路由。"}, + ai_snapshot={"prompt_key": "PROMPT_FEISHU_DIRECT_QA"}, + reason_code="answer_incorrect", + review_status="accepted", + ) + golden_record = FeedbackCenterRecord( + tenant_id=1, + project_id=8, + source_type="qa_feedback", + source_id=102, + object_type="qa_record", + object_id=qa_record.id, + field_name="qa_feedback", + source_title="飞书问答反馈", + object_title="问答修正", + before_value={"question": qa_record.question, "answer": qa_record.answer}, + after_value={"rating": "positive", "correct_answer": "这条回复实际走的是 high，来源于默认规则。"}, + ai_snapshot={"prompt_key": "PROMPT_FEISHU_DIRECT_QA"}, + reason_code="answer_incorrect", + review_status="accepted", + ) + db_session.add_all([failure_record, golden_record]) + await db_session.commit() + + service = ReplyIterationService(db_session) + failure_result = await service.promote_feedback_record( + tenant_id=1, + record_id=failure_record.id, + actor_id=9001, + asset_type="failure", + prompt_key="PROMPT_FEISHU_DIRECT_QA", + workflow_type="query.read_only", + ) + golden_result = await service.promote_feedback_record( + tenant_id=1, + record_id=golden_record.id, + actor_id=9001, + asset_type="golden", + prompt_key="PROMPT_FEISHU_DIRECT_QA", + workflow_type="query.read_only", + pair_with_asset_id=failure_result["asset"]["id"], + pair_role="chosen", + pair_reason="人工确认修正版明显优于原答复", + ) + + assert failure_result["asset"]["asset_type"] == "failure" + assert failure_result["asset"]["qa_record_id"] == qa_record.id + assert failure_result["asset"]["planned_tier"] == "low" + assert failure_result["asset"]["executed_tier"] == "high" + assert failure_result["asset"]["route_rule_name"] == "engine_high_answer" + assert failure_result["pair"] is None + + assert golden_result["asset"]["asset_type"] == "golden" + assert golden_result["pair"] is not None + assert golden_result["pair"]["chosen_asset_id"] == golden_result["asset"]["id"] + assert golden_result["pair"]["rejected_asset_id"] == failure_result["asset"]["id"] + + +@pytest.mark.asyncio +async def test_judge_run_and_optimizer_candidate_follow_bucket_rules(db_session) -> None: + asset = QualityAsset( + tenant_id=1, + project_id=3, + asset_type="failure", + status="approved", + prompt_key="PROMPT_FEISHU_DIRECT_QA", + workflow_type="query.read_only", + asked_via="feishu", + planned_tier="low", + executed_tier="low", + route_rule_name="engine_low_fallback", + question_text="这个回复为什么不对", + answer_text="让我先看一下，再通过 API 帮你创建。", + corrected_answer="直接说明这条回复走的是 low，并给出路由来源。", + source_snapshot={"reason_code": "answer_incorrect"}, + ) + db_session.add(asset) + await db_session.commit() + + service = ReplyIterationService(db_session) + judge = await service.create_judge_run( + tenant_id=1, + asset_id=asset.id, + actor_id=9001, + ) + candidate = await service.create_optimizer_candidate( + tenant_id=1, + judge_run_id=judge["id"], + actor_id=9001, + ) + + assert judge["bucket_key"] == "PROMPT_FEISHU_DIRECT_QA|query.read_only|feishu|low|low" + finding_codes = {item["code"] for item in judge["findings"]} + assert "process_talk_prefix" in finding_codes + assert "execution_claim_prefix" in finding_codes + assert candidate["target_type"] == "renderer_policy" + assert candidate["status"] == "draft" + assert candidate["target_ref"] == "reply_renderer" + + +@pytest.mark.asyncio +async def test_prompt_release_service_prefers_active_release_and_falls_back_on_format_error(db_session) -> None: + service = PromptReleaseService(db_session) + release = await service.create_release( + tenant_id=1, + prompt_key="PROMPT_FEISHU_DIRECT_QA", + body_snapshot="【定制版】问题：{question}", + created_by=9001, + notes="定制回复语气", + ) + await service.activate_release( + tenant_id=1, + release_id=release["id"], + actor_id=9001, + ) + + rendered = await service.render_prompt( + tenant_id=1, + prompt_key="PROMPT_FEISHU_DIRECT_QA", + fallback_template="默认：{question}", + question="系统现在走哪个 tier", + ) + broken = await service.render_prompt( + tenant_id=1, + prompt_key="PROMPT_FEISHU_DIRECT_QA", + fallback_template="默认：{question}", + question="系统现在走哪个 tier", + _override_template="坏模板：{missing_key}", + ) + + assert rendered == "【定制版】问题：系统现在走哪个 tier" + assert broken == "默认：系统现在走哪个 tier" diff --git a/backend/tests/test_reply_iteration_training_migration.py b/backend/tests/test_reply_iteration_training_migration.py new file mode 100644 index 00000000..0bd16cce --- /dev/null +++ b/backend/tests/test_reply_iteration_training_migration.py @@ -0,0 +1,104 @@ +from __future__ import annotations + +import importlib.util +from pathlib import Path + +import sqlalchemy as sa +from alembic.migration import MigrationContext +from alembic.operations import Operations + + +def _load_migration_module(): + path = ( + Path(__file__).resolve().parents[1] + / "alembic" + / "versions" + / "20260327_add_reply_iteration_training_tables.py" + ) + spec = importlib.util.spec_from_file_location("reply_iteration_training_tables_migration", path) + module = importlib.util.module_from_spec(spec) + assert spec is not None + assert spec.loader is not None + spec.loader.exec_module(module) + return module + + +def _create_base_tables(metadata: sa.MetaData) -> None: + sa.Table( + "feedback_center_records", + metadata, + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False), + ) + sa.Table( + "qa_records", + metadata, + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False), + ) + sa.Table( + "experiments", + metadata, + sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True), + sa.Column("tenant_id", sa.BigInteger(), nullable=False), + sa.Column("created_at", sa.TIMESTAMP(), nullable=False), + sa.Column("updated_at", sa.TIMESTAMP(), nullable=False), + sa.Column("title", sa.String(length=255), nullable=True), + sa.Column("hypothesis", sa.Text(), nullable=True), + sa.Column("status", sa.String(length=50), nullable=False), + sa.Column("target_metric", sa.String(length=50), nullable=True), + sa.Column("current_score", sa.Float(), nullable=True), + sa.Column("linked_context_nodes", sa.JSON(), nullable=True), + sa.Column("project_id", sa.BigInteger(), nullable=True), + ) + + +def test_reply_iteration_training_migration_adds_tables_and_experiment_columns() -> None: + migration = _load_migration_module() + engine = sa.create_engine("sqlite:///:memory:") + metadata = sa.MetaData() + _create_base_tables(metadata) + metadata.create_all(engine) + + with engine.begin() as conn: + context = MigrationContext.configure(conn) + migration.op = Operations(context) + migration.upgrade() + + inspector = sa.inspect(conn) + tables = set(inspector.get_table_names()) + experiment_columns = {column["name"] for column in inspector.get_columns("experiments")} + + assert "quality_assets" in tables + assert "quality_asset_pairs" in tables + assert "judge_runs" in tables + assert "optimizer_candidates" in tables + assert "prompt_releases" in tables + assert "training_datasets" in tables + assert "training_dataset_items" in tables + assert "training_jobs" in tables + assert "training_job_runs" in tables + assert "training_evaluations" in tables + assert "trained_model_artifacts" in tables + assert "trained_model_deployments" in tables + assert "experiment_type" in experiment_columns + assert "baseline_release_id" in experiment_columns + assert "candidate_release_id" in experiment_columns + assert "scope_json" in experiment_columns + assert "result_summary" in experiment_columns + assert "decision" in experiment_columns + + migration.downgrade() + + inspector = sa.inspect(conn) + tables = set(inspector.get_table_names()) + experiment_columns = {column["name"] for column in inspector.get_columns("experiments")} + + assert "quality_assets" not in tables + assert "training_jobs" not in tables + assert "experiment_type" not in experiment_columns + assert "baseline_release_id" not in experiment_columns diff --git a/backend/tests/test_semantic_lint.py b/backend/tests/test_semantic_lint.py new file mode 100644 index 00000000..a21e48de --- /dev/null +++ b/backend/tests/test_semantic_lint.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +import importlib.util +from pathlib import Path +import sys + + +def _load_semantic_lint_module(): + repo_root = Path(__file__).resolve().parents[2] + module_path = repo_root / "scripts" / "semantic_lint.py" + spec = importlib.util.spec_from_file_location("semantic_lint", module_path) + assert spec is not None and spec.loader is not None + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def test_semantic_lint_flags_new_scattered_hint_tables(tmp_path) -> None: + module = _load_semantic_lint_module() + target = tmp_path / "backend" / "app" / "services" / "integrations" / "foo.py" + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text('PROJECT_CREATE_HINTS = ("创建项目",)\\n', encoding="utf-8") + + problems = module.collect_problems( + root=tmp_path, + scan_roots=(Path("backend/app/services/integrations"),), + baseline_path=Path("scripts/semantic_lint_baseline.txt"), + ) + + assert len(problems) == 1 + assert problems[0].rule_id == "semantic_hint_constant" + + +def test_semantic_lint_allows_workflow_semantic_planner_directory(tmp_path) -> None: + module = _load_semantic_lint_module() + target = tmp_path / "backend" / "app" / "services" / "ai_pmo" / "workflow_semantic_planner" / "foo.py" + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text('PROJECT_CREATE_HINTS = ("创建项目",)\\n', encoding="utf-8") + + problems = module.collect_problems( + root=tmp_path, + scan_roots=(Path("backend/app/services/ai_pmo"),), + baseline_path=Path("scripts/semantic_lint_baseline.txt"), + ) + + assert problems == [] diff --git a/backend/tests/test_training_pipeline_service.py b/backend/tests/test_training_pipeline_service.py new file mode 100644 index 00000000..14aa4e5e --- /dev/null +++ b/backend/tests/test_training_pipeline_service.py @@ -0,0 +1,196 @@ +from __future__ import annotations + +import os + +import pytest +import pytest_asyncio +from sqlalchemy import JSON +from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine + +os.environ["DATABASE_URL"] = "sqlite+aiosqlite:///:memory:" + +from app.models.base import Base +from app.models.reply_iteration import QualityAsset, QualityAssetPair +from app.models.training_pipeline import ( + TrainedModelArtifact, + TrainedModelDeployment, + TrainingDataset, + TrainingDatasetItem, + TrainingEvaluation, + TrainingJob, + TrainingJobRun, +) +from app.services.training_pipeline.service import TrainingPipelineService + + +def _use_sqlite_json_types() -> None: + for table in ( + QualityAsset.__table__, + QualityAssetPair.__table__, + TrainingDataset.__table__, + TrainingDatasetItem.__table__, + TrainingJob.__table__, + TrainingJobRun.__table__, + TrainingEvaluation.__table__, + TrainedModelArtifact.__table__, + TrainedModelDeployment.__table__, + ): + for column in table.columns: + if column.name in { + "source_snapshot", + "tags", + "selection_rules", + "channel_scope", + "redacted_snapshot", + "metrics_json", + "scope_json", + "evaluation_summary", + "effective_scope", + }: + column.type = JSON() + + +@pytest_asyncio.fixture +async def db_session(): + engine = create_async_engine("sqlite+aiosqlite:///:memory:") + _use_sqlite_json_types() + async with engine.begin() as conn: + await conn.run_sync( + lambda sync_conn: Base.metadata.create_all( + sync_conn, + tables=[ + QualityAsset.__table__, + QualityAssetPair.__table__, + TrainingDataset.__table__, + TrainingDatasetItem.__table__, + TrainingJob.__table__, + TrainingJobRun.__table__, + TrainingEvaluation.__table__, + TrainedModelArtifact.__table__, + TrainedModelDeployment.__table__, + ], + ) + ) + maker = async_sessionmaker(engine, expire_on_commit=False) + async with maker() as session: + yield session + await engine.dispose() + + +@pytest.mark.asyncio +async def test_training_dataset_rules_and_job_bootstrap(db_session) -> None: + golden = QualityAsset( + tenant_id=1, + project_id=8, + asset_type="golden", + status="approved", + prompt_key="PROMPT_FEISHU_DIRECT_QA", + workflow_type="query.read_only", + asked_via="feishu", + question_text="现在系统走哪个层级", + answer_text="当前走 high。", + corrected_answer="当前走 high。", + source_snapshot={"approved": True}, + ) + failure = QualityAsset( + tenant_id=1, + project_id=8, + asset_type="failure", + status="approved", + prompt_key="PROMPT_FEISHU_DIRECT_QA", + workflow_type="query.read_only", + asked_via="feishu", + question_text="这个回复为什么不对", + answer_text="让我先看看。", + corrected_answer="直接回答路由层级和原因。", + source_snapshot={"approved": True}, + ) + db_session.add_all([golden, failure]) + await db_session.flush() + + pair = QualityAssetPair( + tenant_id=1, + project_id=8, + pair_type="preference", + status="approved", + chosen_asset_id=golden.id, + rejected_asset_id=failure.id, + reason_text="黄金样本明显更符合产品要求", + ) + db_session.add(pair) + await db_session.commit() + + service = TrainingPipelineService(db_session) + sft_dataset = await service.create_dataset( + tenant_id=1, + actor_id=9001, + dataset_type="sft", + version="sft-v1", + asset_ids=[golden.id], + pair_ids=[], + selection_rules={"source": "manual"}, + notes="SFT 首批数据集", + ) + preference_dataset = await service.create_dataset( + tenant_id=1, + actor_id=9001, + dataset_type="preference", + version="pref-v1", + asset_ids=[], + pair_ids=[pair.id], + selection_rules={"source": "manual"}, + notes="偏好对首批数据集", + ) + + assert sft_dataset["dataset_type"] == "sft" + assert sft_dataset["sample_count"] == 1 + assert preference_dataset["dataset_type"] == "preference" + assert preference_dataset["sample_count"] == 1 + + with pytest.raises(ValueError, match="SFT dataset only accepts approved golden assets"): + await service.create_dataset( + tenant_id=1, + actor_id=9001, + dataset_type="sft", + version="sft-v2", + asset_ids=[failure.id], + pair_ids=[], + selection_rules={"source": "manual"}, + notes="invalid", + ) + + job = await service.create_job( + tenant_id=1, + actor_id=9001, + dataset_id=sft_dataset["id"], + job_type="sft", + base_model_family="glm", + target_slot="high", + provider_backend="openclaw-training", + ) + evaluations = await service.list_evaluations( + tenant_id=1, + job_id=job["id"], + ) + promoted = await service.promote_artifact( + tenant_id=1, + artifact_id=job["artifact"]["id"], + actor_id=9001, + ) + decided = await service.decide_deployment( + tenant_id=1, + deployment_id=promoted["id"], + actor_id=9001, + decision="accepted", + notes="评测通过，允许候选部署", + ) + + assert job["status"] == "queued" + assert job["artifact"]["target_slot"] == "high" + assert {item["evaluation_type"] for item in evaluations["items"]} == { + "offline_judge", + "structure_compliance", + "shadow_replay", + } + assert promoted["deployment_status"] == "candidate" + assert decided["deployment_status"] == "active" diff --git a/backend/tests/test_workflow_semantic_planner.py b/backend/tests/test_workflow_semantic_planner.py new file mode 100644 index 00000000..0d7c55f9 --- /dev/null +++ b/backend/tests/test_workflow_semantic_planner.py @@ -0,0 +1,44 @@ +import pytest + +from app.services.ai_pmo.workflow_semantic_planner import ( + WorkflowSemanticPlanner, +) + + +def test_workflow_semantic_planner_builds_multi_workflow_bundle() -> None: + bundle = WorkflowSemanticPlanner.plan_message( + message_text="帮我创建一个项目，并把这个需求接入信号源", + source_system="feishu", + ) + + workflow_types = [item.workflow_type for item in bundle.workflows] + + assert bundle.source_system == "feishu" + assert bundle.primary_workflow == "new_project_flow" + assert workflow_types == ["new_project_flow", "signal_source_flow"] + assert bundle.reply_contract.mode == "aggregate_card" + + +def test_workflow_semantic_planner_derives_query_bundle() -> None: + bundle = WorkflowSemanticPlanner.plan_message( + message_text="现在项目进展怎么样？", + source_system="pmflow_manual", + ) + + assert bundle.primary_workflow == "query_flow" + assert [item.workflow_type for item in bundle.workflows] == ["query_flow"] + assert bundle.message_gate == "auto_execute" + + +def test_workflow_semantic_planner_helpers_cover_legacy_entry_semantics() -> None: + assert WorkflowSemanticPlanner.looks_like_project_lookup_question("现在有哪些项目？") is True + assert WorkflowSemanticPlanner.extract_project_lookup_keyword("请问项目 智能风控平台 有吗？") == "智能风控平台" + assert WorkflowSemanticPlanner.is_legacy_business_command("把项目状态改成已完成") is True + assert WorkflowSemanticPlanner.is_legacy_business_command("项目现在状态怎么样？") is False + assert WorkflowSemanticPlanner.wants_followup_continue("继续处理刚才那个") is True + assert WorkflowSemanticPlanner.wants_followup_status("它现在怎么样了？") is True + + +def test_workflow_semantic_planner_contextual_write_confirmation_is_stateful() -> None: + assert WorkflowSemanticPlanner.looks_like_contextual_write_confirmation("那就按这个继续执行") is True + assert WorkflowSemanticPlanner.looks_like_contextual_write_confirmation("这个项目现在怎么样？") is False diff --git a/scripts/semantic_lint.py b/scripts/semantic_lint.py new file mode 100644 index 00000000..5659b49d --- /dev/null +++ b/scripts/semantic_lint.py @@ -0,0 +1,195 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import sys +from dataclasses import dataclass +from pathlib import Path +import re +from typing import Iterable, Sequence + + +ROOT = Path(__file__).resolve().parents[1] +DEFAULT_SCAN_ROOTS = ( + Path("backend/app/services/ai_pmo"), + Path("backend/app/services/integrations"), + Path("backend/app/services/signal"), + Path("backend/app/api/ai_pmo_api"), +) +ALLOWLIST_PREFIXES = ( + Path("backend/app/services/ai_pmo/workflow_semantic_planner"), + Path("backend/app/config/ai_prompt_registry.py"), + Path("backend/app/config/ai_prompts.py"), + Path("backend/app/config/ai_prompts_catalog"), + Path("backend/app/config/operation_catalog_core"), + Path("backend/app/services/ai_pmo/ai_pmo_kernel_world_model_core/mixin_project.py"), + Path("backend/app/services/signal/signal_source_orchestration/mixin_planning_locator_roles.py"), + Path("backend/app/services/signal/signal_source_orchestration/mixin_planning_onboard.py"), + Path("backend/app/services/signal/signal_capture_service/mixin_analysis_normalize.py"), + Path("backend/app/services/signal/symbol_index/shared.py"), + Path("backend/app/services/integrations/feishu_integration_service/mixin_message_payload.py"), +) +DEFAULT_BASELINE = Path("scripts/semantic_lint_baseline.txt") + + +@dataclass(frozen=True) +class Problem: + path: str + line: int + rule_id: str + excerpt: str + + def key(self) -> str: + return f"{self.path}:{self.line}:{self.rule_id}" + + +@dataclass(frozen=True) +class Rule: + rule_id: str + pattern: re.Pattern[str] + message: str + + +RULES: tuple[Rule, ...] = ( + Rule( + rule_id="semantic_hint_constant", + pattern=re.compile(r"\b[A-Z][A-Z0-9_]*(?:HINTS|KEYWORDS)\b\s*="), + message="semantic hint/keyword table should live in workflow_semantic_planner or prompt/catalog config", + ), + Rule( + rule_id="semantic_regex_constant", + pattern=re.compile( + r"\b[A-Z][A-Z0-9_]*(?:PROJECT|TASK|SIGNAL|FOLLOWUP|COMMAND|QUERY|SOURCE|INTENT|EXTERNAL|CORRECTION)[A-Z0-9_]*_RE\b\s*=\s*re\.compile" + ), + message="business routing regex should live in workflow_semantic_planner", + ), + Rule( + rule_id="looks_like_helper", + pattern=re.compile( + r"def\s+_?looks_like_(?:project|task|signal|followup|query|command|external|contextual|write|source|intent)[A-Za-z0-9_]*\s*\(" + ), + message="behavior-routing looks_like helper should live in workflow_semantic_planner", + ), + Rule( + rule_id="question_routing_helper", + pattern=re.compile(r"def\s+_is_(?:query_like_question|obvious_question)\s*\("), + message="question routing helper should live in workflow_semantic_planner", + ), +) + + +def _normalize_relpath(root: Path, path: Path) -> str: + return path.resolve().relative_to(root.resolve()).as_posix() + + +def _is_allowlisted(relpath: str) -> bool: + relative = Path(relpath) + for prefix in ALLOWLIST_PREFIXES: + if relative == prefix or prefix in relative.parents: + return True + return False + + +def _iter_files(root: Path, scan_roots: Sequence[Path]) -> Iterable[Path]: + for rel_root in scan_roots: + candidate = (root / rel_root).resolve() + if not candidate.exists(): + continue + if candidate.is_file(): + yield candidate + continue + for path in candidate.rglob("*"): + if not path.is_file(): + continue + if path.suffix not in {".py", ".ts", ".tsx"}: + continue + yield path + + +def _load_baseline(root: Path, baseline_path: Path) -> set[str]: + candidate = (root / baseline_path).resolve() + if not candidate.exists(): + return set() + rows: set[str] = set() + for line in candidate.read_text(encoding="utf-8").splitlines(): + stripped = line.strip() + if not stripped or stripped.startswith("#"): + continue + rows.add(stripped) + return rows + + +def collect_problems( + *, + root: Path, + scan_roots: Sequence[Path], + baseline_path: Path, +) -> list[Problem]: + baseline = _load_baseline(root, baseline_path) + problems: list[Problem] = [] + for path in _iter_files(root, scan_roots): + relpath = _normalize_relpath(root, path) + if _is_allowlisted(relpath): + continue + lines = path.read_text(encoding="utf-8").splitlines() + for idx, raw_line in enumerate(lines, start=1): + line = raw_line.rstrip("\n") + if "semantic-lint: ignore" in line: + continue + for rule in RULES: + if not rule.pattern.search(line): + continue + problem = Problem( + path=relpath, + line=idx, + rule_id=rule.rule_id, + excerpt=line.strip()[:240], + ) + if problem.key() in baseline: + continue + problems.append(problem) + break + return problems + + +def _parse_args(argv: Sequence[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Guard PMFlow business semantics from leaking outside workflow_semantic_planner.") + parser.add_argument( + "--root", + default=str(ROOT), + help="Repository root to scan.", + ) + parser.add_argument( + "--baseline", + default=str(DEFAULT_BASELINE), + help="Baseline file with approved compatibility exceptions.", + ) + parser.add_argument( + "scan_roots", + nargs="*", + help="Optional relative roots/files to scan. Defaults to backend/app and frontend/src.", + ) + return parser.parse_args(argv) + + +def main(argv: Sequence[str] | None = None) -> int: + args = _parse_args(argv or sys.argv[1:]) + root = Path(args.root).resolve() + scan_roots = tuple(Path(item) for item in (args.scan_roots or DEFAULT_SCAN_ROOTS)) + problems = collect_problems( + root=root, + scan_roots=scan_roots, + baseline_path=Path(args.baseline), + ) + if not problems: + print("semantic-lint: ok") + return 0 + + print("semantic-lint: problems found") + for item in problems: + print(f"- {item.path}:{item.line} [{item.rule_id}] {item.excerpt}") + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/semantic_lint_baseline.txt b/scripts/semantic_lint_baseline.txt new file mode 100644 index 00000000..c6b78219 --- /dev/null +++ b/scripts/semantic_lint_baseline.txt @@ -0,0 +1,15 @@ +# Approved compatibility exceptions for semantic-lint. +# Format: relative/path.py:line:rule_id +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:71:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:79:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:95:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:99:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:103:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:107:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:111:semantic_regex_constant +backend/app/services/integrations/feishu_signal_pipeline/shared_core.py:129:semantic_regex_constant +backend/app/services/signal/signal_capture_service/shared.py:107:semantic_hint_constant +backend/app/api/ai_pmo_api/shared.py:42:semantic_hint_constant +backend/app/api/ai_pmo_api/shared.py:43:semantic_hint_constant +backend/app/api/ai_pmo_api/shared.py:44:semantic_regex_constant +backend/app/api/ai_pmo_api/shared.py:48:semantic_hint_constant diff --git a/task_instance_20260326.xlsx b/task_instance_20260326.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..3a809b7137f162c35514c6600cc8f119b210caa3 GIT binary patch literal 445397 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�gI1P08a4ZQ{;K34yR?S21n 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ν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

X7(B+jFgU@hVm(9}-_^~^bWM^Vxi<$ZJL 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%0A9nUW0OBs3=r#0wgavH(NWxLi^V>9?vIc)vcwo~N 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

!maQ?A?hsp3hiP! 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 >u!X4|h9IZ{ zxwT$IXS$`m9N&Run-a*Y^MT{21i3*bZ!q-m@N&`%5EXlSJVCWwMuSPl7*x8hTQ3DeKe-z=irQOnanL7N;#-RP;>?}vc=ZkXK zw9bv!3$oB51x*>5KjofsnE<>E%GQlS`+vnur!AyLvr5yzDo0PwSl zyZZQ_<#lfX#oAdbv|Q2Kpnc-@`gef>Wi#JlUvDcV+x?9d^cpFcJBzz6;(5A`<9;2H z?L!i#FlwH!{3{Z|_#pK`lv{q|lR>01Og=k@^=RoPSyDg|`TJP%9kM=dcw9id%636L zgVs)U2p*vXWoJT@RAX-I)_BZA7eY6LzfNzFL-)t!DNCbS!VusLQZ~WN7m}^s=E4c0 z5ii6=6O37n@G^JX>0L=x$g`ZO?mTL%mKzv`Ptp2x!S-=lbVJrs3!Rbr&UbrgO!|bk z6)+5&Wc0X2S_O>6bfI(Q+vk*THvFa^|K6{3a-QoL*V z(B!`n;iDcsM7GLbVURPi=_qh_H@Nqz=5C_3_P&<#F8^_X@u%fzYt{vp;fJj=O7=`| zwJR0hNl{mOvwHH!(+$$&+0SgZtGf4JR42}4*ju$H_gFkW{Gt3=*}h)!h@`tm+{&f* zFrn#vx`U#PcXg)s_tIi_;$9xQQ|ONkSWbmS#l>QiejJlB4?B6XoI(vV*z&gHQK2iE zDucPdj7Wi{BJBG}TqoLmuv}GxA=p-^zEh10**S1t*}~W`VkPYsHMd(ByQ3TxRua+% z(wuR=#-Gbk`{-b7uaYw{3lP>;T;ZR7{^W$E_MX%2z#)9E?A#N5I1Q8Jc)K(AOZi~^ z)tj*{ysYNg(T#HbwpkH3=*uvdI8^LIstgy?^%S+2%-pZ>7ABK|%>(3>$@`YEbK`2V zmGxYi#nP3KZaMWxXkT^m{}|Z8oI)eEtSXa|?T?Ns!^LHdvv?s{@jzT#7P ztD8QBgp@@NCHJy$pKx=JE%o>l)w{SW6MR2pT9Re0yPmne1>T`xcoa0azqztalPuIhQ;pRK9zeZgY?)A9HFJaSx$0&gp!eFwQ zM6M|A@L7_#ChCy7m`}gJI4PORL6fh`fJ^DYbBIsWy9OBbPG8)F)K91K)7ZCZb8Nu> zN}{0zbulTYD#nsU{k@(*+P4WC-*;cRq-Ohal5zdGelABzxX2_mv%~-{cuLhzrqyV<#dTosGJw>Q?~W zV;v!^9kBaW`JVjQD4*JDF~xPYXr7S5;nsfqJKGke?SmHX9p0g9;OXwP9)y&-`Q=vT zI001KrFERF6KChXHPUHhWaPcC2ko-uRB2|kUk!5sY#Mx6!r{TMI=sAZ4x!$R9S7vC z+Xoza{f8NX3;s|$=q5YhyhK(#Gns=$=(yaMzrCQC{n?2UEdRXhm;aR{^sw=>V|p}S z(M3nw%I)1p#Kt%cw8dKN#%v7*4$v>`Tsjden6k_PN|H`w{t%HY0G!i>LPMR>?BUa~JXAmwruHeZNg=Oi7w?^Yw;GG!%&C>pl0J z|7=Qs%B9*dgiY9olWBf!T=^wS?er&f;gh*mGvhe=*E^rA(*Dn3gm`T9@#&@9E^uPIKUwl=M+1A{;*OEDMC4V-?|v`ENWA;b!q zfIHwCA$eC<6A9QWsv*~BitzOgvdvo^xWC3GIU2SM6cU_QIcfVnv zXk!)_Tq1qwl*lv-Jm8?82AthHcosGVB%>F=w8@*>L37@kFI$F@eOpdWCxx;wD#$Lf zFHdJ#Dq{)8ePp&KP2yHL-B0(1`tr0ZD~<(gNJCeD)w$iY_}sI;`|DYkZ0COSDUc|C zr?apBtzvt8FHzAh&iB2;37X?67{@-7H^_#`C^-of14T9(SK8Q$Nyn{-RRis z{o_g@tX|NO$eyxe=x7?DeY8rRcfaRWqUAL+i7Sx!b#)UB9a%G$H@{R>rHl zo%MOqJLe0+4-YnD=cB(|Rqh3uPeqsh3_rFWUUkg3-ZU3p;r6v=dL7LA7+vo_ytyq2 zy@lS~K_4%_T4p}pZ~7P(&0`K8?2f$=zCG!%yZO=&{p~uYU_x;jI(Forw^;mz3Nz>{QU9bj2<0s zp_jt9UEJ(U-=lCc5p#um$ekVHl? z)w^lZgJnfnZa-J=WHsxf_o&QrXx~-YZ3dL`@SW~!p}S2{>k{c@OHAR-$BT8{o4IbJ zOX2e)Eq^?><#!@~RK7=17&fbF`S&lgp0jvFacNcF_3b&#?>L05e#lzfZS~G8!e2V< z3Ae1Bcy)e{HEo9VDEjO1`gf&&1F9kuGg?WfSot0WQ?Uc+O>a1l9LgzPCF zvmg%LRAK(8LKewD z2qpUkvJ~*24NsFyC`}W`D!$BPjzt$1K?V2nWbCtVdIr5)yct5@_zWcU^wg$xhE+zCt$SlcTG{UnUW4{M{bLl~}yQ zwJUkeQc!u+KU-8ie?K%8a!PFP`D^lh>RWKwNPx&lRoqvDq=G>*RXnG@{i!OzIYRD6 zcr$c@IZaPmdNPZk@Z0A@PMWbFFJ1)gVnRpmD~3??B@wG?h?(~9!6|=vaMyTX7JKl%ew1= zdg>k;8NFv$-3eTKc=cxc53gR-`#QQanERf1oVKd?7#Uz`L46#3S30~~{qJ9PYluyU zLRG80v4C$sJYG8n1n@EIRVb$9ipl(c2YNB9G&KIzi%KSy+r3*>ZyU z_8|#{eTUR^!?xYZx`gKKX_Uv0K3mgPF=Leom@3Vj0lhn{k4z^?m^xe}@#WPO zjA#zODW+j+getM?sq%@Pc0gQ$Tm=)CVn$Gz@rhRPK?UoJk#Qper~K8#q?uC zuo%9|m`>^Q7ZU{NZ(olc8usEqW27R($7Q^z#t!2>)ZPi`5)%gJjb^EVqV~~8SQ~fp z>E^1j{kVeT_-Mx{U%SvsX+~=#4`tS@*2NB&_N(K|IcZGfiA#Yj z~ zG&JzO_`2Zur(I}TUxz4TAfue&%^gxl^i9W=aIOCs`{k#Zr0_!r718sbMk2!c(Qa9k zKAzBywyLZ7!cZft+T#~T+T=2#30GQB>Br*Z``yZ`hm}ekc|H>Sja&ZMGCs&U^m(aA zw~=RxQQqSDU3(k*wP3G;J+0_3_tuG$V&L$jjW{vaYR}iiE#{5y1hBejVz7VTE(R0z zz;KoK0>F5WA)i9v`Q3l_&AQUY3?#P6tRO5;mVFAdATwTw`e(l=)Wo5SrJhdlLO{wa zrU>u}IsBrVl20Du`K`qBrA-Qc!EKTorFv*Xg7CN+pIlEZJ_cU6WdRdJF{%qcNQ7nB z$U1i<`E=VR;6q0Vy-87;`hMUO**!O>VF9|U&Y9(0LSF{Vn`->HzunHoYA95xreZxp zZqQ3UPe(C{Z2m0@95bdvdwecweLlCcHMMj4tK0hA7*t>+l4t^g8BpM0$R;hZnB&;P ztZsywK23hi*^aygg?}`Tkdp4W*T&P0XZPDaFEVK35u71)EYKi1${*${v0KVWqB?06 z4_Q-|cN)>UhG1faj1LAJzUHZV&EUf-11%1F^Z8rcRdc_Z)|JlC9*g~S zt@^xKvrFmSX?4|DMt}5*wyiLt)Vs`5n!=W)<*H`8C9SV$;Z>4fN|!ooW%tiaVn=xo zT^8rIH$++uEb2ej6Q5ciXPw{vb_*2z_`SToRLi!xd4~JhLs)OF^c|eEaQ_k?D=zN_ zd4Qu1oplI6sd?AU#|n4$RFF3ZnMACS*7@uV@53EzY&Wh@RL>{0t*B z%wR;Bro5%S%YE^>Z>O)#l}0YlJ0gO8!G`lf>gR=OH{mPv{9A)B^8H42ZjM2TfxZ_f zgFn83KkI#!b>l8Fx|2fNiaI8!F{*n~Hss-TB4HhWqT0Q+s>%3k$Y!CO?+g9t``zPU zU~PsED5O~JHvx)a1vSZ^_KWxQK8Nx`WPhA&EOT(r#Jk?Rh9BszD49f2{q#B3Ufr6m z{f>1SuMEX>SXy2i4LKx~B?FOB+Y0AJWO%~Pif{uQFuro*qX4()>xDkJp^bWv)mXH{H8J&eP_|3Lu57JH~F%eTFe2E z6At)UcZp@*D>~d;t1<{Y2ku~R_>FK+xgsvO(R;uV6M^(RAS@K_G+)K&B`pOzTn}t6 z@O9CyDM#?VuyGGJ1wLE}p?Y+`yV|qOby*wL5Nj@=CZQ020!Heao#4;Mu8O#&FTqDh zOM0*_eUkAydKi*i7QM_RgTG>B&-D0y;UN>URZ7E_R}v#&7(1 z4J1;Pzq_M)wK%>upq;X(9o6`Q~BEjeB^b~=n3IjOVZ_Mr49^O)M; z_K1rVU;V|BSJc4{ue6g?^cuv$!|hoohclH3;s>tbUE;MHCa|p{ zLl9=p-XMMvg$7Zr0$x}Ak9OkeJ`5N==HFkoxhT~&+cLdX1XQZj4B3I*Lb8nCbZC1? ztjn3}j7J6FQPNGQ`J&$o5*`=R1Vn!MVG=F)Bk@*rpJQPeCw`Rgbxpw}n*%3@I7+%V z=LcwX0FrKchon5nHtmpy6juvv2naH^7X!Q#aNb!-Ca4|=DNx2=~ATb_swqR!?L=c zV&UXxHC+Yr`+1JHzK@s953@4l%YBLOqZ%vEB3{(FUsHrdgx0xt1s3@wgfD6==9dTi zsy*xEQF+6(Tvhzi_V6SbL-|cid#H7f1cLDQX8}600Z7R(iD6F{g75$niGZYi%B76q zJh#dSf-p0;W>4;OPmLThH`{}J7;PJ;dh)qvS^Y7ZDvL_|QvUQk+DXrB5%tVH>Ind{ zF5apBr4xk=VO&2iQ3YsCapD#BIl@VO(Y-7u9Kb|&5Hj&z-Bb;g2m?zHM|T6jSVU+F zCnp)xKXmvLVyU`o7Z#h3>k52ChJpkRdNdtx?&3QwE7{v*6;60UT$*@OjafmR&m78u zLD%PM*e!8Y`nG*T%bseu`)fc)LCCMcW3xg9-v8meAW>Voe{fy=Ofe-$_I-=zX3E=& zhY`omD*i%E7fR3*ZQ47V{0fQDJsbzGBDGZRIV!}$N@w%>3qGH$)lH<6RgpiUf>`cG zo`O5fZ%s6J=&NRtO9L)3SBtSr<1Ur?uct4}tp>YVFk&=ieZn34G}JmR!8KJYM5v`| z^&awr6bv#8LcrGx{Pf?~Th_H81bn@$k{mp{Zkc(oMq;TQK`HWY@{S9^se*zeQ&@jO zCz+u=(NL))Dq7jcY30v>hJ>0;=tuJm3Pgv_|;vFX&Muy#BARq z7^{}nEQ??1L8CR$khDi{{5$?$Zp4%-RHoD6o^2Ua^!R^xc2et;<-gbQTj1ntmT=uo zb85KXhc!YK>{8!+Pv!moZR{^1A}gXEh5mnj!hQJ+{XV77KU{^2J-Y6LT7!!_iXxMw zhif6tUkG?P;wFr&10F+~?Gmrc&P?XX+H1HXH2dh&rJp=gljE!~nPJxil!ZvS0_OyT z2;=V~_c?lL$!Suq8d_SqOfN^6xDO3~9w#p0dR)SU2gwPNu8N-(9{bfvXf+0mtjV+x zuxtZyyT$ayA)AfBD~*)My8m(kdoj0!8X}oJ zk9;N=y4D^b7^>9yD!RG{9?JP2vq?yWRw#%jCq3JbQv^OI-6xb)1eS`83Ad9zjG<6- z?a3Bi?Ns+JQiAnHt{T4Witun=p|hpCjMuvDDgzGlerJ1=ov`QTmhcySwPjch5ipI!>ya~gNN=(xVIYJ42hx}$ZhygS+S09@1!UXf71 z^NajN5q^W|=6QW`i$AtyJPF($AKESUL(&eiD;64_Pm|x>&1a6Pv4xl$Moh=r-KpK6 zETwBW8NReOFb?<(aFA2uZiqci5u6ksvD|#Z2No zo`NXLfDTHYGa1k&gz!h-(hLLhMT{Erv*jvnlHe#{0N5Pi9ycr%1h%)DV;_CeA-{i_ ze>$%P;o6{Cuo{qxRz>oeOs(C8o68&ke%wTB{g;Nktjy|^}{lTAObZmOf^A6=YUx`A2%fp2!L_3E_a-=)wLYa z;brYCHaFeUQ4yca{0n3LD{>ZwiJU3m3->Ux+6B_xus2jSU%bU;CR%9w;JU68rPWyk z_{giKp@zLwTU;+oA^kxttoMu{8gQo&ZgC`trV?RNuzT_deQyH#;vflvoIqf=SKyMG z0sa(ZRWA!}e=uzX=r+vE%!nq22>L%}~6vXN|j+zw+Q-0~kV6Vf~xjzvkOl19KMkVjs8AFY9S zN{s2@&Og-lCe&T4E)h_}AoHjAQRwU0KY_J_JVl{#7uONDgBRM#iD)eI6J5r969fJiDWu zvtiT>Km&s{!~H!~W}?~6?1 zbKKSYR&h~rH&d8^Hmc{`m6wzx!!v6d&97y5mrEE;(;huk*}x+2+%+HF8x4~ZCJq?? zpRc|fY@Q(q^VRo9cLO~2_cRC!u=7Dus!iGv4Bxc*Uc8LlN-B|4l?N>N)CpX-dI0Zi z7YPY`z&qOoQh-J>yBCKW3ilT!)MeABPRI*j>!eLZ!q_?uRb9&j({%V8rmli0ao3l- z;+(uFys5ZSZ|UAy*!%j%?khJ@^rIH?l=bI;Kg%ai46nm(i~v#7qXs5}o^FiLH~OT1 zd%;iV+48XOs~^6y(I*92d$y9|5vlZrrGw!%Pww5MmA+R80vU;5(5w1pAL#B-Vw~C$ z9WHR2Fc{f_!;(Bd4?F(6#TpmIf`ib`)RsD?-f*3IlunGaoXm?BX3T2z32*40`dhqb zo?4SwD(e!*gE=-WLMVw^N^Qn;fCNW^#ZF6v&L^`LJSAf1U$$vnK{>1iFJCJ=>H;zr z2~cSB52j%lHK*zphr%mS$~xlcb1<}>45i7X_|l!pw|G6wh=gbLNv-9t4rcJ>X zCel6#Z;rr~v_DM!Fg^|{GA!{^D)YneIjlmx3o`a5IDKk{mo^CND zoXZ{(PU4nvVTm#z>ZY|R$uEA{SIx|3rW<%c+yKExZu>z}jo;Lx8mFU^l<~Qx1Tvqe zO2T(&$$eWxTA~9mI+SkcZABgY`yr2A?Htr zkGNdpgcHDb;j4#@A}*${8uTxv8>Q#l1gD0Y3j%)K9Y_*gAgvrA#f5_e$#nsWinFktD6M`nv=$< z75|Kn(pUUU`@pvTL(c>hKvMgU+!HpiAd$>P3x~>xu?wvO5bVqBCj@(Ys`S<()!l^t zOlQSwRy89_Nbo`HvA#CXUh&>m8x$$r(NtLT>^Ab_TKT=t;|RtCmi_Io%w4P_uf0b{ zsISo`sEhxh5`abR<6q|~Ygr1M?3pMU;jQJ7y*$dlY;iQR?7lqxh^dtQS0Y|sN=jb8 zCjefmH{davH0`l#zU{Ip!z&XyoY}0Fk1f$i3OxKmRllWr>>Vp?{-5NO)utiEjC12OLYyKGS7 zcUZ9#vnl4kWsl$O;N0G5Ka8h~ufHSsTD)BwtM}m%SF!z>U7*m5Qxw$h81X)ZAl;vD zH}UYpYQI!7qcHR^hI6EsmvubHtCJ>t4tM=Lbe)R#**e+v7Is*0wiU8ffC@#IQ#A;k zuz}-y`YYQ)leCh!zQUa@r*(RCZIZ=5#$S8X>YKHftLb?=8R^h1pIvXNyPEJDr2m}mj+ZxTgA7moAs){6Nw6L<;9dwfW(;RdZxfHrP;VkAIQGgJ zksGmCx4SS%fBuzo{81aUQAhqc^nBUIEOWqRGNH!l_3Gi&2lo3qa<$OfD-<r6`x8YXR3qJD{_s9FeGHuD3nRw#`op})5To|2ptBLIM*kizrV zw(oo;k5alyoM_asq)kha~4OzH-bXG;JY`kMDkSDG|w1z#+OC? z$ujOQZ*RJ-Pw%s8U#SdWu^FwH2yG!*E|O6+1p7IeHJzLV&z^DkIbkPz8&_h7ru&^N zY=c2tP$Wi=qaW+pQ!n7-D9P~WgNuog_X4QHDaoEoVY&H>@)Q3Epl;qn`VvC<-B(`{ zA2Gpu>`0R~iV|H;MYQRdW}9U!PmEz0LaML!jHqTvCxrTS03W)X1jX+Zt_|Di4Eh>& zw_k%MbawW58PR95_T7Kf)!#lUM?=6!{iTfNYW&C{nf<9~%`6~l)7Lq#zV!G{9~S&pb* zw~-^JR3H-NJH~GVa12qeh6V~=(W(?+7fWMGkykd^n4g++vJ*G6F+}G!(OvQzGklv% zNUI`Bh_8je(~YjuX1U)}z#|52n4D6SsCs-JP$b-!p1qQ%zdR$)C^qM0Q^%5o1oKa* zKqaxEw=YtY;;hR$5WeGRJi6?j;O&LU=}%flx5)dWcd7yfqyEC6Z&Mq8qAar>G|1k3Y=5{q*Z#7S zyBan-ze*g9Ug0fnr2ApyeMx}c-jqttfhv zGEp-v&Sz-F5@Fc$Amh^qq~JSmQK(U~ueL`_{e!t>(PQWWsof#j??%l((zaYn^BIo` zpP*Wwt`;|iDWTe;$C!Ux@RI$rryBb=eIFEvcQ#MAx|s)({o%n1&z|GM!NDQJwaWS! zOm4kSOGbc$qeX**!vH?@v}1R5^RlyWW%IPRTh>x?T;xE%X9r2+T%Yl>_WwoMj5uave zqUfwIWfn$)W9BR$eWWFDPLNeW_?7?#uLx#O`RK|Kyy8M603zX*gJn~nPFKO`a0e{##jtV`+TZ{14DmL zErPyzvJdUVx&^6dO#ITOj z2I2or9EGx8mF8X8-fi9#sq<*P!L>!=$=8b#cXI7kUOr{z_qW9#b#LzEw()pyZ_yg1 zwHwZhZ|GS6tu650sXw2t35$r`+jT2GA#B;ruSz>oVgk#Ow(vw3-zZIc!ZY1$P2Wec zsB-ScfNAW491bSpTFj}HarPK-1K|lPJys@VnIdo zmS;{|_*VDyZ6mKO?U8Kt9u6Uj1s7r_y!E%XH)2pu{yh7pgMVd7&V@#>7{p@xrB%Lq)tt>X28kMS6&0)miriHtvcNK`B+6d9p*;?4Rtp;5}to zWuF6slF=oR)(40B99HlMG&yCyvR{(FFa6}}a=o4ZqWAn_MNPlk-CuVd0H#|pU>XJ{ zVTSmk)SO~{JrFr}l6M}HA&}f%O??v@?EU}jo%38*X3br{=FOkw zrXQA_`TSL3!XkIq0-Y}tm-uv-O<8X@@9w@OpO+>lZK=5b;{WFhD@1I6?w@P0wDZz+ zS5CG34L{L5`mL04l>s9IgC@|U{E&=Vo?n!ml%Jms%BsB+F8Uod;Bl>AdW!u*UX!QK z>$n*Wo*V+s)#sziw@y1U^>N;Y_3ECQK95?}k6*uba&O$64u0!J&fgMyKNstTYF|40 z`A)cQ#M|{Nn8nk0H(nKry7&BwNyNdfRri`E*F=eIo^vq6v1s4XbE_M_$xnMPQSvsL zVPl#@WUrsD_~Oms=RTe8V_EehIArlASBszbTW_Sff7#*O{3&wP7qbOM-F&+97V3pA zG`fH3FCsdhMlTPNc0MDvT!cHjHCq~qS+qi2@R5@o!hQ0*z*xxV?N za?8_&uUp?;lwjX==B&uHWJ#zd_9!`4!G7np#hzpTr!>`DS)7YLdo; zr5dkeer@tw(r{WxP@gTcfAh=9^;Jvl+hgy%4c}>c-hIbf#Rp$rKSJ~5>^7$sX`lzM zGczy<13ek-oS#>cnpYAZQdy8%91BWCYbT!vrJ`f;OJ9{{8Cw)Myw>Z{esh4kw7ynURy*-)bj8(dASf#Uwe5=FNhRG3a9P^Y*J^Y0J zFPqyDw6%!+QQgiO0j&xqf7Y*3KdZJjM!nNbJujQTm~-DL;fOPvmm6+O58c^wQA)M* z@uLS{`Mo~6YV0gJaqyT+Oo7w9&dnW)U$h^F{HSV}($kisExgy`c;=$bOfNGSPoI`b z-^Ej!EAnE&w?1#L9?m7l*c#^Ox?emhYVvVH;-7nG^AaZP^muY5mrL;GR+jqbb8}v< z?mpo(;Y5rj@ZyoTH-Xns74rTHv+)0+yrk>{%h3&Iz7VG z=Fi*l(008&u-ar~5@AMEoNmW`J*EOf@hlJv05J?S07IC8AtgUKpeVnfSU<6#02Hw3 zy3a?g{PP;9?le%fAWSQeZeTo&tUEcsC>5LbnK5&e1=tuE=BPuW5@tdJ<6WSEz&gAn zBQ-Y_LK5p8 z*C964rUZHbpqJYStz1XhkV|oNjp*edLgQzkMxfV`vn;x1^n8xc9B>@08Aq;1HwQf{ eAG}6);AS0h-dquNZf2 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 z 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

)rQ5!l-rKMDXT-mxiV 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Ï^xd~R+gjV8c|YvZoa#eoRx6u^z91q+ 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

kM#b9ANCX)N)yLoTVRqw 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%0DFKmoOdY?S3oWurW@8x z`CR53q6E#P1S-h>0a|+NT(Cin+E~Jp`g9);l6L!EfGfoRNPBZvHdo4TxbGTo4AMQs zT&6*&Df+UvE`^A^al70~|7hoq(}i$}zgq!9F4Ja^pTAi3rRLR@%=OaT;IT1@|H+mr zAxrYuZinqN`;zu%Ftzfq$_RNd8-Aun#56EQg3pBgVYug3#Bod&$`> zIj;%Ek*f)^fI`qMTaI5#4{EwrqXtsZou&rUVayJ)_-a{+42rt#)UFJ?x&~a!)Y7{u z%nlrVAxs=Ckz+0EY9YHSo&8E;V3wDeH>UF0grP2%nO}-l{5RSAmzn=oWm{}yF-iBs zIs@=x1d!^6cF!@3D1wYdH^-iyA6~3&lu&#GRw(yxyC~WUP&AC90SV*c4u{~0uBKu@ z!d_ZxS~Bbau-I#3kirXoVkBHrP;J~u7oR_15_A~pM{}ngdyV2s`?fG3YAI4`Uy$`? zlyVe=%@9F=DE#e031anj9FsI$s1RHna~Oi0DJnUsuIcT&f?5;su8z~Vs?}gA;zg8N zx_tBjy@W?%O1+wZIhzcd_#rby8t;Fm-s}sW7MvHfAOZ7;O{oxP1aVyBvhuy530Juu zstId6LTYE}FkEna%#tTzx6V)?J3AJaN--pZJErkGBIQjEd~415lo4XbaFoFx%b&%R zQ^&;<^n1W`M#ScEMY3Z;yZP0@s7!?9ThHQ`$_S$(NuttXG(hSCc8 zvAjY4Vq6(vGgxiUy=z5=78QZME+`=F!7l_a)xB+UsVW^TIY(ebiaNwcVZ%xwxyWBO zvl?lf#LO&FI0g}_(ef8UA3NKR%+OR)!z^%{%*GM&qxHJ4_~9GB!Av_b0EtUW)4uV} zq(GB`jx%Kwl$O*rLrA6NT<2aL_*UlWApXV)zQEsqa9B9lXoYz zbT8lXTkv$xK!_UxKN|FbJyV|YU*$7`h~aH8%Q2{xr-U8vNr%ju7=v@_MP{P%p$Clj zw1WH@3ZCojvwI#$sNO@+-uq4;Ykz2Ri9qiU;c}1YpUc4fDdROu?8l{Wi#$F8hbtjC z+#NiJ5#xc_mr)snXu?GrFihFGN*!fM2v=-~NiW73rNAk;N+0C|2>!~F@%ac}A_H<0 z5n#^ZDxY2@ZjIGz8T&4_Wsz1dNcEwKuJ4%!esolzhMJa_Cxao>p*9&N1HN{PNCeGI zFH42YQ4?Dci3;tRqD%P0yu|cdzt4T9KphyLSe}%ON%}lW`#VtG+E;URY@Yi*m7IY9G4-i zQn^2(Nq)c}oo)*ZFHj6enatA>M$I$uBax9p2k!_p6-rS`fK6Bo6l^=O6!vZZgK6bb z@h-p%lq?ngE5PH9O}a-xk>~@-JIAm5>L=4sSc>6Dy=7sE;0>GP@=;{ezKc!1u)x+O zQU+?46gFDrnZd(zYGPKD-1Zgj?FHOvdzRYckpleKmGI=i^T1u}CdS=S0daT#OoG0q zMTKZKj2FN9+MMAEz01AOQ{%qRjs`w#v-VP&aW9S+7B7KVDj>DtX6heiBETUG`%d2i zuRT4XKun>gv*Q;M2!Z~^|Bo7}oH*a6wZ!B(^pg>$7ml|=<3WQRbe#i^;qn!2vaVWTP!ucp3#iQP)e& zOeGkEx+h-I0~vJBK~V45wBUP(W>(2eiS%}r?-3XV`{BW!;Nux6Q1U#Mrl)6kX9LVu zS|{Cs_`-w(&>20P2&Y<}19U}o$9fvwna;WOrJ8F~LnLej|7fJP%RzF!Kqjv!XEh=c z$S;0K=m8I3Y&~n4Tc(W4(5JL_f4-WiE=+C#3Z)LSqNon#S-){+>3M{Sj$#>`sO34E zUhniAY>yl?*n!mo18!$&&DB;aWyUK{nt@g^seV?4H7%+Q=or$`8}Hj1Tovka z6rV!U<%znhLt}{rhhl~;2i|2B5t4Cah@ZuxpL}D&sn5Y~z>@+bWL+gFa~fc#E3v}n zRp>BbjY|siK-FMK5w(!_y&5!HsHmji^V8%d!dwO|YZ|3~PK4<`SuHtg%J!+ZS{Ije4iJ0B`)%rPFp5N!oVIwd~teTRgDEoZrZDuC~M2}8nt@6Fb=40 zH5&eKwkSFZS2*K9x}RscL){|TPK?&o#q(%VbYX6>8aN(1KUfG{E`B z=^DJi#_PJGMc1y_mGGCzwCiOq8LTFYeF1FK65gh)SbURf{ zi+R|_KOGHQ;M+bFCzjryJN>3#Zb9Ic*xJY|C#$HQ!mbXjx(im^7=5`~M909|XkF1a zP%B!#C2Ka(QFJw`N7Qy&axvROOlB{S{*9&OhTx}=1cM4I$cjw^Vd_DYcIs39CHm*S zkjnN8JL{09Q^vjrM{ezNZVQUq1(uRyR`1&`DP>M`6;jU$ z@f==pQXC}{&pN~}D$oLZ?bFhUMIO(zf8th=NsUrus6a{ou^yOVuKw z2+d)K`KkSJ#{D;UQA^z<7O2vHva;x_fUG&L1Wv1k)`Lv_I?HNo6@c0=9}Th`@-%4J zqy_17S!1Vfmr&>qt|^A;`)n7RWSm|kZ{XujTb=4n-QY29!5%96(mqIuXe~SVevQdGzOc8bqc& zc4aaZhRyyIgQK*oe*D*t-noGNU;+aGK7w`>_)nm^**ShOva|d09;#8XGje@Qh+;m4 zqcGF9{*p4MdMUn=uqYy4Q(A5fN&VkZ z)1ZqP*h?t{UZz{ZR`1?GoJX-}=kOXcIc;jyJW610)Yq(3_Lt% z1p%1Yn1I+H@KjM0aYa8l5>~f5ISv>s7%#${UyZHXPp%ODw-ChPwpn!(}Q*3b?gEHzie}}{yLGDA}K*_@Ev92>}40gLYC|#Lm{))Ye&F z#lzmzN%!50DiWsNy=YLs@WjRH6Q{l4DMKXfSvNvpzi$3PwvnB)UCe5&R89@jcj^4W zyL+b>in1nS$Z>9SJ~a;!4B{Zc1>XdXVA!k=E)sHRe~L0gl^PsjcD}WIMWJyAmxsE= zd-QDZ)4HHHog%c$hwB_g*BGxWX09<;ZHb)0qX^sG*}4Tv{T8EcaUAX$6xFd8&I+pw zCB32DR(bIBO^gh-rbX|N7_!W(13$I^8ymwjZ$)&m!8ppfiQx)h1DN~z%WJW!Fkw(0DRi5!N&rkj8Vno*;=hIS^N_5>caRk)Ko1nq z<3E4CAPWNkCU(XOj&}A=jE461?}q*NXupr5hNqzQ#z1SM{%0uY)fcSqe~vb`b2RpIQ9h z1OJ@||2vTH&)@I-pCSA2!T*l){|-(AK)(Or|DUM;_jdjrO8?!C4;bYC6<7+=P@uyF S0KkF%`9T?c3>*@)^#1_09SXVt literal 0 HcmV?d00001