diff --git a/.workbuddy/memory/2026-08-21.md b/.workbuddy/memory/2026-08-21.md deleted file mode 100644 index 949bf3f..0000000 --- a/.workbuddy/memory/2026-08-21.md +++ /dev/null @@ -1,221 +0,0 @@ -# 2026-08-21 工作日志 - -## 企业微信自动回复第二套方案(引擎 B 数据直读)落地 - -### 背景 -用户确认 4 个拍板点:发送层 GUI 复用、数据来源两条线并行、机器人对接复用 ai_chat、互斥共存。 - -### 新建文件 -- `send_lock.py`:发送互斥锁。Windows 命名互斥量(`Global\WeChatBotSendLock`)+ 线程持有者跟踪(防同线程重入);非 Windows 回退 threading.Lock。`try_acquire(owner, timeout)` / `release()` / `lock()` 上下文管理器。 -- `engine_b.py`:引擎 B(数据直读)。`DataEngine` 类独立线程轮询 `conversations.json`,按 history 增量发现新客户消息,经 `bot.enqueue_detected()` 投递共享队列。启动时 120s 内新消息算新鲜可投,防抖窗口 300s。纯检测纯投递,不碰窗口。 -- `test_dual_engine.py`:双引擎集成测试(31 项断言),覆盖互斥锁/投递/字段透传/去重/合并/DataEngine 集成。回归命令:系统 Python 3.11 跑(wechat_bot 依赖 win32gui,managed python 无此包)。 - -### 修改文件 -- `wechat_bot.py`: - - 队列条目新增 5 字段:`dedup_key`/`detected_by`/`detection_ts`/`sending_owner`/`send_lock_ts`,在 `_load_pending_replies` 与 `_persist_pending_replies_unlocked` 两处白名单透传(旧条目自动补默认值,44 字段兼容验证通过)。 - - `send_reply()` 改为互斥包装:`try_acquire` 拿不到锁 → `_deny_send("另一引擎正在发送")`;原主体改名 `_send_reply_inner`。 - - 新增 `enqueue_detected()`(B 引擎投递,复用 `_mark_reply_pending` + 补新字段 + display_name 兜底)、`has_active_pending()`(终态集合判断去重)、`merge_detected_by()`、`_merge_engine_tags()`。 -- `gui_runtime.py`:`BotThread.__init__` 加 `enable_engine_b`/`engine_b_poll_interval`;`run()` 中 bot connect 成功后启动 DataEngine 线程,finally/stop 中停止。 -- `wechat_gui_qt.py` / `wechat_gui.py`:runtime 默认值加 `enable_engine_b=True`、`engine_b_poll_interval=2.0`,start_monitoring 传参。 -- `app_settings.json`:加 `enable_engine_b: true`、`engine_b_poll_interval: 2.0`。 - -### 关键架构决策 -- **B 引擎不自己发送**:队列条目由引擎 A 的 `_resume_orphaned_pending_reply` 统一捡起(重新定位→视觉提取→`_generate_ai_reply`→`send_reply`)。发送天然收敛到唯一通道 + 互斥锁,B 全程不碰窗口。这是"检测解耦、发送收敛"的最稳落地。 -- 检测到 A 已处理的会话时 B 只补 detected_by 标记,不重复投递。 -- 队列字段是白名单读写,新增字段必须在 load/persist 两处透传,否则 B 引擎的标记会被 A 持久化时抹掉。 - -### 验证 -- `test_dual_engine.py`:31 项全部通过。 -- `test_runtime_settings.py` 18 项、`test_session_name.py` 67 项回归通过。 -- 旧 pending_replies.json 条目加载兼容(新字段自动补默认值)。 - ---- - -## Phase 2:企微本地库解密(密钥提取攻坚) - -### 关键发现(本轮) -1. **真正的 bug 根因**:`wxwork_key.py::_prep_verify` 的验证基准构造错误——读了文件 offset 16..32(含明文头),正确应为 `8..16 密文A + 24..32 密文B`(与 `wxwork_crypto.decrypt_page1_block` 一致)。修复后探针测试从"0 命中"变为"命中"。 -2. **算法确认**:`WXWork.exe`(269MB,`D:\soft\WXWork\`,版本 5.0.10.6015)代码段含 `sAlT` 常量 + MD5 初始常量 `0x67452301` 的机器码(`mov [ebp-0xC],0x546C4173` / `mov [ebp-0x7C],0x67452301`)→ 证实 wxSQLite3 aes128cbc MD5+sAlT 派生算法判断正确。 -3. **扫描器性能优化**:`regions(rw_only=True)` 只扫可写区 + `len(set(w))>=8` 字节多样性预过滤 + `_fast_verify` 单变体优先验证(AES 3→1 次)。探针扫描 87.7s → 3.4s。 -4. **扫描覆盖全部**:16/32 字节窗口 × 16/8 字节对齐 × 全部企微进程(含 WeChatAppEx.exe 8 实例、WXDrive_x64.exe、WXWorkXNet.exe),3 轮全 0 命中 → **结论:企微 5.0.10 数据库密钥不在常驻可读内存**(用完即焚/受保护页/混淆存储)。 -5. 当前进程非管理员权限(IsUserAnAdmin=False)。 - -### 新建/修改文件 -- `wxwork_key.py`:修复 `_prep_verify`;`regions()` 加 `rw_only` 参数;`scan_binary_single` 加 `key_len`/`step` 参数;`scan_binary_all` 支持 step;`find_wxwork_pids` 加 `include_extra`(WeChatAppEx/WXDrive);CLI 加 `--binary8`(8 字节对齐)。 -- `test_scan_probe.py`:修复子进程 code 路径 `\U` 转义(用 `!r`),加子进程存活检查;改为 aligned 优先。 -- `test_scan_probe_mis.py`(新):非对齐密钥探针,验证全滑窗兜底。 -- `scan_golden_window.py`(新):重启企微黄金窗口多轮扫描脚本(`--kill` 需用户确认)。 -- `probe_wxwork_db.py`:已就绪(等密钥到手探查 message.db 表结构)。 - -### 下一步(待用户决策) -- A. 黄金窗口扫描:重启企微后立即多轮扫(`scan_golden_window.py`,需用户同意重启) -- B. 管理员权限重跑全部扫描 -- C. hook sqlite3_key(看雪方案,注入拦截,开发量大) -- D. 换会话存档 SDK 路线(`Downloads\wxwork-finance-sdk-main`,企业后台 API) - ---- - -## Phase 2 落地:参考目录代码 → DB 直读(密钥已验证,主线打通) - -### 背景 -用户提供参考目录 `C:\Users\pc\WorkBuddy\2026-08-19-18-27-34\`(企业微信导出助手,密钥已验证),要求以它为基准实现 DB 直读,保留密钥逻辑、复用可靠模块。 - -### 参考目录关键资产(已逐文件分析) -- `wxwork_keys.json`:2 个账号验证过密钥(`1688856770803435`/`db7288a302bfbe66563d81f025bde977`、`1688855555743233`/`d18e7f9a222665389989066f929ece19`)→ **密钥来源问题解决,内存提取不再必要** -- `wxwork_crypto.py`:解密算法与本项目 `wxwork_crypto.py` 完全一致(互相印证) -- `wxwork_find_key.py`:7 种内存密钥提取模式(参考项目曾在运行中企微成功提取,但本项目 5.0.10 提取不到) -- `wxwork_export_final.py`:`parse_content`(UTF-8→protobuf 递归→JSON→hex)、`MSG_TYPE_MAP`、`is_personal_chat`(M:/S: 白名单)、`clean_text`、`format_timestamp`、`load_keys`(支持 `*` 通配)、`decrypt_with_keys`(WAL 感知增量缓存)、`detect_wxwork_dir`、会话名解析 -- `wxwork_export_db.py`:`collect_metadata`(user_table/conversation_table → user_cache/conv_cache) -- `crm_import/decrypted/`:9 账号目录全空 → 印证仅 2 账号有密钥 - -### 新建/修改文件 -- `wxwork_keys.json`(新):复制参考密钥,含 note 说明"每账号独立密钥,未列出账号未登录" -- `wxwork_db.py`(重写): - - 移植参考全套:`load_keys`/`decrypt_with_keys`/`parse_content`/`extract_protobuf_texts`/`clean_text`/`MSG_TYPE_MAP`/`get_msg_type_name`/`is_personal_chat`/`is_blocked_conv_name`/`format_timestamp`/`detect_wxwork_dir`/`connect_sqlite`/会话名解析(user_cache/conv_cache/S: 对端推导) - - **WAL 帧合并增强**(参考实现没有):企微运行时新消息在 message.db-wal,参考只靠 wal_mtime 触发重解密主库(仍缺 WAL 内消息);本项目直接解密 WAL 帧(同算法、帧头明文、salt 匹配过滤、后帧覆盖)按页号合并进主库副本,更新 SQLite 头页数字段,`PRAGMA quick_check` 验证(`test_wal_merge.py`) - - **会话指纹增强**:`session_fp_from_name` 用与 `wechat_bot._fp_from_name` 完全一致的算法(md5+blake2b,40 字节)→ DB 直读 fp_hex 与引擎 A identity_by_name 模式同指纹空间 - - `normalize_name` 仅标准库实现(NFKC+去空白),避免 import session_name(其顶层依赖 numpy) - - `WXWorkDB` 类:构造时解密缓存+元数据,`get_new_messages(since_ts)` 秒级 send_time 增量查询,`_refresh_if_needed` 按 mtime 自动重解密 -- `engine_b.py`(改造):`DataEngine` 加 `db_source` 参数(WXWorkDB 实例);`_run` 有 DB 则 `_poll_db_once`;DB 直读失败自动回退 `poll_once`(conversations.json),下轮自动重试恢复;DB 路径**按 fp_hex 聚合**只投递每会话最后一条(防历史逐条误投);初始游标 = now-120s(与启动新鲜窗口一致);`_process_entry` 提取为两条路径共用 - -### 验证结果 -- `wxwork_db.py` 冒烟:2 账号可读(`1688856770803435`+`1688855555743233`)、1041 条单聊消息、health_check 通过 -- 增量查询命中真实消息:今天 11:06:05「一个小迷糊: 在不」 -- 指纹一致性:`' 高瑞 @微信 '` 的 fp 前 16 字节与 conversations.json 档案 key 完全一致 → 引擎 A 正运行在 identity_by_name 模式 -- WAL 合并:quick_check ok(当前 WAL 无更新帧,机制已验证) -- 引擎 B 真实集成:FakeDB 聚合单测通过(多历史只投最新一条/self 过滤/去重/降级回退) -- `test_dual_engine.py`:31 项全部通过(系统 Python 3.11 跑) -- 密钥匹配验证:仅 2 账号可解密,其余 9 账号无密钥(与参考项目空目录印证) - -### 关键结论 -- 密钥确认在主库页 1 可验证(`verify_key` 0.03s),企微运行时 WAL 帧同算法加密可合并 → 实时性方案成立 -- DB 直读 fp_hex 与引擎 A 档案同指纹空间 → 投递后可被引擎 A 无缝定位窗口回复 -- 回归命令:managed venv(`C:\Users\pc\.workbuddy\binaries\python\envs\default\Scripts\python.exe`)跑 wxwork_db/engine_b;系统 Python 3.11 跑 test_dual_engine(wechat_bot 依赖 win32gui) - ---- - -## 引擎 B 数据源改为「两路并行双跑」(用户拍板) - -### 背景 -用户质疑"是否有两套方案兜底,而不是合到一起了"。原实现 DB 与 JSON 是**主备二选一**(`_run` 有 DB 只跑 `_poll_db_once`,DB 异常才 `return self.poll_once()` 降级)——DB 正常时 JSON 路径完全不执行,存在单点盲区。用户选择改为**并行双跑**。 - -### 修改(engine_b.py) -- `_run`:每轮无条件调用 `_poll_db_once()` + `poll_once()`(两路独立检测,互为兜底) -- 游标分离:新增 `_seen_db`(DB 路径会话游标),`_seen` 只归 JSON 路径;`_process_entry` 加 `seen` 参数(DB 传 `_seen_db`,JSON 用默认),两路独立建档/判定、互不污染 -- `_poll_db_once`:去掉降级 return,DB 失败仅 `db_active=False` 并打印,JSON 路径不受影响 -- 去重统一走 `_maybe_enqueue` 的 dedup_key(fp_hex:时间戳,300s 防抖 + 队列级去重)——同一条消息两路都发现也只投一次 - -### 验证 -- 引擎 B 冒烟通过;并行单测全部断言通过:同消息只投一次 / 两路各自增量 / 游标独立 / DB 崩溃不影响 JSON -- 真实 DB 并行集成:db_active=True、0 重复投递 -- `test_dual_engine.py`:31 项全过 - -### 架构语义(最终形态) -引擎 A(截图 RPA)与引擎 B(数据直读)两套独立检测通道;引擎 B 内部 DB 直读 + conversations.json **并行双跑**互为兜底;发送统一收敛引擎 A send_reply + send_lock 互斥。 - ---- - -## GUI 引擎切换卡片 + 全量回归(交付) - -### GUI 改动(wechat_gui_qt.py) -- `DashboardPage` 加「检测引擎」卡片:引擎 A 开关(`engine_a_check`)、引擎 B 开关(`engine_b_check`)、引擎 B 数据源三选一(`QRadioButton` 并行双跑/仅DB/仅JSON);引擎 B 关闭时数据源单选组置灰(`_sync_engine_b_source_enabled`) -- 信号:复用已有 `settingsChanged` 信号 → `MainWindow._on_dashboard_engine_settings`(合并进 runtime_settings + 持久化) -- 键名统一为 **`engine_a_enabled`**(注意不是 `enable_engine_a`!BotThread 参数、_runtime_defaults、_load_runtime_settings 校验、start_monitoring 传参、DashboardPage 读写全部用 `engine_a_enabled`);`enable_engine_b`、`engine_b_data_source` 不变 -- `_load_runtime_settings` 校验:`engine_a_enabled`/`enable_engine_b` 转 bool、`engine_b_data_source` 白名单(非法回落 parallel) - -### 运行时改动(gui_runtime.py) -- `BotThread.__init__` 加 `engine_a_enabled=True`、`engine_b_data_source="parallel"`(含合法性回落) -- 引擎 B 启动段:按数据源模式决定是否接 DB(parallel/db 才初始化 WXWorkDB,失败仅记日志 db_source=None) -- 主循环:`bot._poll_once(scan_unread=self.engine_a_enabled)`(引擎 A 关闭→跳过红点扫描,只留队列恢复,B 投递仍能发送) - -### 修复的真实 bug -- `engine_b.py::_poll_db_once`:DB 故障恢复后若首轮查询为空,`db_active` 永不回 True(`if not msgs: return` 跳过置位)→ 查询成功即置 `db_active=True`(空返回前) - -### 验证 -- 语法:5 核心模块 py_compile 通过 -- GUI 卡片冒烟(`tmp/qt_engine_card_smoke.py`,offscreen):18 项全过(初始态/信号键集合/radio 置灰联动/设置加载校验/合并保存持久化) -- 引擎 B 三模式单测(`tmp/test_engine_b_modes.py`):14 项全过(json 只跑 JSON、db 只跑 DB、db 无源退化 JSON、parallel 双跑、DB 异常隔离+恢复、非法模式回落) -- 回归:`test_dual_engine.py` 31 项、`test_runtime_settings.py` 18 项、`test_qt_console_bridge.py` 14 项、`test_qt_capsule.py` 19 项全过 -- **测试适配**:`test_runtime_settings.py` 的 mock `poll_once()` 改为 `poll_once(scan_unread=True)`(gui_runtime 新调用契约) - -### 运行语义提示 -- GUI 改引擎开关:运行中修改→保存文件,**本轮监听结束后重启才完全生效**(BotThread 启动时读取) -- 引擎 A 关闭 ≠ 不回复:B 投递的消息由 A 的队列恢复通道照常定位发送,只是不再截图扫红点 - ---- - -## 修复:视觉定位"卡死"(bot 线程假死) - -### 现象 -用户截图显示任务卡在"正在视觉定位"(opening),日志在 `_find_next_unread_session` 检测到总未读后完全中断,bot 线程约 4-5 分钟无响应。 - -### 根因 -`_scroll_session_list_page` 滚动到底后,由于时间戳/动画等微小像素差异,`_session_page_signature` 认为页面不同,返回 `after` 而非 `None`。导致: -- `_find_pending_session` / `_find_next_unread_session` 持续翻页扫描 240 页(`SESSION_SCAN_MAX_PAGES`)或 45 秒超时 -- 4 个 pending 恢复任务 × 45 秒 = 3 分钟+/轮 -- 每轮结束后冷却期短(`SESSION_SCAN_COOLDOWN_SECONDS=15s`,失败按 `2^failures` 退避),任务反复被扫描 -- 日志长时间无输出,GUI 状态停滞,用户感知为"卡死" - -### 修复(wechat_bot.py) -1. `_session_pages_overlap_at_shift`:放宽 `shift` 边界检查从 `<=0` 到 `<0`,允许 `shift=0` 检测(同页内容完全匹配) -2. 新增 `_any_scroll_overlap(before, after)`:在 `0 ~ 2*item_h` 范围内遍历合理 shift,检测是否存在 >=90% 的内容重叠 -3. `_scroll_session_list_page`:签名比较后增加 `_any_scroll_overlap` 兜底——如果签名不同但无有效滚动重叠,返回 `None`(认为到底),阻止无效翻页 - -### 验证 -- 语法 py_compile 通过 -- `test_dual_engine.py` 31 项、`test_engine_b_modes.py` 14 项全过 -- `tmp/test_scroll_deadlock_fix.py`: - - 同页 shift=0 返回 True ✓ - - 时间戳微差(签名不同但无有效滚动)→ `_any_scroll_overlap` 返回 True → `_scroll_session_list_page` 会返回 None ✓ - - 真实滚动 72px → `_any_scroll_overlap` 返回 True,滚动仍被识别 ✓ - -### 影响 -- 修复后:滚动到底立即返回 None,不再做 45 秒无效扫描 -- 极少量场景(动画/加载导致大面积像素变化)可能提前结束扫描,遗漏极底部未读——但相比卡死 3 分钟+,可接受;下一轮轮询会重新扫描 - ---- - -## 修复:队列任务永远"处理中"(快速放弃机制) - -### 现象 -用户截图:3 个任务(一个小迷糊@微信/在线问诊/高瑞)全部 stage=opening、resume_failures=7/3/2,监听停止后 GUI 仍显示"处理中"。用户诉求:AI 回复完成就应移除任务,除非有新消息。 - -### 根因 -- 发送成功(sent)任务本就会 `_clear_reply_pending` 移除——但**卡在 opening 的任务没有快速放弃机制** -- `_UNREACHABLE_RESUME_FAILURES=8`:纯定位任务要失败 8 次才丢弃,加上 `2^failures` 指数退避(最长 600s),最坏情况任务挂几小时 -- 已生成 AI 回复(staged_reply_text 非空)却发不出去的任务,回复有时效性,继续挂着毫无意义 - -### 修复(wechat_bot.py) -1. 新增 `_STAGED_REPLY_EXPIRE_FAILURES = 3`:有 staged_reply_text 的任务失败 3 次即放弃(回复未发出、不落档,客户新消息会重新建单) -2. `_expire_unreachable_pending` 按是否有 staged_reply_text 选阈值:有回复→3,纯定位→8(保留原语义,防企微暂未开误删) -3. 放弃时打印区分原因(有过时回复 / 找不到会话) - -### 验证 -- 语法 py_compile 通过 -- `tmp/test_pending_expire.py` 7 项全过(staged 3 次放弃/2 次保留、纯定位 8/7 边界、放弃不落档、非法值与空白回复边界) -- 回归:`test_dual_engine.py` 31 项、`test_engine_b_modes.py` 14 项、`test_runtime_settings.py` 18 项全过 - -### 用户队列现状(修复后重启监听即生效) -- 一个小迷糊@微信(failures=7,有回复)→ 下次失败即达 3 → 放弃 -- 在线问诊(failures=3)→ 立即达阈值 → 放弃 -- 高瑞(failures=2)→ 再失败 1 次 → 放弃 - ---- - -## 任务池闭环验证(发送成功移除 + 新消息重新投递) - -用户确认诉求:AI 回复成功→任务移除;对方新消息→算新任务重新入队,任务池顺畅。 - -### 闭环语义(全部已确认成立) -- **发送成功(sent)→ `_clear_reply_pending` 移除任务**(`_resume_orphaned_pending_reply` 发送对账路径) -- **新消息 = 新 dedup_key**:`dedup_key = fp_hex:消息ts`,DB 消息在 `_poll_db_once` 归一化为 `{"content", "ts"}`(ts=send_time),新消息 ts 不同 → 不撞防抖 -- **`_recently` 300s 防抖只挡同一条消息**(同 dedup_key),新消息不受影响 -- **`has_active_pending` 对终态(sent/cancelled/expired/cleared)返回 False** → 任务移除后引擎 B 可重新投递 -- **队列已有活跃任务时引擎 B 只补 detected_by 标记不重复投递** - -### 验证 -- `tmp/test_queue_loop.py` 10 项全过:投递→防抖→发送移除→新消息重新投递→二次防抖→活跃不重复 -- 注意:测试数据字段用 `ts`(不是 `send_time`),`_msg_ts` 读 `msg["ts"]` -- 回归:`test_dual_engine.py` 31、`test_engine_b_modes.py` 14、`test_pending_expire.py` 7 全过 - - diff --git a/.workbuddy/memory/MEMORY.md b/.workbuddy/memory/MEMORY.md deleted file mode 100644 index 878c8af..0000000 --- a/.workbuddy/memory/MEMORY.md +++ /dev/null @@ -1,27 +0,0 @@ -# 项目长期记忆 — 企业微信 RPA 自动化 - -## 项目背景 -- 企业微信(WeCom)消息自动回复,核心:红点检测 → 会话定位 → 提取文本 → AI 回复 → GUI 发送。 -- 企微用自定义 GPU 渲染(UIA 节点=0),**无法**用 UIAutomation/win32gui 内部控件查询,只能截图 + 坐标。 -- 本地库(message.db 等)为 wxSQLite3 加密(文件头 `4fa4c7db855d54ad`),需内存提密钥 + 解密,普通 sqlite3 打不开。 -- 主 GUI:`wechat_gui_qt.py`(PySide6),后台运行时:`gui_runtime.py`(BotThread),核心:`wechat_bot.py`(13664 行,WeChatBot 类)。 -- AI 统一入口:`ai_chat.get_ai_reply(chat_text, image_bytes, history, *, force_vision, media_types)`,Dify 提供商(gpt-5.6-sol),`ai_settings.json` 配置。 - -## 双引擎架构(2026-08-21 落地) -- **引擎 A**(截图 RPA):红点识别 → 打开会话 → 视觉提取 → `_generate_ai_reply` → `send_reply`。发送收敛点。 -- **引擎 B**(数据直读,`engine_b.py`):**两路并行双跑、互为兜底**——① DB 直读(升级数据源)② `conversations.json`(引擎 A 视觉回写档案)每轮都独立检测;任一数据源有盲区另一路补漏,同一条消息靠 dedup_key 去重(fp_hex:时间戳,300s 防抖+队列级去重)只投一次 → `bot.enqueue_detected()` 投共享队列 → 由引擎 A 的 `_resume_orphaned_pending_reply` 统一处理。B 不碰窗口。两路游标独立:`_seen`(JSON)/`_seen_db`(DB),DB 失败仅停 DB 路(db_active=False)。 -- **DB 直读**(`wxwork_db.py`,Phase 2 主线,密钥已验证):密钥在 `wxwork_keys.json`(2 账号:`1688856770803435`→`db7288a302bfbe66563d81f025bde977`、`1688855555743233`→`d18e7f9a222665389989066f929ece19`,其余 9 账号无密钥/未登录)。解密缓存 `wxwork_decrypted/`,WAL 感知(帧同算法加密,可合并拿 checkpoint 前最新消息)。`get_new_messages(since_ts)` 秒级 send_time 增量查询,`is_personal_chat` 只留 M:/S: 单聊。fp_hex = `session_fp_from_name`(md5+blake2b 40 字节,与引擎 A identity_by_name 模式一致)。 -- **共享队列** `pending_replies.json`:字段白名单读写(`_load_pending_replies`/`_persist_pending_replies_unlocked`)。新字段必须两处透传!现有 44 字段含:dedup_key(去重)、detected_by(engine_a/engine_b)、detection_ts、sending_owner、send_lock_ts。 -- **发送互斥** `send_lock.py`:Windows 命名互斥量 `Global\WeChatBotSendLock` + 线程持有者跟踪。`send_reply()` 入口抢占,拿不到即让出。 -- 引擎开关(`app_settings.json`,GUI「检测引擎」卡片可改):`engine_a_enabled`(默认 true,注意键名不是 enable_engine_a!)、`enable_engine_b`(默认 true)、`engine_b_poll_interval`(2.0)、`engine_b_data_source`(parallel/db/json,非法回落 parallel)。运行时在 BotThread 启动时读取,GUI 改后本轮结束重启生效。 -- 引擎 A 关闭(`engine_a_enabled=false`)≠ 不回复:`_poll_once(scan_unread=False)` 跳过红点截图扫描,但队列恢复照常,B 投递的消息仍被定位发送。 - -## 关键约定 -- 队列任务 stage 状态机:queued→opening→reading→collecting→generating→ready_to_send→sending→sent,另有 manual_review/retry_wait/call_paused/uncertain。 -- 发送频率限制:`MAX_SENDS_PER_MINUTE=4`、`MAX_SENDS_PER_HOUR=60`(`_send_gate`)。 -- 测试注意:wechat_bot.py 依赖 win32gui/mss/numpy/pyautogui,**只能用系统 Python 3.11 跑**(`C:\Users\pc\AppData\Local\Programs\Python\Python311\python.exe`),managed python 3.13 无这些包。 -- 构造最小 bot 对象用 `WeChatBot.__new__(WeChatBot)` + 手工补 `_pending_lock/_pending_reply_sessions/_pending_reply_path/_cancelled_reply_sessions`。 - -## 待办/未来方向 -- Phase 2 DB 直读主线已打通(密钥就位 + WAL 合并 + 指纹对齐 + 引擎 B 集成),回归 31 项通过。剩余:长稳联跑验证(企微运行中轮询 WAL 增量 → 引擎 A 回复闭环)。 -- 机器人对接口子:ai_chat(已用)/ MCP 增强(AI_MCP_ENABLED + mcp_bridge)/ 外部 Agent(mcp_server.py)。 diff --git a/admin-web/apps/web-antd/src/api/console.ts b/admin-web/apps/web-antd/src/api/console.ts index 99ef6f0..0f6da0c 100644 --- a/admin-web/apps/web-antd/src/api/console.ts +++ b/admin-web/apps/web-antd/src/api/console.ts @@ -398,6 +398,8 @@ export interface DesktopConfig { /** 桌面客户端启动后从管理端读取的 ZYT 登录 API 基础地址 */ ZYT_LOGIN_API_URL: string; AI_REVIEW_RULES: ReviewRule[]; + /** 审核后发送的审核范围:true = 每条都审核;false = 按原规则(医疗助理人工回复后该会话恢复自动) */ + AI_REVIEW_EVERY_REPLY: boolean; } /** diff --git a/admin-web/apps/web-antd/src/views/console/desktop-config.vue b/admin-web/apps/web-antd/src/views/console/desktop-config.vue index 01aea74..4135a21 100644 --- a/admin-web/apps/web-antd/src/views/console/desktop-config.vue +++ b/admin-web/apps/web-antd/src/views/console/desktop-config.vue @@ -58,6 +58,7 @@ const form = reactive({ AI_MCP_MAX_ROUNDS: 5, AI_MCP_SERVERS: [], AI_REVIEW_RULES: [], + AI_REVIEW_EVERY_REPLY: false, AI_UI_GUARD_ENABLED: true, AI_USE_VISION: true, }); @@ -299,10 +300,36 @@ onMounted(load); + +

+ 只对切到「审核后发送」的客户端起作用;自动发送模式下只按下面的选择性审核规则拦截。 +

+
+ + {{ form.AI_REVIEW_EVERY_REPLY ? '每条都审核' : '按原规则(默认)' }} +
+

+ + +

+

+ 客户端默认跟随这里的设置,也可以在「自动化设置 → 审核后发送 → 审核范围」单独设置本机;1.5.3 起的桌面端生效,更早的版本保持按原规则。 +

+
+

命中任意一条,那一条回复才会停下来贴进企业微信输入框等人工确认,不会自动按回车; - 没命中的照常自动发送。关键词不区分大小写,客户这句话和模型准备发的回复, + 没命中的照常自动发送。客户这句话和模型准备发的回复, 沾上任意一边都算命中。

+

+ 关键词按包含匹配,忽略大小写、空格和标点(1.5.2 及更早的桌面端只忽略大小写);建议把客户的日常说法都填上,如 服用、怎么吃、用法、用量、饭前、饭后。 +

diff --git a/admin-web/apps/web-antd/src/views/console/model-plan.vue b/admin-web/apps/web-antd/src/views/console/model-plan.vue index 036df76..b7ccc40 100644 --- a/admin-web/apps/web-antd/src/views/console/model-plan.vue +++ b/admin-web/apps/web-antd/src/views/console/model-plan.vue @@ -42,11 +42,11 @@ const visionOptions = computed(() => const MODE_HELP: Record = { shadow: - '照常发主模型的回复,裁判只在后台打分、不改变任何行为。先量出现有回复的真实水平,再决定要不要花第二份钱。', + '照常发主模型的回复,裁判只打分、不参与挑选答案;被判高风险的回复仍转人工审核(1.5.2 及更早的桌面端不会)。先量出现有回复的真实水平,再决定要不要花第二份钱。', score_only: - '用裁判的绝对分和风险做路由:低分或高风险转人工审核,不做二选一。', + '裁判打绝对分并标风险,高风险转人工审核;不做二选一,不改变答案选择。', arbitrate: - '完整的 best-of-N:并发问多个模型,按裁判选出的赢家发送。成本约 2.3 倍。', + '完整的 best-of-N:并发问多个模型,按裁判选出的赢家发送,高风险同样转人工审核。成本约 2.3 倍。', }; async function load() { diff --git a/ai_chat.py b/ai_chat.py index f1848bf..841d099 100644 --- a/ai_chat.py +++ b/ai_chat.py @@ -168,9 +168,10 @@ def _gateway_completion( 对 `_chat_completion` 的所有调用方来说,走不走网关没有任何区别——MCP 的多轮 循环、视觉、Dify 兜底全部原样可用。 - 工具轮网关只问主出口、也不评审:工具跑在本机且有副作用(挂号登记会真建一条 - 记录),并发问多个模型会拿到互相冲突的 tool_calls。等工具跑完、模型给出真正 - 的答复时,那一轮不带 tools,best-of-N 和裁判照常生效。 + 工具轮网关只问主出口:工具跑在本机且有副作用(挂号登记会真建一条记录), + 并发问多个模型会拿到互相冲突的 tool_calls。返回 tool_calls 的那一轮不评审; + 带 tools 却直接给出答复的那一轮会被当作最终回复发出去,所以网关照样拿它过 + 裁判(单候选),裁判结果和普通轮一样记进追踪。 `purpose` 区分"这一次是在回客户"还是"界面识别之类的内部判断"。界面守卫每 轮轮询都要问一次模型,次数远多于真实对话;不打标记的话调用日志和调用统计 diff --git a/ai_config.py b/ai_config.py index 6ba68b4..7060ee2 100644 --- a/ai_config.py +++ b/ai_config.py @@ -68,9 +68,11 @@ AI_TIMEOUT = 120 # 请求超时秒数(本地模型推理较慢,给 # True → 回复前连接 AI_MCP_SERVERS,把它们的 tools 交给模型按需调用,再生成最终回复 # ── 多模型编排 ──────────────────────────────────────────────────────────────── # 裁判模型:对生成出来的回复打一个绝对质量分和风险等级。 -# shadow 照常发主模型的回复,评分只记录,不改变任何行为(默认) -# score_only 用评分和风险做路由(低分/高风险转审核),不做二选一 +# shadow 照常发主模型的回复并记录裁判结果(默认) +# score_only 裁判在发送前同步打分和标风险,不做二选一 # arbitrate 完整的 best-of-N,按裁判选出的赢家发送 +# 模式只决定发哪个候选:裁判判「高风险」的回复在任何模式下(含 shadow)都转人工审核。 +# 本机直连时影子评审在后台跑,结论赶在发送前回来才拦得住;走网关时裁判结果随回复一起返回。 # 默认 shadow:先量出现有回复的真实水平,再决定要不要花第二份钱。 AI_JUDGE_ENABLED = False AI_JUDGE_MODE = "shadow" @@ -85,6 +87,11 @@ AI_MCP_SERVERS: list = [] # 形状:[{"id": str, "label": str, "keywords": [str, ...], "enabled": bool}, ...] AI_REVIEW_RULES: list = [] +# 「审核后发送」的审核范围,由后台「客户端配置」统一下发:True = 每条都审核(医疗助理 +# 人工回复过的会话也不恢复自动);False = 按原规则。本机「自动化设置」里可以选择跟随 +# 这里,或单独设置本机(见 review_policy.review_every_reply)。 +AI_REVIEW_EVERY_REPLY: bool = False + # ── 智能体(角色)────────────────────────────────────────────────────────────── # 由后台「AI 模型 → 智能体」下发,本机不编辑。一个智能体 = 人设 + 一组规则, # 规则分 guide(补充指令)/ forbid(禁止措辞)/ reply(固定口径)三种,形状与 @@ -297,7 +304,7 @@ CONFIGURABLE_KEYS = [ "AI_MAX_TOKENS", "AI_TEMPERATURE", "AI_TIMEOUT", "AI_MCP_ENABLED", "AI_MCP_MAX_ROUNDS", "AI_MCP_SERVERS", "AI_JUDGE_ENABLED", "AI_JUDGE_MODE", - "AI_REVIEW_RULES", + "AI_REVIEW_RULES", "AI_REVIEW_EVERY_REPLY", "AI_AGENTS", "AI_AGENT_PLAN", "ARCHIVE_AUTO_BACKUP_ENABLED", "ARCHIVE_AUTO_BACKUP_INTERVAL_MINUTES", ] diff --git a/ai_settings.json b/ai_settings.json index 0519126..b067c96 100644 --- a/ai_settings.json +++ b/ai_settings.json @@ -44,7 +44,19 @@ "换药", "能不能吃", "剂量", - "血糖" + "血糖", + "怎么吃", + "怎么服", + "用法", + "用量", + "一天几次", + "几袋", + "饭前", + "饭后", + "空腹", + "温服", + "冲服", + "煎服" ], "enabled": true }, @@ -71,6 +83,7 @@ "enabled": true } ], + "AI_REVIEW_EVERY_REPLY": false, "AI_AGENTS": [ { "id": "health-advisor", diff --git a/app_settings.json b/app_settings.json index 35e1d73..c0090ae 100644 --- a/app_settings.json +++ b/app_settings.json @@ -8,7 +8,8 @@ "mouse_idle_enabled": true, "mouse_idle_seconds": 5.0, "send_delay_seconds": 1.0, - "send_mode": "auto", + "send_mode": "review", + "review_scope": "every", "reply_transport": "protocol", "message_batch_window_seconds": 5.0, "foreign_draft_autosend_minutes": 1.0, diff --git a/app_version.py b/app_version.py index 1a1012e..c02c9ce 100644 --- a/app_version.py +++ b/app_version.py @@ -7,7 +7,7 @@ import re from typing import Any -APP_VERSION = "1.5.2" +APP_VERSION = "1.5.4" _VERSION_PATTERN = re.compile( r"^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)" r"(?:[-+][0-9A-Za-z.-]+)?$" diff --git a/assets/ui/console-app.js b/assets/ui/console-app.js index 1700953..a2c4c25 100644 --- a/assets/ui/console-app.js +++ b/assets/ui/console-app.js @@ -578,7 +578,7 @@ function reviewAssistantPanel(a){ const recipientTitle = !recipientId ? "尚未从我的客户选择医疗助理" : nameKnown ? recipientName : "昵称未读取,请核对联系编号"; return `

医疗助理处理提醒

${r.enabled ? "当前账号已开启" : "当前账号未开启"}
-

客户会话进入待审核或需人工时,由当前托管企业微信账号向你从「通讯录 → 我的客户」中指定的医疗助理发送客户咨询、已有回复草稿和处理原因。

+

客户会话进入待审核、需人工处理或被转人工时,由当前托管企业微信账号向你从「通讯录 → 我的客户」中指定的医疗助理发送客户咨询、已有回复草稿和处理原因。

托管企微账号(最近核验)${esc(r.accountName || "尚未核验")}${r.accountId ? `${esc(r.accountId)}` : ""}
@@ -593,15 +593,48 @@ function reviewAssistantPanel(a){ ${r.reason ? `

${esc(r.reason)}

` : ""} ${r.recipientWarning ? `` : ""} ${r.message ? `

${esc(r.message)}

` : ""} - ${r.notification && r.notification.message ? `

最近提醒(读取账号时刷新):${esc(r.notification.message)}

` : ""} + ${r.notification && r.notification.message ? `

最近提醒:${esc(r.notification.message)}

` : ""}

待处理会话与原因

${(r.attention || []).length} 个
${(r.attention || []).map(item=>`
${esc(item.name)}${esc(item.status)}
${esc(item.conversation)}

进入原因:${esc(item.reason)}

`).join("") || '

当前账号暂无待审核或需人工处理的会话。

'}

设置按企微账号分别保存。选择或更换联系人后默认关闭,确认收件人后再开启;同名联系人按列表中的联系编号区分。

-

人工用同一企业微信账号直接回复客户,核验后任务标记为人工已完成;后续新消息恢复自动回复,仍逐条风控。此识别以账号发出的消息为准,不区分手机或电脑。在助理联系人会话中回复提醒,不会审批或完成客户任务。

+

人工用同一企业微信账号直接回复客户,核验后任务标记为人工已完成;${(STATE.sendMode || "auto") === "review" && a.reviewEveryReply === true ? "当前审核范围为“每条都审核”,后续新消息仍要人工审核。" : "后续新消息恢复自动回复,仍逐条风控。"}此识别以账号发出的消息为准,不区分手机或电脑。在助理联系人会话中回复提醒,不会审批或完成客户任务。

提醒内容示例(只读,不会发送)
${esc(r.preview || "请先读取当前账号")}
`; } +// 「高风险转人工」卡片的标签跟随后台下发的审核规则,只列启用的;模型裁判判为 +// 高风险一律转人工那条内置、关不掉,所以状态一直是“已开启”。 +const HANDOFF_RULE_ICONS = {"诊断":"shield","用药调整":"package","投诉退款":"coins","用法用量":"pill"}; +function handoffRuleTags(rules){ + const labels = (Array.isArray(rules) ? rules : []).filter(r=>r && r.enabled !== false) + .map(r=>String(r.label || "").trim() || "未命名规则"); + if (!labels.length) return `暂无启用的关键词规则`; + // 卡片和同排面板等高,规则一多整排都被撑高;超过 3 条只列前 2 条,其余收进“等 N 条”。 + const shown = labels.length > 3 ? labels.slice(0, 2) : labels; + const tags = shown.map(label=>`${icon(HANDOFF_RULE_ICONS[label] || "shield")} ${esc(label)}`); + if (shown.length < labels.length) tags.push(`${icon("shield")} 等 ${labels.length} 条规则`); + return tags.join(""); +} + +// 审核后发送的审核范围。按原规则:医疗助理人工回复并核验后该会话恢复自动(仍逐条风控); +// 每条都审核:人工回复只结束这一次审核,之后每条 AI 回复照样等人确认。默认跟随管理后台 +// 「客户端配置」的统一设置,也可以本机单独选。自动发送模式下不显示。 +function reviewScopePanel(a, autoOn){ + if (autoOn) return ""; + const scope = ["follow", "every", "rules"].includes(a.reviewScope) ? a.reviewScope : "follow"; + const every = a.reviewEveryReply === true; + const adminLabel = a.reviewEveryReplyAdmin === true ? "每条都审核" : "按原规则"; + const source = scope === "follow" ? "管理后台统一设置" : "本机单独设置"; + const option = (key, label) => ``; + return `

审核范围

${every?"每条都审核":"按原规则"} · ${source}
+
${option("follow", `跟随管理后台(${adminLabel})`)}${option("every", "每条都审核")}${option("rules", "按原规则")}
+

${every + ? "每条 AI 回复都要人工确认后才发送;医疗助理人工回复过的会话也不会恢复自动回复。" + : "医疗助理用同一企微账号人工回复并核验后,该会话恢复自动回复,之后仍逐条过审核规则和模型裁判;未配置医疗助理时每条都要人工确认。"}${scope === "follow" + ? "当前跟随管理后台「客户端配置」的统一设置,后台修改后自动同步到本机。" + : "本机已单独设置,不受管理后台统一设置影响;选“跟随管理后台”可恢复统一管理。"}

`; +} + automationView = function(){ if (STATE.demo) return _automationView(); const a = STATE.automation || {}; @@ -612,13 +645,13 @@ automationView = function(){ const ready = p.canSend === true && p.status === "native_ready" && p.databaseReady === true; return `
${head("自动化设置","协议模式 · 保留原员工账号与现有客户会话",``)}${transportPanel}
- ${reviewAssistantPanel(a)}

${ready?"协议自动回复已就绪":"协议模式尚未就绪"}

${esc(ready?"原账号文本单聊":p.label || "正在准备检测")}
+ ${reviewScopePanel(a, autoOn)}${reviewAssistantPanel(a)}

${ready?"协议自动回复已就绪":"协议模式尚未就绪"}

${esc(ready?"原账号文本单聊":p.label || "正在准备检测")}

启动后监听新到的文本消息,使用当前员工账号回复现有客户。审核模式下,回复保留在任务队列,点击“通过并发送”后发送。

支持 ${esc(p.supportedClient || "5.0.10.6023 x86、5.0.11.6018 x86、5.0.11.6026 x86")}。自动识别安装盘符和目录;其他企业微信版本、x64 客户端仍需单独适配。当前自动处理文本消息。

发送核对

客户补充消息时重新生成回复;人工已经回复时取消旧任务。发送结果不明确时保留该会话记录待核对,其他会话继续监听,防止重复发送。

协议模式按会话 ID 发送,不操作聊天窗口。切换账号或升级企业微信后,会重新校验可用性。

`; } - return `
${head("自动化设置","配置企业微信监听、消息合并与自动发送规则",`${esc(a.wecom || "企业微信未识别")}规则已生效`)}${transportPanel}
${reviewAssistantPanel(a)}

监听与发送策略

${icon("activity")} ● 规则运行中
${[["activity","扫描未读"],["log","提取消息"],["folder","合并消息"],["brain","请求 AI"],["send","回填发送"]].map(x=>`
${icon(x[0])}
${x[1]}
`).join("")}
${icon("clock")}扫描间隔  秒
${icon("hourglass")} 连续消息等待  秒
${icon("clock")}发送前等待  秒

企业微信窗口

✓
${icon("clipboard")} 主窗口:● ${esc(a.wecom || "未识别")}
${icon("user")} 当前账号:${esc(a.account || "—")}
${icon("globe")} DPI:${esc(STATE.dpi || "—")}
${icon("monitor")} 最小化恢复:● 已开启

人机共存

启用人工操作保护
鼠标静止  秒 后恢复
草稿超时直发
输入框里有人工草稿  0 ? "" : "disabled"}> 分钟后直接发出
关闭时只跳过该会话、绝不动别人写的字;命中审核规则的仍会等人确认
${icon("bot")}
AI 运行中
${icon("cursor")}
${icon("pause")}
检测到人工操作
AI 暂停

消息处理

✓ 同一客户连续消息自动合并
✓ 保留最近 轮上下文${esc(a.context || 8)} 轮
✓ 一次只处理 1 个会话1 个

异常与兜底

${icon("clock")}AI 超时:${esc(a.timeout || 120)} 秒后重试2 次
${icon("alert")}发送失败:自动重试已开启
${icon("message")}固定回复:${esc(a.reply || "在的,请稍等")}

高风险转人工

● 已开启
${icon("shield")} 诊断${icon("package")} 用药调整${icon("coins")} 投诉退款

启动前检查

${statusCells([["check","企业微信已登录", STATE.wecomConnected ? "检查完成" : "等待连接"],["cloud","AI 服务正常","检查完成"],["activity","窗口坐标已校准", STATE.wecomConnected ? "检查完成" : "待校准"],["shield","规则配置有效","检查完成"]])}
`; + return `
${head("自动化设置","配置企业微信监听、消息合并与自动发送规则",`${esc(a.wecom || "企业微信未识别")}规则已生效`)}${transportPanel}
${reviewScopePanel(a, autoOn)}${reviewAssistantPanel(a)}

监听与发送策略

${icon("activity")} ● 规则运行中
${[["activity","扫描未读"],["log","提取消息"],["folder","合并消息"],["brain","请求 AI"],["send","回填发送"]].map(x=>`
${icon(x[0])}
${x[1]}
`).join("")}
${icon("clock")}扫描间隔  秒
${icon("hourglass")} 连续消息等待  秒
${icon("clock")}发送前等待  秒

企业微信窗口

✓
${icon("clipboard")} 主窗口:● ${esc(a.wecom || "未识别")}
${icon("user")} 当前账号:${esc(a.account || "—")}
${icon("globe")} DPI:${esc(STATE.dpi || "—")}
${icon("monitor")} 最小化恢复:● 已开启

人机共存

启用人工操作保护
鼠标静止  秒 后恢复
草稿超时直发
输入框里有人工草稿  0 ? "" : "disabled"}> 分钟后直接发出
关闭时只跳过该会话、绝不动别人写的字;命中审核规则的仍会等人确认
${icon("bot")}
AI 运行中
${icon("cursor")}
${icon("pause")}
检测到人工操作
AI 暂停

消息处理

✓ 同一客户连续消息自动合并
✓ 保留最近 轮上下文${esc(a.context || 8)} 轮
✓ 一次只处理 1 个会话1 个

异常与兜底

${icon("clock")}AI 超时:${esc(a.timeout || 120)} 秒后重试2 次
${icon("alert")}发送失败:自动重试已开启
${icon("message")}固定回复:${esc(a.reply || "在的,请稍等")}

高风险转人工

● 已开启
${handoffRuleTags(a.reviewRules)}

启动前检查

${statusCells([["check","企业微信已登录", STATE.wecomConnected ? "检查完成" : "等待连接"],["cloud","AI 服务正常","检查完成"],["activity","窗口坐标已校准", STATE.wecomConnected ? "检查完成" : "待校准"],["shield","规则配置有效","检查完成"]])}
`; }; logsView = function(){ @@ -1547,6 +1580,7 @@ document.addEventListener("click", e => { "verify-protocol-send": () => callBridge("validateProtocolSend"), "export-protocol": () => callBridge("exportProtocolReport"), "send-mode": () => callBridge("setSendMode", key), + "review-scope": () => callBridge("setReviewScope", key), "toggle-idle": () => callBridge("toggleIdle"), "toggle-draft-autosend": () => { // 派发器不给回调传参,元素用闭包里的 action。先本地切一下让点击立刻有 diff --git a/backend_client.py b/backend_client.py index 9cdf76b..0ef92ce 100644 --- a/backend_client.py +++ b/backend_client.py @@ -84,6 +84,12 @@ _LOCK = threading.RLock() _PATIENT_AUTH_LOCK = threading.Lock() _PATIENT_KEEPALIVE_LOCK = threading.Lock() _PATIENT_KEEPALIVE_LAST: dict[str, Any] = {} +# ZYT 患者查询令牌只在到期前最后 1 小时内被访问才续期。界面计时器 30 分钟一次, +# 节流必须比它短,否则每隔一次才真正请求(实际 60 分钟一次),续期窗口里失败一次 +# 令牌就会过期。 +PATIENT_KEEPALIVE_INTERVAL_SECONDS = 25 * 60 +# 没问到 ZYT(网络失败、答复不明)不算保活过,5 分钟后就允许重试。 +PATIENT_KEEPALIVE_RETRY_SECONDS = 5 * 60 _SENSITIVE_NAME_PARTS = ( "api_key", "apikey", @@ -128,6 +134,20 @@ class PatientSessionExpired(BackendError): super().__init__(message, status=status, code="zyt_session_expired") +class PatientQueryRejected(BackendError): + """ZYT 拒绝了客服后台代查患者/订单(登录 IP 校验,后台 409 zyt_ip_restricted)。 + + 不能归到 PatientSessionExpired:重新验证只会把 ZYT 令牌再绑回本机出口 IP, + 下一次查询照样被拒;也不是桌面登录失效,不能归到 AuthenticationError。 + """ + + def __init__(self, message: str = "", *, status=None): + super().__init__( + message or "ZYT 拒绝了客服后台的患者查询(登录 IP 校验),重新验证无法解决,请联系管理员。", + status=status, code="zyt_ip_restricted", + ) + + class RemotePermissionDenied(BackendError): """服务端按 ZYT 权限拒绝了远程控制台相关操作(例如没有移出黑名单的权限)。 @@ -652,7 +672,9 @@ def _request( error_code = str((detail.get("code") if isinstance(detail, dict) else None) or data.get("code") or "") if isinstance(detail, dict): - detail = detail.get("message") or detail.get("msg") or detail.get("error") or "" + # 订单接口的 message 是给模型的中性口径,给客服看的说明在 staff_message。 + detail = (detail.get("staff_message") or detail.get("message") or detail.get("msg") + or detail.get("error") or "") if isinstance(detail, list): detail = ";".join( str(item.get("msg") if isinstance(item, dict) else item) @@ -669,6 +691,10 @@ def _request( ) legacy_expired = (patient_path and exc.code == 502 and message.strip().rstrip("。.!!") == "登录超时,请重新登录") + if error_code == "zyt_ip_restricted": + # 后台没带说明时用默认文案,不能只剩一个“HTTP 409”。 + raise PatientQueryRejected("" if message == f"HTTP {exc.code}" else message, + status=exc.code) from exc if error_code == "zyt_session_expired" or legacy_expired: raise PatientSessionExpired(message, status=exc.code) from exc if exc.code == 403 and patient_path: @@ -1206,7 +1232,10 @@ def reauthenticate_patient_session(password: str, *, timeout: float = 12.0) -> d def keepalive_zyt_session(*, timeout: float = 8.0) -> dict[str, Any]: - """Touch an existing ZYT session at most every 30 min; never log in or log out.""" + """Touch an existing ZYT session at most every 25 min (5 min after a failure); never log in or log out. + + 节流时间在请求结束后才记下:以前请求前就记,一次失败就白白占掉整个间隔。 + """ if not _PATIENT_KEEPALIVE_LOCK.acquire(blocking=False): return {"status": "skipped", "reason": "in_progress"} try: @@ -1214,9 +1243,9 @@ def keepalive_zyt_session(*, timeout: float = 8.0) -> dict[str, Any]: identity = (*_desktop_session_identity(snapshot), str(snapshot.get("zyt_token_protected") or "")) now = time.monotonic() if (_PATIENT_KEEPALIVE_LAST.get("identity") == identity - and now - float(_PATIENT_KEEPALIVE_LAST.get("at", 0)) < 1800): + and now - float(_PATIENT_KEEPALIVE_LAST.get("at", 0)) + < float(_PATIENT_KEEPALIVE_LAST.get("wait", PATIENT_KEEPALIVE_INTERVAL_SECONDS))): return {"status": "skipped", "reason": "throttled"} - _PATIENT_KEEPALIVE_LAST.update(identity=identity, at=now) if not _unprotect_secret(snapshot.get("desktop_token_protected")): return {"status": "desktop_invalid", "message": "桌面账号尚未登录"} try: @@ -1225,6 +1254,7 @@ def keepalive_zyt_session(*, timeout: float = 8.0) -> dict[str, Any]: except AuthenticationError: return {"status": "desktop_invalid", "message": "桌面登录已失效,请重新登录"} except BackendError as exc: + _PATIENT_KEEPALIVE_LAST.update(identity=identity, at=now, wait=PATIENT_KEEPALIVE_RETRY_SECONDS) return {"status": "unreachable", "message": str(exc)} zyt_token = _unprotect_secret(current.get("zyt_token_protected")) if not zyt_token: @@ -1256,6 +1286,10 @@ def keepalive_zyt_session(*, timeout: float = 8.0) -> dict[str, Any]: current = load_settings() if ((*_desktop_session_identity(current), str(current.get("zyt_token_protected") or "")) != identity): return {"status": "skipped", "reason": "session_changed"} + # ZYT 给出了明确答复才按正常间隔节流;连不上或答复不明时 5 分钟后就可以再试。 + _PATIENT_KEEPALIVE_LAST.update(identity=identity, at=now, wait=( + PATIENT_KEEPALIVE_RETRY_SECONDS if result["status"] == "unreachable" + else PATIENT_KEEPALIVE_INTERVAL_SECONDS)) return result finally: _PATIENT_KEEPALIVE_LOCK.release() diff --git a/gui_runtime.py b/gui_runtime.py index 545ea13..64536d3 100644 --- a/gui_runtime.py +++ b/gui_runtime.py @@ -93,6 +93,13 @@ def normalize_send_mode(value, default=SEND_MODE_AUTO): return SEND_MODE_REVIEW if default == SEND_MODE_REVIEW else SEND_MODE_AUTO +def normalize_review_scope(value): + """本机审核范围(只在审核后发送模式下起作用):follow = 跟随管理后台下发的设置(默认), + every = 每条都审核,rules = 按原规则(医疗助理人工回复并核验后该会话恢复自动)。""" + from review_policy import normalize_review_scope as normalize + return normalize(value) + + def cancel_assistant_review_for_state(state, root): """Close only the explicitly cancelled episode; never start native I/O.""" if not isinstance(state, dict) or not state.get("assistant_review_id"): @@ -205,7 +212,10 @@ def delete_pending_reply_file(keys, path="", *, handoff=False, confirm_uncertain return result for _key, state in removed: - cancel_assistant_review_for_state(state, directory) + if handoff: + handoff_assistant_review_for_state(state, directory) + else: + cancel_assistant_review_for_state(state, directory) result["deleted"] = [key for key, _state in removed] result["missing"] = sorted(requested.difference(result["deleted"]).difference(result["protected"])) try: @@ -225,6 +235,34 @@ def delete_pending_reply_file(keys, path="", *, handoff=False, confirm_uncertain return result +def handoff_assistant_review_for_state(state, root, db=None): + """转人工也提醒医疗助理;提醒没开启或核对不了会话时按原方式取消提醒。返回是否已登记提醒。 + + 只登记(或把已有的待审提醒改成转人工),不在这里发送:发送由监听中的医疗助理提醒线程完成, + 监听没开时等下次开始监听再发。""" + if not isinstance(state, dict): + return False + event = state.get("database_event") or {} + account = str(state.get("account") or event.get("account") or "") + coordinator = None + notified = False + if account: + try: + from review_assistant import ReviewAssistantCoordinator + coordinator = ReviewAssistantCoordinator(root=root, account=account, db=db) + notified = bool(coordinator.notify_handoff(state)) + except Exception as exc: + print(f"[助理审核] 转人工提醒登记失败({type(exc).__name__}),按原方式结束提醒") + finally: + if coordinator is not None: + coordinator.close() + if notified: + print("[助理审核] 已转人工,已登记给医疗助理的提醒") + return True + cancel_assistant_review_for_state(state, root) + return False + + def handoff_pending_reply_file(keys, path="", *, confirm_uncertain=False): """Retire stopped work after explicit human takeover; preserve send evidence.""" result = delete_pending_reply_file(keys, path, handoff=True, confirm_uncertain=confirm_uncertain) @@ -398,6 +436,7 @@ class BotThread(threading.Thread): message_batch_window_seconds=MESSAGE_BATCH_WINDOW_SECONDS, send_delay_seconds=SEND_DELAY_SECONDS, send_mode=SEND_MODE_AUTO, + review_scope="follow", foreign_draft_autosend_minutes=FOREIGN_DRAFT_AUTOSEND_MINUTES, enable_engine_b=True, engine_b_poll_interval=2.0, @@ -426,6 +465,8 @@ class BotThread(threading.Thread): self.set_send_delay_seconds(send_delay_seconds) self.send_mode = SEND_MODE_AUTO self.set_send_mode(send_mode) + self.review_scope = "follow" + self.set_review_scope(review_scope) self.foreign_draft_autosend_minutes = FOREIGN_DRAFT_AUTOSEND_MINUTES self.set_foreign_draft_autosend_minutes(foreign_draft_autosend_minutes) self.stop_event = threading.Event() @@ -472,6 +513,14 @@ class BotThread(threading.Thread): if bot is not None: bot.send_mode = mode + def set_review_scope(self, value): + """本机审核范围:跟随管理后台 / 每条都审核 / 按原规则(只影响之后的回复)。""" + scope = normalize_review_scope(value) + self.review_scope = scope + bot = getattr(self, "bot", None) + if bot is not None: + bot.review_scope = scope + def _report_progress(self, text): """把机器人此刻在做什么送到界面上那行进度文字。""" try: @@ -720,6 +769,7 @@ class BotThread(threading.Thread): bot.message_batch_window_seconds = self.message_batch_window_seconds bot.send_delay_seconds = self.send_delay_seconds bot.send_mode = self.send_mode + bot.review_scope = self.review_scope bot.foreign_draft_autosend_minutes = self.foreign_draft_autosend_minutes bot._stop_check = self.stop_event bot.safe_window_mode = True @@ -795,6 +845,10 @@ class BotThread(threading.Thread): "(AI 只把回复填进输入框,不会自动按回车;" "需要自动发送请在设置里切到“自动发送”)" ) + print("[+] 审核范围:" + { + "every": "本机设为每条都审核(人工回复过的会话也不恢复自动)", + "rules": "本机设为按原规则(医疗助理人工回复后该会话恢复自动,仍逐条风控)", + }.get(self.review_scope, "跟随管理后台统一设置")) else: print("[+] 发送模式:自动发送(通过全部安全校验后自动按回车)") try: @@ -826,6 +880,7 @@ class BotThread(threading.Thread): bot.message_batch_window_seconds = self.message_batch_window_seconds bot.send_delay_seconds = self.send_delay_seconds bot.send_mode = self.send_mode + bot.review_scope = self.review_scope bot.foreign_draft_autosend_minutes = self.foreign_draft_autosend_minutes # 引擎 A 开关:关闭时跳过红点截图扫描,只保留队列恢复 # (引擎 B 投递的待回复任务仍会被捡起并发送)。 @@ -930,6 +985,7 @@ class BotThread(threading.Thread): bot.message_batch_window_seconds = self.message_batch_window_seconds bot.send_delay_seconds = self.send_delay_seconds bot.send_mode = self.send_mode + bot.review_scope = self.review_scope try: bot.poll_once() except Exception as exc: diff --git a/model_router.py b/model_router.py index 6cb1550..e6c8413 100644 --- a/model_router.py +++ b/model_router.py @@ -6,9 +6,12 @@ Claude 各自的请求形状),这里是策略层(同时问谁、谁来评 变更节奏完全不同——加一家模型厂商动的是前者,调整评审策略动的是后者。 编排的三档模式,对应灰度路径: - shadow 照常发主模型的回复,裁判结果只记录,不改变任何行为 - score_only 用裁判的绝对分和风险做路由(低分/高风险转审核),不做二选一 + shadow 照常发主模型的回复并记录裁判结果,裁判在后台跑、不挡回复路径 + score_only 裁判在返回回复前同步打绝对分和标风险,不做二选一 arbitrate 完整的 best-of-N,按裁判选出的赢家发送 + +模式只决定发哪个候选。裁判判「高风险」的回复在任何模式下(含 shadow)都由 +发送闸(review_policy)转人工审核;影子评审的结论要赶在发送前回来才拦得住。 """ from __future__ import annotations @@ -271,9 +274,10 @@ def answer( return result if mode == "shadow" and judge_provider is not None: - # 影子模式下裁判说什么都不改变发送内容——那就绝不该让它挡在回复路径上。 - # 客户不该为一次"只用来看数据"的评审多等 1~3 秒。丢到后台线程去跑, - # 结果通过回调登记;进程退出时没跑完就算了,少一条观测数据而已。 + # 影子模式下裁判不改变发哪条候选——那就不该让它挡在回复路径上。 + # 客户不该为这次评审多等 1~3 秒。丢到后台线程去跑,结果通过回调登记; + # 赶在发送闸之前登记的"高风险"仍会把回复拦下转人工,来晚了就只是一条 + # 观测数据。进程退出时没跑完就算了。 result["reply"] = usable[0].text result["chosen"] = usable[0].provider result["total_ms"] = int((time.monotonic() - started) * 1000) @@ -321,8 +325,8 @@ def answer( # 后台评审的并发上限。 # -# 影子模式下回复已经发出去了,评审只是补一个分数——它可以慢,但绝不能把机器 -# 拖垮。客户消息一波来十几条时,没有这道闸就会瞬间起十几个线程同时打模型。 +# 影子模式下回复不等评审(多数时候已经发出去了),评审主要是补一个分数—— +# 它可以慢,但绝不能把机器拖垮。客户消息一波来十几条时,没有这道闸就会瞬间起十几个线程同时打模型。 _SHADOW_LIMIT = threading.Semaphore(2) # 后台评审的单次时限。比正常调用短:这条链路上没人在等它,超时就放弃, @@ -360,7 +364,7 @@ def _spawn_shadow_judge(customer_text, usable, judge_provider, on_verdict, snaps return print( f" [裁判·影子] 绝对分 {verdict.score:.2f}|风险 {verdict.risk}|" - f"{verdict.reason or '无说明'}(不改变已发送内容)" + f"{verdict.reason or '无说明'}(不改变发送的候选;高风险且回复未发出时会转人工)" ) if callable(on_verdict): try: diff --git a/pending_replies.protocol.json b/pending_replies.protocol.json index ac1e167..19e4093 100644 --- a/pending_replies.protocol.json +++ b/pending_replies.protocol.json @@ -1,12 +1,107 @@ { "schemaVersion": 1, "transport": "protocol", - "pending": {}, + "pending": { + "6d1ec624fdfb16346e861e0b067f36f1aeb8cf94bb91f2345878d70eab280c452e4e7340465194c6": { + "transport": "protocol", + "account": "1688856770803435", + "conv_id": "S:1688856770803435_7881301475099806", + "display_name": "一个小迷糊", + "dedup_key": "1688856770803435:S:1688856770803435_7881301475099806:server:1025932", + "created_at": 1790767576.232064, + "updated_at": 1790767593.2703946, + "ready_at": 1790767581.232064, + "stage": "awaiting_review", + "stage_started_at": 1790767593.2703946, + "send_state": "", + "chat_text": "一个小迷糊 2026/09/17 11:41:25\n1\n一个小迷糊 2026/09/18 14:16:23\n[语音转文字] 你吃饭了没有?\n一个小迷糊 2026/09/18 14:18:34\n[语音转文字] 你在干什么?\n一个小迷糊 2026/09/18 14:19:35\n?\n一个小迷糊 2026/09/18 14:20:18\n??\n一个小迷糊 2026/09/18 15:06:05\n[语音转文字] 你在做什么?\n我 2026/09/18 15:06:45\n刚吃过午饭,这会儿正整理几位老患者的血糖随访记录呢,你这会儿是闲下来没事啦?\n一个小迷糊 2026/09/18 18:19:56\n[语音转文字] 你在做什么呀?咱们聊聊天好不好?\n我 2026/09/18 18:20:28\n这会儿刚把手头的随访记录整理完,正闲下来呢,你想聊点啥呀?\n一个小迷糊 2026/09/22 17:34:03\n帮我查询下我的快递到哪里了\n一个小迷糊 2026/09/22 17:34:31\n?\n我 2026/09/22 17:34:50\n我这边帮您去后台核实下物流状态,麻烦您把对应的订单号发我一下可以吗?\n一个小迷糊 2026/09/22 17:48:42\n查了吗\n我 2026/09/22 17:49:03\n我正在后台帮您核实物流信息呢,稍等一小会儿,查到了马上就告诉你哈。\n一个小迷糊 2026/09/22 17:49:19\n有结果吗\n我 2026/09/22 17:49:40\n还在后台核实呢,物流那边的反馈稍慢一点,我这边一查到消息马上就告诉你哈。\n一个小迷糊 2026/09/22 17:51:23\n再查下下\n我 2026/09/22 17:51:42\n我正盯着后台刷新查呢,这会儿还没出最新的物流轨迹,您再稍等一小会儿,查到我第一时间跟您说。\n一个小迷糊 2026/09/22 17:52:47\n你没查吗\n一个小迷糊 2026/09/22 18:05:13\n帮我查询物流到哪里了\n我 2026/09/22 18:05:32\n我这边正加急帮您在后台核实物流状态,一查到最新的轨迹消息我马上就通知您。\n一个小迷糊 2026/09/22 18:08:24\n在查询下\n我 2026/09/22 18:08:44\n我这就帮您再去后台刷新一遍最新的物流信息,一查到结果我立刻就跟您说,不会耽误的。\n一个小迷糊 2026/09/22 18:34:44\n查询我的药到哪里了\n我 2026/09/22 18:35:12\n我这边查到您有两笔订单,一笔是9月5日的已经履约完成,另一笔是今天刚下的还在待审核,您是要查哪一笔的物流呀?\n一个小迷糊 2026/09/22 18:35:34\n9月5号的\n我 2026/09/22 18:35:55\n9月5号的那笔订单显示已经履约签收完成了,您这边是没收到对应的包裹吗?\n一个小迷糊 2026/09/30 18:47:18\n在吗\n我 2026/09/30 18:48:25\n嗯\n一个小迷糊 2026/09/30 18:48:49\n在搞\n一个小迷糊 2026/09/30 19:05:05\n在吗\n一个小迷糊 2026/09/30 19:08:01\n在吗\n一个小迷糊 2026/09/30 19:08:16\n在不\n一个小迷糊 2026/09/30 19:10:17\n壁布\n一个小迷糊 2026/09/30 19:11:06\n1\n我 2026/09/30 19:15:12\n嗯\n一个小迷糊 2026/09/30 19:15:31\n的\n一个小迷糊 2026/09/30 19:16:37\n的\n一个小迷糊 2026/09/30 19:21:36\n的\n一个小迷糊 2026/09/30 19:24:44\n6\n一个小迷糊 2026/09/30 19:25:34\n在干嘛\n一个小迷糊 2026/09/30 19:26:13\n的", + "last_lines": [ + "的", + "的", + "的", + "6", + "在干嘛", + "的" + ], + "staged_user_text": "的\n的\n的\n6\n在干嘛\n的", + "detected_by": "protocol_db", + "detection_ts": 1790767576.232064, + "reply_text": "刚忙完手头的事坐着歇会儿呢,你这是打字手滑按错啦?", + "awaiting_review": true, + "content_type": 2, + "database_event": { + "account": "1688856770803435", + "conv_id": "S:1688856770803435_7881301475099806", + "fp_hex": "6dccb425b05ea2a5eb7d4801c8f9bedb022b8d16c0e78ee9ae7854e224a0d465e786c77ab56b59b2", + "display_name": "一个小迷糊", + "sender_id": "7881301475099806", + "is_self": false, + "content": "的", + "content_type": 2, + "content_status": "decoded", + "content_kind": "text", + "send_time": 1790767573.0, + "server_id": "1025932", + "rowid": 1107, + "dedup_key": "1688856770803435:S:1688856770803435_7881301475099806:server:1025932" + }, + "assistant_resume_evidence": null, + "contact_retry_evidence": { + "account": "1688856770803435", + "conv_id": "S:1688856770803435_7881301475099806", + "anchor": { + "account": "1688856770803435", + "conv_id": "S:1688856770803435_7881301475099806", + "send_time": 1789440491.0, + "rowid": 577, + "server_id": "1023389", + "dedup_key": "1688856770803435:S:1688856770803435_7881301475099806:server:1023389" + }, + "rejected_at": 0.0 + }, + "voice_batch_fingerprint": "", + "stage_detail": "本会话仍有待处理审核,请由医疗助理回复客户", + "last_error": "", + "model_task_id": "5ef2bdd950f84d8faf563b9d3c74201f", + "judge_risk": "low", + "judge_mode": "shadow", + "knowledge_trace": { + "enabled": false, + "hits": [], + "mode": "disabled", + "elapsed_ms": 0 + }, + "staged_reply_text": "刚忙完手头的事坐着歇会儿呢,你这是打字手滑按错啦?", + "send_ready_at": 1790767594.2633948, + "review_reason": "本会话仍有待处理审核,请由医疗助理回复客户", + "manual_required": false, + "manual_reason": "", + "review_every_reply": true, + "assistant_review_id": "e6091e48c5d345b9afc1617a5a355130" + } + }, "seen": { - "867c0f9edab03760a7569ee3ad842a2559ed3b02aa3735f0936fe79646b4d1bf29dfce48d3d521b8": "1688856770803435:S:1688856770803435_7881301579925075:server:1023678", - "6d1ec624fdfb16346e861e0b067f36f1aeb8cf94bb91f2345878d70eab280c452e4e7340465194c6": "1688856770803435:S:1688856770803435_7881301475099806:server:1024742" + "867c0f9edab03760a7569ee3ad842a2559ed3b02aa3735f0936fe79646b4d1bf29dfce48d3d521b8": "1688856770803435:S:1688856770803435_7881301579925075:server:1025935", + "6d1ec624fdfb16346e861e0b067f36f1aeb8cf94bb91f2345878d70eab280c452e4e7340465194c6": "1688856770803435:S:1688856770803435_7881301475099806:server:1025932" + }, + "contactBlocked": { + "6d1ec624fdfb16346e861e0b067f36f1aeb8cf94bb91f2345878d70eab280c452e4e7340465194c6": { + "schemaVersion": 2, + "account": "1688856770803435", + "conv_id": "S:1688856770803435_7881301475099806", + "anchor": { + "account": "1688856770803435", + "conv_id": "S:1688856770803435_7881301475099806", + "send_time": 1789440491.0, + "rowid": 577, + "server_id": "1023389", + "dedup_key": "1688856770803435:S:1688856770803435_7881301475099806:server:1023389" + }, + "rejected_at": 0.0, + "observed_at": 1790765291.1628551, + "skipped_event": "1688856770803435:S:1688856770803435_7881301475099806:server:1025843" + } }, - "contactBlocked": {}, "manual_handoffs": { "867c0f9edab03760a7569ee3ad842a2559ed3b02aa3735f0936fe79646b4d1bf29dfce48d3d521b8": { "state": { diff --git a/protocol-validation-reports/main-1790765178357980000.json b/protocol-validation-reports/main-1790765178357980000.json new file mode 100644 index 0000000..5f0b122 --- /dev/null +++ b/protocol-validation-reports/main-1790765178357980000.json @@ -0,0 +1,25 @@ +{ + "appVersion": "1.5.3", + "checkedAt": 1790765178.365982, + "status": "confirmed", + "automaticListenerStarted": false, + "clientVersion": "5.0.11.6029", + "clientSha256": "f46dbfb0059d4527b76b8dd3dfcd1dd45604c5ba257af80c064e4896e02cf50e", + "nativeAdapter": "wxwork-5.0.11.6029-x86", + "target": "高瑞", + "receipt": { + "messageId": 1085, + "serverId": 1025833, + "accountId": "1688856770803435", + "conversationId": "S:1688856770803435_7881301579925075", + "nativeCallback": "success", + "clientVersion": "5.0.11.6029", + "clientSha256": "f46dbfb0059d4527b76b8dd3dfcd1dd45604c5ba257af80c064e4896e02cf50e", + "adapterRevision": "relocated-text-v1", + "status": "confirmed", + "senderVerified": true, + "textVerified": true, + "confirmedAt": 1790765181.5129552 + }, + "requestId": "manual-verification:build:f46dbfb0059d4527b76b8dd3dfcd1dd45604c5ba257af80c064e4896e02cf50e:relocated-text-v1:5.0.11.6029:1688856770803435:S:1688856770803435_7881301579925075" +} \ No newline at end of file diff --git a/protocol_engine.py b/protocol_engine.py index 272d7d1..7732e2a 100644 --- a/protocol_engine.py +++ b/protocol_engine.py @@ -117,6 +117,8 @@ class ProtocolBot: self.sender=sender or NativeSender(self.db,application_data_dir()/'protocol_sends.sqlite3') self.generate=generate or self._generate self.message_batch_window_seconds=8.;self.send_delay_seconds=2.;self.send_mode='auto' + # 本机审核范围:follow = 跟随管理后台(默认),every = 每条都审核,rules = 按原规则 + self.review_scope='follow' self.reply_count=0;self.false_pos_rows=[];self.security_verification_required=False self._window_ready=True;self._reply_wakeup=threading.Event();self.needs_attention=False self._since=time.time();self._pending={};self._seen={};self._contact_blocked={};self._manual_handoffs={};self._assistant_cancellations={} @@ -781,12 +783,13 @@ class ProtocolBot: self._save() review,reason=self._needs_review(state) if review and not state.get('approved'): - if not state.get('awaiting_review') or state.get('review_reason')!=reason: - with self._lock:state.update(awaiting_review=True,review_reason=reason,manual_required=False,manual_reason='') + every=self._review_every_reply() + if not state.get('awaiting_review') or state.get('review_reason')!=reason or bool(state.get('review_every_reply'))!=every: + with self._lock:state.update(awaiting_review=True,review_reason=reason,manual_required=False,manual_reason='',review_every_reply=every) self._stage(key,'awaiting_review',reason) return if not review and (state.get('awaiting_review') or state.get('review_reason')): - with self._lock:state.update(awaiting_review=False,review_reason='') + with self._lock:state.update(awaiting_review=False,review_reason='',review_every_reply=False) self._stage(key,'ready_to_send','审核策略已更新,等待发送前核对') if time.time() dict: return {"ok": False, "reason": str(exc)[:300], "recipient": None} -def notification_preview(account="当前企微账号", recipient=None) -> str: +def notification_preview(account="当前企微账号", recipient=None, every_reply=False) -> str: + after = "当前为每条都审核,后续新消息仍要人工审核。" if every_reply else "后续自动回复仍逐条风控。" return ("【客户待审核提醒】\n" f"托管企微账号:{account}\n" "客户:示例客户(实际提醒包含会话标识)\n" "客户咨询:这里显示本轮待处理的客户消息\n" "待发送回复:这里显示 AI 生成、尚未发送的回复\n" "审核原因:这里显示命中的审核原因\n" - "请用同一企业微信账号直接回复该客户,结束本次审核。后续自动回复仍逐条风控。\n" + "请用同一企业微信账号直接回复该客户,结束本次审核。" + after + "\n" "——以上仅为内容示例,不会发送消息。") diff --git a/review_policy.py b/review_policy.py index 37ec63b..1a776dc 100644 --- a/review_policy.py +++ b/review_policy.py @@ -1,70 +1,84 @@ -"""Shared review decisions; model observation never grants or consumes approval.""" +"""Shared review decisions; model observation never grants or consumes approval. -MODES = frozenset({'shadow', 'score_only', 'arbitrate'}) +A judge verdict of risk 'high' holds the reply for a human in every judge mode +(shadow, score_only, arbitrate, or a verdict recorded without a mode). The admin +「客户端配置」 page promises this built-in rule is always on and cannot be turned +off; the judge mode only decides which candidate is sent, not whether a +high-risk reply may go out unreviewed. +""" +import re +import string +import unicodedata + +# Older backends may deliver a pasted "服用,用法" as one keyword. +_KEYWORD_SEPARATORS = re.compile(r'[,,、;;]') +_ASCII_PUNCTUATION = frozenset(string.punctuation) +# Unicode punctuation, separators and invisible format marks (zero-width space). +_IGNORED_CATEGORIES = frozenset({'Pc', 'Pd', 'Ps', 'Pe', 'Pi', 'Pf', 'Po', 'Zs', 'Zl', 'Zp', 'Cf'}) -def _mode(value): - value = str(value or '').strip().lower() - return value if value in MODES else '' - - -def current_judge_mode(): - """Read the active application's synced plan without auth/network calls. - - backend_client resolves its own runtime data directory (including frozen - installs). Never select a source checkout or a different user's config. - An absent/invalid mode is unknown, not permission to release legacy work. - """ - try: - import backend_client - settings = backend_client.load_settings() - gateway = settings.get('gateway') or {} - if gateway.get('enabled') and str(gateway.get('url') or '').strip(): - roles = (settings.get('model_plan') or {}).get('roles') or {} - return _mode(roles.get('judge_mode')) - except Exception: - return '' - try: - import ai_config - if getattr(ai_config, 'AI_JUDGE_ENABLED', False): - return _mode(getattr(ai_config, 'AI_JUDGE_MODE', '')) - except Exception: - pass - return '' +def _match_key(text): + """NFKC (full-width -> ASCII) + casefold, without whitespace or punctuation, + so '能不 能吃' and '能不能吃?' both match the keyword '能不能吃'.""" + text = unicodedata.normalize('NFKC', str(text or '')).casefold() + return ''.join(ch for ch in text if not ( + ch.isspace() or ch in _ASCII_PUNCTUATION or unicodedata.category(ch) in _IGNORED_CATEGORIES)) def judge_review_reason(state, *, current_mode=None): + # current_mode is accepted for older callers only; no judge mode releases a + # high-risk verdict. state = state if isinstance(state, dict) else {} if str(state.get('judge_risk') or '').strip().lower() != 'high': return '' - recorded = _mode(state.get('judge_mode')) - # A verdict's explicit mode takes priority over a possibly stale plan cache. - # Consult the current plan only to migrate historical verdicts without a mode. - effective = recorded - if not effective: - effective = current_judge_mode() if current_mode is None else _mode(current_mode) - if effective == 'shadow': - return '' - # Missing historical mode remains conservative until a valid plan arrives. return '模型裁判评估为高风险' def selective_review_reason(state, customer_text, reply_text, *, rules, current_mode=None): - reason = judge_review_reason(state, current_mode=current_mode) + reason = judge_review_reason(state) if reason: return reason - combined = (str(customer_text or '') + '\n' + str(reply_text or '')).lower() + # Normalize each side separately: keywords carry no whitespace after + # normalization, so none can match across the customer/reply boundary. + combined = _match_key(customer_text) + '\n' + _match_key(reply_text) for rule in rules or []: if not isinstance(rule, dict) or not rule.get('enabled', True): continue keywords = rule.get('keywords') or [] if not isinstance(keywords, (list, tuple)): continue - if any(str(word or '').strip().lower() in combined for word in keywords if str(word or '').strip()): + words = (_match_key(part) for word in keywords + for part in _KEYWORD_SEPARATORS.split(str(word or ''))) + # A keyword that normalizes to nothing (e.g. only punctuation) is ignored. + if any(word and word in combined for word in words): return '命中审核规则:' + (str(rule.get('label') or '').strip() or '未命名规则') return '' +REVIEW_SCOPES = ('follow', 'every', 'rules') + + +def normalize_review_scope(value): + """Local review scope for review mode: follow the admin setting (default), + review every reply, or the original rule (resume after a verified manual reply).""" + if value is True: + return 'every' + text = str(value or '').strip().lower() + return text if text in REVIEW_SCOPES else 'follow' + + +def review_every_reply(scope, admin_value): + """Whether review mode holds every reply, even in a conversation a human already handled. + + A local 'every'/'rules' choice wins; 'follow' uses the admin setting synced as + AI_REVIEW_EVERY_REPLY (anything but an explicit True keeps the original rule). + """ + scope = normalize_review_scope(scope) + if scope == 'follow': + return admin_value is True + return scope == 'every' + + def can_recheck_review(state): """Policy changes cannot resolve delivery or independent manual safeguards.""" if not isinstance(state, dict): diff --git a/test_assistant_followup.py b/test_assistant_followup.py new file mode 100644 index 0000000..3fa04f9 --- /dev/null +++ b/test_assistant_followup.py @@ -0,0 +1,112 @@ +# -*- coding: utf-8 -*- +"""待审核/需人工期间客户每发来一条新消息,都再提醒一次医疗助理(原提醒已发出时)。 + +提醒库、设置都放在临时目录;不连企业微信、不发送。 +""" + +import json +import sqlite3 +import tempfile +import unittest +from contextlib import closing +from pathlib import Path + +import review_assistant as ra + +ACCOUNT = "1688856770803435" +RECIPIENT = "S:1688856770803435_7881300000000001" +CUSTOMER = "S:1688856770803435_7881300000000002" + + +def context(*texts): + messages = [{"account": ACCOUNT, "conv_id": CUSTOMER, "is_self": False, "content": text, + "rowid": index + 1, "send_time": 1000 + index, "dedup_key": f"d{index}", "content_type": 0} + for index, text in enumerate(texts)] + return {"account": ACCOUNT, "conv_id": CUSTOMER, "display_name": "客户甲", "messages": messages} + + +def state(**extra): + base = {"account": ACCOUNT, "conv_id": CUSTOMER, "display_name": "客户甲", "stage": "awaiting_review", + "awaiting_review": True, "review_reason": "人工审核后点击“通过并发送”", "reply_text": "AI 草稿"} + base.update(extra) + return base + + +class FollowupTest(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + config = {ra.SETTINGS_KEY: {ACCOUNT: {"enabled": True, "recipient_conv_id": RECIPIENT}}} + self.assistant = ra.ReviewAssistantCoordinator(root=self.root, settings_loader=lambda: config, account=ACCOUNT) + self.addCleanup(self.assistant.close) + + def rows(self, status=None): + with closing(sqlite3.connect(self.root / "review_assistant.sqlite3")) as conn: + query = "SELECT status, data FROM episodes" + (" WHERE status=?" if status else "") + " ORDER BY rowid" + return [(row[0], json.loads(row[1])) for row in conn.execute(query, (status,) if status else ())] + + def mark_sent(self, episode_id): + with self.assistant._connect() as conn: + item = self.assistant._read_episode(conn, {"assistant_review_id": episode_id}, CUSTOMER) + item.update(notification="sent", attempts=1) + self.assistant._write(conn, item) + + def test_unsent_reminder_absorbs_new_messages(self): + review_id = self.assistant.ensure_review(state(), context("在吗")) + self.assertEqual(self.assistant.ensure_review(state(), context("在吗", "这个药怎么吃")), review_id) + self.assertEqual(self.rows("followup"), []) + text = self.rows("pending")[0][1]["notification_text"] + self.assertIn("这个药怎么吃", text, "还没发出去的原提醒直接带上最新对话") + + def test_each_new_message_after_the_reminder_is_pushed_once(self): + review_id = self.assistant.ensure_review(state(), context("在吗")) + self.mark_sent(review_id) + self.assistant.ensure_review(state(), context("在吗")) + self.assertEqual(self.rows("followup"), [], "没有新消息不补推") + self.assertEqual(self.assistant.ensure_review(state(reply_text="新草稿"), context("在吗", "这个药怎么吃")), review_id) + self.assistant.ensure_review(state(reply_text="新草稿"), context("在吗", "这个药怎么吃")) + followups = self.rows("followup") + self.assertEqual(len(followups), 1, "同一条新消息只推一次") + item = followups[0][1] + self.assertEqual((item["parent"], item["trigger"], item["notification"]), (review_id, "d1", "pending")) + self.assertTrue(item["notification_text"].startswith("【客户待人工审核·新消息】")) + self.assertIn("关联提醒:#" + review_id[:8], item["notification_text"]) + self.assertIn("这个药怎么吃", item["notification_text"]) + self.assertIn("新草稿", item["notification_text"]) + self.assistant.ensure_review(state(), context("在吗", "这个药怎么吃", "一天几次")) + self.assertEqual([row[1]["trigger"] for row in self.rows("followup")], ["d1", "d2"]) + + def test_manual_task_followup_uses_the_manual_label(self): + manual = state(stage="error", awaiting_review=False, manual_required=True, manual_reason="发送失败") + review_id = self.assistant.ensure_review(manual, context("在吗")) + self.mark_sent(review_id) + self.assistant.ensure_review(manual, context("在吗", "人呢")) + item = self.rows("followup")[0][1] + self.assertTrue(item["notification_text"].startswith("【客户需人工处理·新消息】")) + + def test_followups_never_block_and_stop_after_the_review_ends(self): + review_id = self.assistant.ensure_review(state(), context("在吗")) + self.mark_sent(review_id) + self.assistant.ensure_review(state(), context("在吗", "这个药怎么吃")) + followup = self.rows("followup")[0][1] + self.assertTrue(self.assistant._parent_pending(followup)) + self.assertTrue(self.assistant._notification_guard(followup)) + self.assertTrue(self.assistant.cancel_review(state(assistant_review_id=review_id))) + self.assertFalse(self.assistant.has_pending(CUSTOMER), "补推的提醒不算待审核") + self.assertFalse(self.assistant._parent_pending(followup), "原审核结束后不再补发") + source = Path(ra.__file__).read_text(encoding="utf-8") + self.assertIn("status IN ('pending','handoff','followup')", source) + self.assertIn("notification='skipped'", source) + + def test_summary_mentions_the_followup(self): + review_id = self.assistant.ensure_review(state(), context("在吗")) + self.mark_sent(review_id) + self.assistant.ensure_review(state(), context("在吗", "这个药怎么吃")) + summary = ra.notification_summary(self.root, ACCOUNT) + self.assertEqual(summary["status"], "followup_pending") + self.assertIn("新消息", summary["message"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/test_assistant_handoff.py b/test_assistant_handoff.py new file mode 100644 index 0000000..60b640c --- /dev/null +++ b/test_assistant_handoff.py @@ -0,0 +1,155 @@ +# -*- coding: utf-8 -*- +"""转人工也提醒医疗助理:已有待审提醒改成转人工(发过的不重发),没有就新建;不再挡住会话。 + +提醒库、设置都放在临时目录;不连企业微信、不发送。 +""" + +import ast +import json +import sqlite3 +import tempfile +import unittest +from contextlib import closing +from pathlib import Path + +import review_assistant as ra + +ROOT = Path(__file__).resolve().parent +ACCOUNT = "1688856770803435" +RECIPIENT = "S:1688856770803435_7881300000000001" +CUSTOMER = "S:1688856770803435_7881300000000002" + + +def settings(enabled=True): + return {ra.SETTINGS_KEY: {ACCOUNT: {"enabled": enabled, "recipient_conv_id": RECIPIENT}}} + + +def context(*texts): + messages = [{"account": ACCOUNT, "conv_id": CUSTOMER, "is_self": False, "content": text, + "rowid": index + 1, "send_time": 1000 + index, "dedup_key": f"d{index}", "content_type": 0} + for index, text in enumerate(texts)] + return {"account": ACCOUNT, "conv_id": CUSTOMER, "display_name": "客户甲", "messages": messages} + + +def state(**extra): + base = {"account": ACCOUNT, "conv_id": CUSTOMER, "display_name": "客户甲", "stage": "awaiting_review", + "awaiting_review": True, "review_reason": "人工审核后点击“通过并发送”", "reply_text": "AI 草稿", + "staged_user_text": "这个药怎么吃", "dedup_key": "d0"} + base.update(extra) + return base + + +class HandoffTest(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.config = settings() + self.assistant = ra.ReviewAssistantCoordinator(root=self.root, settings_loader=lambda: self.config, + account=ACCOUNT) + self.addCleanup(self.assistant.close) + + def episode(self, episode_id): + with closing(sqlite3.connect(self.root / "review_assistant.sqlite3")) as conn: + row = conn.execute("SELECT status, data FROM episodes WHERE id=?", (episode_id,)).fetchone() + return row[0], json.loads(row[1]) + + def test_new_handoff_reminder_is_created_and_does_not_block(self): + episode_id = self.assistant.notify_handoff(state(), context("这个药怎么吃")) + self.assertTrue(episode_id) + status, item = self.episode(episode_id) + self.assertEqual(status, "handoff") + self.assertEqual(item["notification"], "pending") + self.assertEqual(item["recipient"], RECIPIENT) + self.assertTrue(item["notification_text"].startswith("【客户已转人工】")) + self.assertIn("客服已把该会话从自动回复队列转为人工处理", item["notification_text"]) + self.assertIn("客服已转人工", item["reason"]) + self.assertFalse(self.assistant.has_pending(CUSTOMER), "转人工提醒不能再挡住这个会话的自动回复") + self.assertEqual(self.assistant.notify_handoff(state(), context("这个药怎么吃")), episode_id, "重复转人工不重复登记") + + def test_pending_review_not_yet_sent_becomes_a_handoff_reminder(self): + review_id = self.assistant.ensure_review(state(), context("这个药怎么吃")) + self.assertTrue(self.assistant.has_pending(CUSTOMER)) + self.assertEqual(self.assistant.notify_handoff(state(assistant_review_id=review_id)), review_id) + status, item = self.episode(review_id) + self.assertEqual(status, "handoff") + self.assertTrue(item["notification_text"].startswith("【客户已转人工】")) + self.assertFalse(self.assistant.has_pending(CUSTOMER)) + + def test_already_sent_review_reminder_is_not_resent(self): + review_id = self.assistant.ensure_review(state(), context("这个药怎么吃")) + with self.assistant._connect() as conn: + item = self.assistant._read_episode(conn, {"assistant_review_id": review_id}, CUSTOMER) + item.update(notification="sent", attempts=1) + self.assistant._write(conn, item) + before = self.episode(review_id)[1]["notification_text"] + self.assertEqual(self.assistant.notify_handoff(state(assistant_review_id=review_id)), review_id) + status, item = self.episode(review_id) + self.assertEqual((status, item["notification"]), ("handoff", "sent")) + self.assertEqual(item["notification_text"], before, "发过的提醒不换文案、不重发") + + def test_worker_guard_accepts_handoff_reminders(self): + episode_id = self.assistant.notify_handoff(state(), context("这个药怎么吃")) + item = self.episode(episode_id)[1] + self.assertTrue(self.assistant._notification_guard(item)) + source = (ROOT / "review_assistant.py").read_text(encoding="utf-8") + self.assertRegex(source, r"status IN \('pending','handoff'", "发送线程要把转人工提醒一起发出去") + + def test_later_cancel_or_reconcile_does_not_touch_a_handoff_reminder(self): + episode_id = self.assistant.notify_handoff(state(), context("这个药怎么吃")) + self.assertTrue(self.assistant.cancel_review(state(assistant_review_id=episode_id))) + self.assertEqual(self.episode(episode_id)[0], "handoff") + + def test_disabled_assistant_returns_empty(self): + self.config = settings(enabled=False) + self.assertEqual(self.assistant.notify_handoff(state(), context("这个药怎么吃")), "") + + def test_recipient_conversation_is_never_notified_about_itself(self): + self.assertEqual(self.assistant.notify_handoff(state(conv_id=RECIPIENT), context("x")), "") + + def test_without_database_the_task_text_is_used(self): + episode_id = self.assistant.notify_handoff(state()) + self.assertTrue(episode_id) + item = self.episode(episode_id)[1] + self.assertIn("客户:这个药怎么吃", item["context"]) + self.assertEqual(self.assistant.notify_handoff(state(staged_user_text="", conv_id="S:1688856770803435_7881300000000009")), "") + + def test_summary_mentions_the_handoff(self): + self.assistant.notify_handoff(state(), context("这个药怎么吃")) + summary = ra.notification_summary(self.root, ACCOUNT) + self.assertEqual(summary["status"], "handoff_pending") + self.assertIn("已转人工", summary["message"]) + + +class HandoffCallersTest(unittest.TestCase): + """三条转人工路径都先登记提醒,没登记上才按原方式取消。""" + + def test_protocol_notifies_before_flushing_cancellations(self): + tree = ast.parse((ROOT / "protocol_engine.py").read_text(encoding="utf-8-sig")) + bot = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "ProtocolBot") + method = next(n for n in bot.body if isinstance(n, ast.FunctionDef) and n.name == "handoff_pending_replies") + source = ast.get_source_segment((ROOT / "protocol_engine.py").read_text(encoding="utf-8-sig"), method) + self.assertIn("notify_handoff", source) + self.assertLess(source.index("notify_handoff"), source.index("_flush_assistant_cancellations")) + + def test_visual_and_file_paths_use_the_handoff_helper(self): + bot = (ROOT / "wechat_bot.py").read_text(encoding="utf-8-sig") + start = bot.index("def handoff_pending_replies(") + self.assertIn("handoff_assistant_review_for_state", bot[start:bot.index("def cancel_pending_replies(", start)]) + runtime = (ROOT / "gui_runtime.py").read_text(encoding="utf-8-sig") + self.assertIn("handoff_assistant_review_for_state(state, directory)", runtime) + + def test_file_path_helper_registers_or_falls_back(self): + import gui_runtime + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + (root / "app_settings.json").write_text(json.dumps(settings()), encoding="utf-8") + self.assertTrue(gui_runtime.handoff_assistant_review_for_state(state(), root)) + with closing(sqlite3.connect(root / "review_assistant.sqlite3")) as conn: + self.assertEqual(conn.execute("SELECT status FROM episodes").fetchall(), [("handoff",)]) + (root / "app_settings.json").write_text(json.dumps(settings(enabled=False)), encoding="utf-8") + self.assertFalse(gui_runtime.handoff_assistant_review_for_state(state(conv_id=RECIPIENT[:-1] + "3"), root)) + + +if __name__ == "__main__": + unittest.main() diff --git a/test_patient_session_errors.py b/test_patient_session_errors.py new file mode 100644 index 0000000..ecc1c27 --- /dev/null +++ b/test_patient_session_errors.py @@ -0,0 +1,491 @@ +# -*- coding: utf-8 -*- +"""患者查询错误分类、ZYT 会话保活节流与绑定窗口提示;只用合成 HTTP 和内存配置。 + +源码运行时 application_data_dir() 就是源码目录,请在临时副本里运行本测试。 +""" + +import copy +import io +import json +import os +import time +import unittest +import urllib.error +from unittest import mock + +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +import backend_client as client # noqa: E402 + +ZYT_SESSION_PATH = "/adminapi/desktop/session" + + +class PatientRequestErrorMapping(unittest.TestCase): + def request_error(self, status, body, path=None): + error = urllib.error.HTTPError( + "https://synthetic.invalid/path", status, "synthetic", {}, + io.BytesIO(json.dumps(body, ensure_ascii=False).encode("utf-8"))) + with mock.patch.object(client.urllib.request, "urlopen", side_effect=error): + try: + client._request("GET", "https://synthetic.invalid", path or client.DESKTOP_PATIENT_SEARCH_PATH) + except client.BackendError as exc: + return exc + self.fail("expected synthetic HTTP error") + + def test_ip_restricted_is_query_rejected_not_expiry_or_logout(self): + for path in (client.DESKTOP_PATIENT_SEARCH_PATH + "?keyword=synthetic", client.DESKTOP_PATIENT_BINDING_PATH, + client.DESKTOP_PATIENT_CONTEXT_PATH, client.DESKTOP_PATIENT_ORDER_SUMMARY_PATH): + with self.subTest(path=path): + error = self.request_error( + 409, {"detail": {"code": "zyt_ip_restricted", "message": "synthetic ip rejected"}}, path) + self.assertIsInstance(error, client.PatientQueryRejected) + self.assertNotIsInstance(error, client.PatientSessionExpired) + self.assertNotIsInstance(error, client.AuthenticationError) + self.assertEqual(error.code, "zyt_ip_restricted") + self.assertEqual(error.status, 409) + self.assertEqual(str(error), "synthetic ip rejected") + + def test_ip_restricted_without_message_uses_readable_default(self): + error = self.request_error(409, {"detail": {"code": "zyt_ip_restricted"}}) + self.assertIsInstance(error, client.PatientQueryRejected) + self.assertNotIn("HTTP 409", str(error)) + self.assertIn("登录 IP 校验", str(error)) + self.assertNotIn("过期", str(error)) + + def test_order_routes_show_staff_message_instead_of_model_text(self): + # 订单接口的 message 是给模型的中性口径,客服界面要显示 staff_message 里的说明。 + for code, kind in (("zyt_ip_restricted", client.PatientQueryRejected), + ("zyt_session_expired", client.PatientSessionExpired)): + with self.subTest(code=code): + error = self.request_error(409, {"detail": { + "code": code, "message": "synthetic neutral", "staff_message": "synthetic staff"}}, + client.DESKTOP_PATIENT_ORDER_SUMMARY_PATH) + self.assertIsInstance(error, kind) + self.assertEqual(str(error), "synthetic staff") + + def test_session_expired_mapping_unchanged(self): + error = self.request_error(409, {"detail": {"code": "zyt_session_expired", "message": "synthetic expired"}}) + self.assertIsInstance(error, client.PatientSessionExpired) + self.assertNotIsInstance(error, client.PatientQueryRejected) + self.assertEqual(error.code, "zyt_session_expired") + self.assertEqual(str(error), "synthetic expired") + + def test_legacy_expiry_text_still_expired(self): + error = self.request_error(502, {"detail": "登录超时,请重新登录"}) + self.assertIsInstance(error, client.PatientSessionExpired) + + def test_patient_permission_denied_stays_generic_backend_error(self): + error = self.request_error(403, {"detail": {"code": "permission_denied", "message": "synthetic denied"}}) + self.assertEqual(type(error), client.BackendError) + self.assertEqual(error.code, "permission_denied") + self.assertEqual(error.status, 403) + + def test_desktop_revocation_elsewhere_stays_authentication_error(self): + for status in (401, 403): + with self.subTest(status=status): + error = self.request_error(status, {"detail": "synthetic revoked"}, client.DESKTOP_ME_PATH) + self.assertIsInstance(error, client.AuthenticationError) + self.assertNotIsInstance(error, client.PatientQueryRejected) + self.assertIsInstance(self.request_error(401, {"detail": "synthetic revoked"}), client.AuthenticationError) + + +class PatientKeepaliveThrottle(unittest.TestCase): + def setUp(self): + self.store = { + "server_url": "https://synthetic.invalid", "zyt_api_url": "https://identity.invalid", + "zyt_account": "synthetic-admin", "desktop_token_protected": "sealed:desktop-original", + "zyt_token_protected": "sealed:zyt-old", "desktop_expires_at": 5000, + "desktop_account": {"id": 7}, "last_error": "", + } + + def save(settings): + self.store = copy.deepcopy(settings) + + self.enterContext(mock.patch.object(client, "load_settings", side_effect=lambda: copy.deepcopy(self.store))) + self.enterContext(mock.patch.object(client, "save_settings", side_effect=save)) + self.enterContext(mock.patch.object(client, "_protect_secret", side_effect=lambda value: "sealed:" + value)) + self.enterContext(mock.patch.object( + client, "_unprotect_secret", side_effect=lambda value: str(value or "").removeprefix("sealed:"))) + self.enterContext(mock.patch.object(client, "is_frozen", return_value=False)) + self.enterContext(mock.patch.object( + client.urllib.request, "urlopen", side_effect=AssertionError("real network forbidden"))) + self.request = self.enterContext(mock.patch.object(client, "_request", side_effect=self.response)) + self.login = self.enterContext(mock.patch.object(client, "_zyt_login", side_effect=AssertionError("login forbidden"))) + self.exchange = self.enterContext(mock.patch.object( + client, "_exchange_desktop_token", side_effect=AssertionError("exchange forbidden"))) + self.logout = self.enterContext(mock.patch.object(client, "desktop_logout", side_effect=AssertionError("logout forbidden"))) + self.clock = [1000.0] + self.enterContext(mock.patch.object(client.time, "monotonic", side_effect=lambda: self.clock[0])) + self.enterContext(mock.patch.object(client.time, "time", return_value=1000)) + original = dict(client._PATIENT_KEEPALIVE_LAST) + client._PATIENT_KEEPALIVE_LAST.clear() + self.addCleanup(lambda: (client._PATIENT_KEEPALIVE_LAST.clear(), client._PATIENT_KEEPALIVE_LAST.update(original))) + self.me_failure = None + self.zyt_failure = None + self.zyt_result = {"code": 1, "data": {"status": "active"}} + self.seen_before_zyt_call = [] + + def response(self, method, server, path, **kwargs): + if path == client.DESKTOP_ME_PATH: + if self.me_failure: + raise self.me_failure + return 200, {"id": 7, "expires_at": 9000} + if path == ZYT_SESSION_PATH: + self.seen_before_zyt_call.append(dict(client._PATIENT_KEEPALIVE_LAST)) + if self.zyt_failure: + raise self.zyt_failure + return 200, copy.deepcopy(self.zyt_result) + raise AssertionError("unexpected synthetic route: " + path) + + def zyt_calls(self): + return sum(call.args[2] == ZYT_SESSION_PATH for call in self.request.call_args_list) + + def advance(self, seconds): + self.clock[0] += seconds + + def test_interval_is_shorter_than_the_thirty_minute_gui_timer(self): + self.assertLess(client.PATIENT_KEEPALIVE_INTERVAL_SECONDS, 30 * 60) + self.assertLess(client.PATIENT_KEEPALIVE_RETRY_SECONDS, client.PATIENT_KEEPALIVE_INTERVAL_SECONDS) + + def test_every_thirty_minute_tick_really_calls_zyt(self): + for _ in range(4): + self.assertEqual(client.keepalive_zyt_session(), {"status": "active"}) + self.advance(30 * 60) + self.assertEqual(self.zyt_calls(), 4) + self.login.assert_not_called() + self.exchange.assert_not_called() + self.logout.assert_not_called() + self.assertEqual(self.store["zyt_token_protected"], "sealed:zyt-old") + + def test_extra_trigger_inside_interval_is_throttled(self): + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + self.advance(client.PATIENT_KEEPALIVE_INTERVAL_SECONDS - 1) + self.assertEqual(client.keepalive_zyt_session(), {"status": "skipped", "reason": "throttled"}) + self.advance(1) + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + self.assertEqual(self.zyt_calls(), 2) + + def test_throttle_is_recorded_only_after_the_call_finishes(self): + client.keepalive_zyt_session() + self.assertEqual(self.seen_before_zyt_call, [{}]) + self.assertEqual(client._PATIENT_KEEPALIVE_LAST["wait"], client.PATIENT_KEEPALIVE_INTERVAL_SECONDS) + + def test_zyt_network_failure_allows_retry_after_five_minutes(self): + self.zyt_failure = client.BackendError("synthetic offline") + self.assertEqual(client.keepalive_zyt_session()["status"], "unreachable") + self.advance(client.PATIENT_KEEPALIVE_RETRY_SECONDS - 1) + self.assertEqual(client.keepalive_zyt_session()["reason"], "throttled") + self.advance(1) + self.zyt_failure = None + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + self.assertEqual(self.zyt_calls(), 2) + self.advance(client.PATIENT_KEEPALIVE_RETRY_SECONDS) + self.assertEqual(client.keepalive_zyt_session()["reason"], "throttled") + + def test_unclear_zyt_answer_is_retried_soon(self): + self.zyt_result = {"code": 0, "msg": "synthetic unknown"} + self.assertEqual(client.keepalive_zyt_session()["status"], "unreachable") + self.assertEqual(client._PATIENT_KEEPALIVE_LAST["wait"], client.PATIENT_KEEPALIVE_RETRY_SECONDS) + + def test_backend_unreachable_before_zyt_allows_retry_after_five_minutes(self): + self.me_failure = client.BackendError("synthetic backend offline") + self.assertEqual(client.keepalive_zyt_session()["status"], "unreachable") + self.assertEqual(self.zyt_calls(), 0) + self.advance(client.PATIENT_KEEPALIVE_RETRY_SECONDS - 1) + self.assertEqual(client.keepalive_zyt_session()["reason"], "throttled") + self.advance(1) + self.me_failure = None + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + + def test_definite_zyt_answers_use_full_interval(self): + cases = [({"code": -1, "msg": "登录超时,请重新登录"}, None, "expired"), + (None, client.AuthenticationError("synthetic denied", status=403), "forbidden"), + (None, client.BackendError("synthetic not deployed", status=404), "unsupported")] + for answer, failure, expected in cases: + with self.subTest(expected=expected): + client._PATIENT_KEEPALIVE_LAST.clear() + self.zyt_result, self.zyt_failure = answer, failure + self.assertEqual(client.keepalive_zyt_session()["status"], expected) + self.advance(client.PATIENT_KEEPALIVE_RETRY_SECONDS) + self.assertEqual(client.keepalive_zyt_session()["reason"], "throttled") + self.logout.assert_not_called() + self.login.assert_not_called() + + def test_desktop_invalid_does_not_consume_the_interval(self): + self.me_failure = client.AuthenticationError("synthetic revoked", status=401) + self.assertEqual(client.keepalive_zyt_session()["status"], "desktop_invalid") + self.me_failure = None + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + self.logout.assert_not_called() + + def test_new_patient_token_is_not_throttled_by_old_one(self): + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + self.store["zyt_token_protected"] = "sealed:zyt-new" + self.assertEqual(client.keepalive_zyt_session()["status"], "active") + self.assertEqual(self.zyt_calls(), 2) + + def test_session_change_during_call_is_skipped_and_not_recorded(self): + def response(method, server, path, **kwargs): + if path == ZYT_SESSION_PATH: + self.store["zyt_token_protected"] = "sealed:zyt-concurrently-new" + return 200, {"code": -1, "msg": "登录超时,请重新登录"} + return self.response(method, server, path, **kwargs) + self.request.side_effect = response + self.assertEqual(client.keepalive_zyt_session(), {"status": "skipped", "reason": "session_changed"}) + self.assertEqual(client._PATIENT_KEEPALIVE_LAST, {}) + self.assertEqual(self.store["zyt_token_protected"], "sealed:zyt-concurrently-new") + + +try: + from PySide6.QtWidgets import QApplication + import wechat_gui_qt as gui +except Exception as exc: # pragma: no cover - 没有 Qt 运行库时只跑上面的用例 + gui = None + GUI_IMPORT_ERROR = repr(exc) +else: + GUI_IMPORT_ERROR = "" + + +def _context(): + return { + "permissions": {"can_search": True, "can_bind": True, "can_unbind": True}, + "conversation": {"name": "synthetic chat"}, + "person": {"id": "person-1"}, + "people": [{"id": "person-1", "display_name": "synthetic person", "patient_bindings": []}], + } + + +@unittest.skipIf(gui is None, f"PySide6 GUI unavailable: {GUI_IMPORT_ERROR}") +class PatientBindingDialogStates(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.app = QApplication.instance() or QApplication([]) + + def setUp(self): + self.dialog = gui.PatientBindingDialog(_context(), "account-1", "conversation-1") + self.addCleanup(self.dialog.deleteLater) + self.dialog.search_input.setText("synthetic keyword") + + def button_shown(self): + return not self.dialog.reauthenticate_button.isHidden() + + def wait_idle(self, seconds=5.0): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + self.app.processEvents() + if not self.dialog._busy: + return + time.sleep(0.01) + self.fail("dialog stayed busy") + + def search_through_worker(self, failure): + with mock.patch.object(client, "search_desktop_patients", side_effect=failure): + self.dialog._search() + self.wait_idle() + + def test_expired_offers_reverification(self): + self.search_through_worker(client.PatientSessionExpired(status=409)) + self.assertTrue(self.button_shown()) + self.assertIn("登录已过期", self.dialog.hint_label.text()) + self.assertFalse(self.dialog.search_button.isEnabled()) + self.assertFalse(self.dialog.bind_button.isEnabled()) + + def test_rejected_shows_backend_message_without_reverification(self): + message = "患者信息暂时查不到:synthetic IP 校验说明" + self.search_through_worker(client.PatientQueryRejected(message, status=409)) + self.assertFalse(self.button_shown()) + self.assertEqual(self.dialog.hint_label.text(), message) + self.assertNotIn("登录已过期", self.dialog.hint_label.text()) + self.assertTrue(self.dialog.search_button.isEnabled()) + + def test_rejected_without_message_uses_fallback(self): + self.dialog._search_finished({"ok": False, "error": "", "patient_query_rejected": True}) + self.assertIn("重新验证无法解决", self.dialog.hint_label.text()) + self.assertFalse(self.button_shown()) + + def test_bind_rejected_is_not_expiry(self): + self.dialog._operation_finished({"ok": False, "action": "bind", "error": "synthetic rejected", + "patient_session_expired": False, "patient_query_rejected": True}) + self.assertEqual(self.dialog.hint_label.text(), "synthetic rejected") + self.assertFalse(self.button_shown()) + self.assertFalse(self.dialog.changed) + + def test_expired_again_after_reverification_does_not_loop(self): + self.search_through_worker(client.PatientSessionExpired(status=409)) + self.assertTrue(self.button_shown()) + with mock.patch.object(client, "search_desktop_patients", + side_effect=client.PatientSessionExpired(status=409)) as search: + self.dialog._reauthentication_finished({"ok": True, "context": _context()}) + self.wait_idle() + search.assert_called_once_with("synthetic keyword") + text = self.dialog.hint_label.text() + self.assertIn("已重新验证 ZYT 登录", text) + self.assertIn("仍被 ZYT 拒绝", text) + self.assertNotIn("登录已过期", text) + self.assertFalse(self.button_shown()) + # 不把人困住:搜索仍可用,稍后可以直接重试。 + self.assertTrue(self.dialog.search_button.isEnabled()) + self.assertFalse(self.dialog._patient_session_expired) + + def test_successful_search_after_reverification(self): + self.search_through_worker(client.PatientSessionExpired(status=409)) + result = {"items": [{"patient_id": 9, "patient_name": "synthetic patient"}], "total": 1} + with mock.patch.object(client, "search_desktop_patients", return_value=result): + self.dialog._reauthentication_finished({"ok": True, "context": _context()}) + self.wait_idle() + self.assertEqual(self.dialog.result_table.rowCount(), 1) + self.assertIn("找到 1 名患者", self.dialog.hint_label.text()) + self.assertFalse(self.button_shown()) + + def test_failed_password_keeps_reverification_available(self): + self.search_through_worker(client.PatientSessionExpired(status=409)) + self.dialog._reauthentication_finished({"ok": False, "error": "synthetic wrong password", "verified": False}) + self.assertIn("验证失败", self.dialog.hint_label.text()) + self.assertTrue(self.button_shown()) + self.assertTrue(self.dialog.reauthenticate_button.isEnabled()) + + def test_verified_but_context_rejected_is_not_reported_as_failed_verification(self): + self.search_through_worker(client.PatientSessionExpired(status=409)) + self.dialog._reauthentication_finished({"ok": False, "verified": True, "error": "synthetic ip rejected", + "patient_query_rejected": True}) + self.assertEqual(self.dialog.hint_label.text(), "synthetic ip rejected") + self.assertFalse(self.button_shown()) + self.assertTrue(self.dialog.search_button.isEnabled()) + + def test_verified_but_context_expired_shows_still_rejected(self): + self.search_through_worker(client.PatientSessionExpired(status=409)) + self.dialog._reauthentication_finished({"ok": False, "verified": True, "error": "synthetic expired", + "patient_session_expired": True}) + self.assertIn("仍被 ZYT 拒绝", self.dialog.hint_label.text()) + self.assertNotIn("验证失败", self.dialog.hint_label.text()) + self.assertFalse(self.button_shown()) + + def reauthenticate_through_worker(self, context_failure): + """点“重新验证”走真实的工作线程和信号;只替换密码框和两次后台调用。""" + self.search_through_worker(client.PatientSessionExpired(status=409)) + self.assertTrue(self.button_shown()) + with mock.patch.object(gui.QInputDialog, "getText", return_value=("synthetic password", True)), \ + mock.patch.object(client, "load_settings", return_value={"zyt_account": "synthetic-admin"}), \ + mock.patch.object(client, "reauthenticate_patient_session", return_value={}) as reauthenticate, \ + mock.patch.object(client, "desktop_patient_context", side_effect=context_failure) as context: + self.dialog._reauthenticate() + self.assertTrue(self.dialog._busy) + self.wait_idle() + reauthenticate.assert_called_once_with("synthetic password") + context.assert_called_once_with("account-1", "conversation-1", person_id="person-1") + + def test_reauthenticate_worker_context_still_expired_stops_the_loop(self): + self.reauthenticate_through_worker(client.PatientSessionExpired(status=409)) + text = self.dialog.hint_label.text() + self.assertIn("已重新验证 ZYT 登录", text) + self.assertIn("仍被 ZYT 拒绝", text) + self.assertNotIn("验证失败", text) + self.assertNotIn("登录已过期", text) + self.assertFalse(self.button_shown()) + self.assertTrue(self.dialog.search_button.isEnabled()) + self.assertTrue(self.dialog._reauthenticated) + self.assertFalse(self.dialog._patient_session_expired) + + def test_reauthenticate_worker_context_rejected_shows_backend_message(self): + message = "患者信息暂时查不到:synthetic IP 校验说明" + self.reauthenticate_through_worker(client.PatientQueryRejected(message, status=409)) + self.assertEqual(self.dialog.hint_label.text(), message) + self.assertFalse(self.button_shown()) + self.assertTrue(self.dialog.search_button.isEnabled()) + self.assertTrue(self.dialog._reauthenticated) + self.assertFalse(self.dialog._patient_session_expired) + + +class _KeepaliveHost: + """只带 _patient_session_checked 用到的状态。""" + + def __init__(self): + from PySide6.QtCore import QTimer + + self._patient_keepalive_running = True + self._patient_session_state = "unknown" + self.patient_session_timer = QTimer() + self.patient_session_timer.setInterval(30 * 60 * 1000) + self.patient_session_timer.start() + self.patient_session_retry_timer = QTimer() + self.patient_session_retry_timer.setSingleShot(True) + self.patient_session_retry_timer.setInterval(6 * 60 * 1000) + self.logs = [] + + def append_log(self, text, tag=""): + self.logs.append((text, tag)) + + def checked(self, result): + gui.MainWindow._patient_session_checked(self, result) + + +@unittest.skipIf(gui is None, f"PySide6 GUI unavailable: {GUI_IMPORT_ERROR}") +class PatientKeepaliveLogging(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.app = QApplication.instance() or QApplication([]) + + def test_unreachable_logs_once_and_schedules_one_retry(self): + host = _KeepaliveHost() + host.checked({"status": "unreachable", "message": "synthetic offline"}) + host.checked({"status": "unreachable", "message": "synthetic offline"}) + host.checked({"status": "unreachable"}) + self.assertEqual(len(host.logs), 1) + self.assertIn("synthetic offline", host.logs[0][0]) + self.assertEqual(host.logs[0][1], "warn") + self.assertTrue(host.patient_session_retry_timer.isActive()) + self.assertFalse(host._patient_keepalive_running) + + def test_periodic_failure_while_retry_pending_restarts_the_retry(self): + # 补查还在等时周期检查又失败:旧补查会落进这次失败后的 5 分钟节流里被跳过, + # 所以必须从这次失败重新计时。 + host = _KeepaliveHost() + host.checked({"status": "unreachable", "message": "synthetic offline"}) + host.patient_session_retry_timer = mock.Mock() + host.patient_session_retry_timer.isActive.return_value = True + host.checked({"status": "unreachable", "message": "synthetic offline"}) + host.patient_session_retry_timer.start.assert_called_once_with() + host.patient_session_retry_timer.stop.assert_not_called() + self.assertEqual(len(host.logs), 1) + + def test_recovery_stops_retry_restarts_period_and_logs_once(self): + host = _KeepaliveHost() + host.patient_session_timer = mock.Mock() + host.patient_session_timer.isActive.return_value = True + host.checked({"status": "unreachable", "message": "synthetic offline"}) + host.patient_session_timer.start.assert_not_called() + host.checked({"status": "active"}) + self.assertFalse(host.patient_session_retry_timer.isActive()) + # 从这次真实请求重新计 30 分钟,下一次到点不会被 25 分钟节流挡掉。 + host.patient_session_timer.start.assert_called_once_with() + host.checked({"status": "active"}) + self.assertEqual([tag for _, tag in host.logs], ["warn", "ok"]) + self.assertIn("恢复正常", host.logs[1][0]) + + def test_forbidden_and_unsupported_log_on_change_only(self): + host = _KeepaliveHost() + for status in ("forbidden", "forbidden", "unsupported", "unsupported", "active", "active"): + host.checked({"status": status, "message": f"synthetic {status}"}) + self.assertEqual(len(host.logs), 3) + self.assertIn("synthetic forbidden", host.logs[0][0]) + self.assertIn("synthetic unsupported", host.logs[1][0]) + self.assertFalse(host.patient_session_retry_timer.isActive()) + + def test_first_active_and_skipped_are_silent(self): + host = _KeepaliveHost() + host.checked({"status": "skipped", "reason": "throttled"}) + host.checked({"status": "active"}) + self.assertEqual(host.logs, []) + self.assertEqual(host._patient_session_state, "active") + + def test_expired_still_logged_once(self): + host = _KeepaliveHost() + host.checked({"status": "expired"}) + host.checked({"status": "expired"}) + host.checked({"status": "active"}) + self.assertEqual([tag for _, tag in host.logs], ["warn", "ok"]) + self.assertIn("已恢复", host.logs[1][0]) + + +if __name__ == "__main__": + unittest.main() diff --git a/test_review_policy.py b/test_review_policy.py new file mode 100644 index 0000000..11b288b --- /dev/null +++ b/test_review_policy.py @@ -0,0 +1,378 @@ +# -*- coding: utf-8 -*- +"""审核闸:裁判判高风险在任何裁判模式下都转人工;关键词比对做全角/大小写/空白/标点归一化。 + +只用内存数据。review_policy 不读配置、不联网;wechat_bot 的几个方法按 AST 从源码 +单独编译,不导入整个模块(导入会初始化运行目录,源码运行时会改写源码目录)。 +""" + +import ast +import functools +import hashlib +import json +import os +import shutil +import sys +import tempfile +import threading +import time +import unittest +from pathlib import Path +from types import ModuleType +from unittest import mock + +import review_policy as policy + +HIGH_RISK = "模型裁判评估为高风险" +FIRST_CONTACT_PLACEHOLDER = "(首次会话的新消息已由聊天截图确认)" + +# 2026-09-30 线上的「用药调整」关键词;另两条是后台默认规则。 +PRODUCTION_RULES = [ + {"id": "diagnosis", "label": "诊断", + "keywords": ["确诊", "诊断", "是不是得了", "是不是患了", "是什么病"], "enabled": True}, + {"id": "medication", "label": "用药调整", + "keywords": ["加量", "减量", "停药", "换药", "能不能吃", "剂量", "血糖"], "enabled": True}, + {"id": "complaint", "label": "投诉退款", + "keywords": ["投诉", "退款", "退货", "举报", "曝光", "消协"], "enabled": True}, +] +USAGE_RULE = {"id": "usage", "label": "用法用量", "keywords": ["服用", "饭后", "温服"], "enabled": True} + +# 2026-09-30 事故原话:客户问服法,机器人自动答了错误剂量。 +INCIDENT_CUSTOMER = "这个中药怎么服用?请告知[抱拳]" +INCIDENT_REPLY = "常规是早晚饭后半小时温服,一次一袋就可以…" + + +def rule(*keywords, label="规则", enabled=True): + return {"label": label, "keywords": list(keywords), "enabled": enabled} + + +def reason(customer, reply="", rules=(), state=None): + return policy.selective_review_reason(state or {}, customer, reply, rules=list(rules)) + + +class JudgeVerdictTest(unittest.TestCase): + def test_high_verdict_holds_in_every_judge_mode(self): + for mode in ("shadow", "score_only", "arbitrate", "SHADOW", "", "nonsense", None): + with self.subTest(mode=mode): + state = {"judge_risk": "high"} + if mode is not None: + state["judge_mode"] = mode + self.assertEqual(policy.judge_review_reason(state), HIGH_RISK) + self.assertEqual(reason("问题", "回复", state=state), HIGH_RISK) + + def test_legacy_current_mode_argument_cannot_release_high_verdict(self): + state = {"judge_risk": " HIGH ", "judge_mode": "shadow"} + for current in ("shadow", "score_only", "", None): + with self.subTest(current=current): + self.assertEqual(policy.judge_review_reason(state, current_mode=current), HIGH_RISK) + self.assertEqual(policy.selective_review_reason( + state, "问题", "回复", rules=[], current_mode=current), HIGH_RISK) + + def test_non_high_verdicts_do_not_hold(self): + for risk in ("low", "medium", "unknown", "", None): + for mode in ("shadow", "score_only", "arbitrate", ""): + with self.subTest(risk=risk, mode=mode): + state = {"judge_risk": risk, "judge_mode": mode} + self.assertEqual(policy.judge_review_reason(state), "") + self.assertEqual(reason("问题", "回复", state=state), "") + self.assertEqual(policy.judge_review_reason(None), "") + + def test_high_verdict_takes_precedence_over_keyword_rules(self): + state = {"judge_risk": "high", "judge_mode": "shadow"} + self.assertEqual(reason("能不能吃", "", [rule("能不能吃")], state), HIGH_RISK) + + +class KeywordMatchingTest(unittest.TestCase): + def test_whitespace_and_punctuation_are_ignored(self): + for text in ("能不 能吃", "能不能吃?", "能不能吃?", "能\u3000不能吃", "能不,能吃", "能不能\n吃", + "能不\u200b能吃", "“能不能吃”", "【能不能吃】"): + with self.subTest(text=text): + self.assertEqual(reason(text, "", [rule("能不能吃", label="用药调整")]), "命中审核规则:用药调整") + # 关键词自己带空白或标点也照样生效 + self.assertTrue(reason("这个药能不能吃", "", [rule(" 能不能吃? ")])) + self.assertTrue(reason("请问能否加量", "", [rule("加 量")])) + + def test_full_width_and_case_are_folded(self): + self.assertTrue(reason("要不要做CT", "", [rule("ct")])) + self.assertTrue(reason("要不要做ct", "", [rule("CT")])) + self.assertTrue(reason("", "请复查 HbA1c", [rule("hba1c")])) + self.assertTrue(reason("Covid", "", [rule("COVID")])) + self.assertTrue(reason("123", "", [rule("123")])) + + def test_keyword_hits_either_customer_or_reply(self): + self.assertTrue(reason("这个药能不能吃", "请稍等", [rule("能不能吃")])) + self.assertTrue(reason("请稍等", "建议停药观察", [rule("停药")])) + self.assertEqual(reason("请稍等", "好的", [rule("停药")]), "") + + def test_keyword_cannot_span_customer_and_reply(self): + self.assertEqual(reason("我想问能不", "能吃的话告诉您", [rule("能不能吃")]), "") + + def test_joined_keyword_is_split(self): + for word in ("服用,用法", "服用,用法", "服用、用法", "服用;用法", "服用;用法"): + for text in ("怎么服用", "用法是什么"): + with self.subTest(word=word, text=text): + self.assertTrue(reason(text, "", [rule(word)])) + self.assertEqual(reason("怎么保存", "", [rule("服用,用法")]), "") + + def test_disabled_rule_is_ignored(self): + rules = [rule("能不能吃", enabled=False)] + self.assertEqual(reason("能不能吃", "", rules), "") + self.assertEqual(reason("", "能不能吃", rules), "") + # enabled 缺省视为开启 + self.assertTrue(reason("能不能吃", "", [{"label": "默认开启", "keywords": ["能不能吃"]}])) + + def test_empty_keywords_are_ignored(self): + rules = [rule("", " ", "?", ",", "...", None, label="空词")] + for text in ("能不能吃?", "你好,在吗", "...", ""): + with self.subTest(text=text): + self.assertEqual(reason(text, "好的。", rules), "") + + def test_malformed_rules_are_ignored(self): + rules = [None, "诊断", {"label": "坏", "keywords": "诊断"}, {"label": "空", "keywords": None}] + self.assertEqual(reason("诊断", "诊断", rules), "") + self.assertEqual(policy.selective_review_reason({}, "诊断", "诊断", rules=None), "") + + def test_reason_text_format_is_unchanged(self): + self.assertEqual(reason("诊断", "", [rule("诊断", label=" 诊断 ")]), "命中审核规则:诊断") + self.assertEqual(reason("诊断", "", [rule("诊断", label="")]), "命中审核规则:未命名规则") + # 多条同时命中时按规则顺序取第一条 + self.assertEqual(reason("诊断后能不能吃", "", PRODUCTION_RULES), "命中审核规则:诊断") + + +class MedicationUsageIncidentTest(unittest.TestCase): + def test_incident_misses_production_rules(self): + state = {"judge_risk": "unknown", "judge_mode": "shadow"} + self.assertEqual(reason(INCIDENT_CUSTOMER, INCIDENT_REPLY, PRODUCTION_RULES, state), "") + + def test_usage_rule_holds_incident_from_either_side(self): + rules = PRODUCTION_RULES + [USAGE_RULE] + for customer, reply in ((INCIDENT_CUSTOMER, INCIDENT_REPLY), (INCIDENT_CUSTOMER, ""), ("", INCIDENT_REPLY)): + with self.subTest(customer=customer, reply=reply): + self.assertEqual(reason(customer, reply, rules), "命中审核规则:用法用量") + + def test_incident_with_high_verdict_holds_under_shadow(self): + state = {"judge_risk": "high", "judge_mode": "shadow"} + self.assertEqual(reason(INCIDENT_CUSTOMER, INCIDENT_REPLY, PRODUCTION_RULES, state), HIGH_RISK) + + +class RecheckGuardTest(unittest.TestCase): + def test_protected_work_is_never_rechecked(self): + base = {"awaiting_review": True, "stage": "manual_review"} + self.assertTrue(policy.can_recheck_review(base)) + for fields in ({"send_state": "sending"}, {"stage": "receipt_check"}, {"manual_required": True}, + {"foreign_draft_text": "人工草稿"}, {"foreign_draft_at": 0}, {"cancel_requested": True}): + with self.subTest(fields=fields): + self.assertFalse(policy.can_recheck_review(dict(base, **fields))) + + +WECHAT_BOT_PATH = Path(__file__).resolve().parent / "wechat_bot.py" + + +@functools.lru_cache(maxsize=None) +def _wechat_bot_tree(): + return ast.parse(WECHAT_BOT_PATH.read_text(encoding="utf-8-sig"), filename=str(WECHAT_BOT_PATH)) + + +@functools.lru_cache(maxsize=None) +def _isolated_bot_namespace(): + """只编译审核文字相关的模块级函数和 WeChatBot 方法,不执行 wechat_bot 模块本身。""" + path = WECHAT_BOT_PATH + tree = _wechat_bot_tree() + constants = {"_AVATAR_FP_BYTES", "_NAME_FP_BYTES", "_SESSION_FP_BYTES", "_LEGACY_SESSION_FP_BYTES", + "SEND_MODE_AUTO", "SEND_MODE_REVIEW"} + assigns = [node for node in tree.body if isinstance(node, ast.Assign) + and any(isinstance(target, ast.Name) and target.id in constants for target in node.targets)] + helper_names = {"review_match_text"} + helpers = [node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name in helper_names] + missing_helpers = helper_names - {node.name for node in helpers} + if missing_helpers: + raise AssertionError("wechat_bot 缺少模块级函数:" + repr(missing_helpers)) + original = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot") + names = {"_review_mode_enabled", "_reply_needs_review", "_drop_stale_review_flags", "_stage_exchange", + "_reset_pending_batch_unlocked", "_persist_pending_replies_unlocked", "_load_pending_replies", + "_knowledge_trace_metadata", "_voice_task_timestamp"} + methods = [node for node in original.body if isinstance(node, ast.FunctionDef) and node.name in names] + missing = names - {node.name for node in methods} + if missing: + raise AssertionError("wechat_bot 缺少方法:" + repr(missing)) + cls = ast.ClassDef(name="WeChatBot", bases=[], keywords=[], body=methods, decorator_list=[]) + module = ast.Module(body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0), + *assigns, *helpers, cls], type_ignores=[]) + namespace = {"hashlib": hashlib, "json": json, "os": os, "time": time} + exec(compile(ast.fix_missing_locations(module), str(path), "exec"), namespace) + return namespace + + +class ReviewMatchTextTest(unittest.TestCase): + """发送闸和审核复查共用的客户侧比对文字。""" + + @classmethod + def setUpClass(cls): + cls.match_text = staticmethod(_isolated_bot_namespace()["review_match_text"]) + + def test_first_contact_placeholder_is_joined_with_customer_words(self): + state = {"staged_user_text": FIRST_CONTACT_PLACEHOLDER, "staged_review_text": INCIDENT_CUSTOMER, + "last_lines": ["不该用到的聊天行"]} + self.assertEqual(self.match_text(state), FIRST_CONTACT_PLACEHOLDER + "\n" + INCIDENT_CUSTOMER) + # 占位文字本身命中不了规则,拼上客户原话才拦得住事故那一句 + rules = PRODUCTION_RULES + [USAGE_RULE] + self.assertEqual(reason(FIRST_CONTACT_PLACEHOLDER, "好的", rules), "") + self.assertEqual(reason(self.match_text(state), "好的", rules), "命中审核规则:用法用量") + + def test_last_lines_stand_in_for_missing_staged_text(self): + self.assertEqual(self.match_text({"last_lines": ["第一行", 2]}), "第一行\n2") + self.assertEqual(self.match_text({"staged_user_text": "", "last_lines": ["聊天行"], + "staged_review_text": "原话"}), "聊天行\n原话") + self.assertEqual(self.match_text({"staged_review_text": "只有原话"}), "\n只有原话") + + def test_without_review_text_only_staged_text_is_used(self): + for extra in ({}, {"staged_review_text": ""}, {"staged_review_text": None}): + with self.subTest(extra=extra): + self.assertEqual(self.match_text(dict({"staged_user_text": "可信的客户原话"}, **extra)), + "可信的客户原话") + + def test_empty_or_missing_state_gives_empty_text(self): + for state in (None, {}, "", [], {"staged_user_text": None, "last_lines": None}): + with self.subTest(state=state): + self.assertEqual(self.match_text(state), "") + + def test_send_gate_and_recheck_use_the_helper(self): + tree = _wechat_bot_tree() + bot = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot") + + def uses_helper(node): + return isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "review_match_text" + + # 发送闸:_reply_review_decision 的客户文字参数必须直接来自 review_match_text + gate_calls = [node for node in ast.walk(bot) if isinstance(node, ast.Call) + and isinstance(node.func, ast.Attribute) and node.func.attr == "_reply_review_decision"] + self.assertTrue(gate_calls) + for call in gate_calls: + with self.subTest(line=call.lineno): + self.assertTrue(len(call.args) >= 2 and uses_helper(call.args[1]), + "发送闸没有用 review_match_text 取客户文字") + # 取的必须是同一个待发任务,不能是 None 或别的状态 + helper_args = call.args[1].args + self.assertTrue(isinstance(call.args[0], ast.Name) and len(helper_args) == 1 + and isinstance(helper_args[0], ast.Name) and helper_args[0].id == call.args[0].id, + "review_match_text 没有拿到发送闸自己的待发任务") + # 复查:_drop_stale_review_flags 用同一个函数取证据(行为另由 VisualReviewHoldTest 覆盖) + recheck = next(node for node in bot.body + if isinstance(node, ast.FunctionDef) and node.name == "_drop_stale_review_flags") + self.assertTrue(any(uses_helper(node) for node in ast.walk(recheck))) + + def test_first_contact_branch_stages_the_real_words_for_review(self): + # 首次会话归档用占位文字;规则比对要的原话由这一支单独暂存,丢了它 BUG 2 就回来了。 + tree = _wechat_bot_tree() + bot = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot") + placeholder = "(首次会话的新消息已由聊天截图确认)" + branches = [node for node in ast.walk(bot) if isinstance(node, ast.If) and any( + isinstance(stmt, ast.Assign) and isinstance(stmt.value, ast.Constant) and stmt.value.value == placeholder + for stmt in node.body)] + self.assertEqual(len(branches), 1, "找不到首次会话的占位分支") + assigned = [stmt.value for stmt in branches[0].body if isinstance(stmt, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "review_text" for t in stmt.targets)] + self.assertTrue(assigned and isinstance(assigned[-1], ast.Call) + and isinstance(assigned[-1].func, ast.Name) and assigned[-1].func.id == "latest_customer_turn", + "首次会话分支没有把客户原话放进 review_text") + method = next(node for node in bot.body if isinstance(node, ast.FunctionDef) + and any(sub is branches[0] for sub in ast.walk(node))) + stage_calls = [node for node in ast.walk(method) if isinstance(node, ast.Call) + and isinstance(node.func, ast.Attribute) and node.func.attr == "_stage_exchange"] + self.assertTrue(stage_calls) + for call in stage_calls: + with self.subTest(line=call.lineno): + passed = [kw.value for kw in call.keywords if kw.arg == "review_text"] + self.assertTrue(passed and isinstance(passed[0], ast.Name) and passed[0].id == "review_text", + "_stage_exchange 没有收到 review_text") + + +class VisualReviewHoldTest(unittest.TestCase): + """视觉链路的发送闸/复查:影子模式高风险不再被复查放行,首次会话原话参与规则比对。""" + + @classmethod + def setUpClass(cls): + cls.bot_class = _isolated_bot_namespace()["WeChatBot"] + + def setUp(self): + self.config = ModuleType("ai_config") + self.config.AI_REVIEW_RULES = [] + patcher = mock.patch.dict(sys.modules, {"ai_config": self.config}) + patcher.start() + self.addCleanup(patcher.stop) + self.fp = b"r" * 40 + self.key = self.fp.hex() + self.state = {"stage": "manual_review", "awaiting_review": True, "review_origin": "rule", + "staged_user_text": "问题", "staged_reply_text": "回复", "reply_text": "回复"} + bot = self.bot = self.bot_class() + bot.send_mode = "auto" + bot._pending_lock = threading.RLock() + bot._pending_reply_sessions = {self.key: self.state} + bot._pending_reply_state = lambda fp: bot._pending_reply_sessions.get(bytes(fp).hex()) + bot._persist_pending_replies = mock.Mock(return_value=True) + bot._forget_uncertain_tracking = mock.Mock() + + def drop(self): + with mock.patch("builtins.print"): + self.bot._drop_stale_review_flags() + + def test_shadow_high_risk_hold_stays_held(self): + for mode in ("shadow", "score_only", ""): + with self.subTest(mode=mode): + self.state.update(awaiting_review=True, stage="manual_review", review_reason=HIGH_RISK, + judge_risk="high", judge_mode=mode) + self.assertEqual(self.bot._reply_needs_review(self.state, "问题", "回复"), (True, HIGH_RISK)) + self.drop() + self.assertTrue(self.state["awaiting_review"]) + self.assertEqual(self.state["stage"], "manual_review") + self.assertFalse(self.state.get("review_approved")) + + def test_obsolete_keyword_hold_is_still_released(self): + self.config.AI_REVIEW_RULES = [rule("问题", label="已关闭", enabled=False)] + self.state.update(review_reason="命中审核规则:已关闭", judge_risk="low", judge_mode="shadow") + self.drop() + self.assertFalse(self.state.get("awaiting_review")) + self.assertEqual(self.state["stage"], "queued") + self.assertFalse(self.state.get("review_approved")) + + def test_first_contact_customer_words_keep_rule_hold(self): + self.config.AI_REVIEW_RULES = PRODUCTION_RULES + [USAGE_RULE] + reply = "您好,这边帮您确认一下" + self.bot._stage_exchange(self.fp, FIRST_CONTACT_PLACEHOLDER, reply, review_text=INCIDENT_CUSTOMER) + self.assertEqual(self.state["staged_user_text"], FIRST_CONTACT_PLACEHOLDER) + self.assertEqual(self.state["staged_review_text"], INCIDENT_CUSTOMER) + self.assertEqual(self.bot._pending_exchanges[self.key], (FIRST_CONTACT_PLACEHOLDER, reply)) + # 只看占位文字永远命中不了规则——这正是要修的问题 + self.assertEqual(self.bot._reply_needs_review(self.state, FIRST_CONTACT_PLACEHOLDER, reply), (False, "")) + self.state.update(review_reason="命中审核规则:用法用量", staged_reply_text=reply, reply_text=reply) + self.drop() + self.assertTrue(self.state["awaiting_review"]) + self.assertEqual(self.state["review_reason"], "命中审核规则:用法用量") + + def test_review_text_does_not_outlive_its_batch(self): + self.bot._stage_exchange(self.fp, FIRST_CONTACT_PLACEHOLDER, "回复", review_text=INCIDENT_CUSTOMER) + self.bot._stage_exchange(self.fp, "可信的客户原话", "回复") + self.assertNotIn("staged_review_text", self.state) + self.bot._stage_exchange(self.fp, FIRST_CONTACT_PLACEHOLDER, "回复", review_text=INCIDENT_CUSTOMER) + self.bot._reset_pending_batch_unlocked(self.fp) + self.assertNotIn("staged_review_text", self.state) + + def test_review_text_survives_restart(self): + root = tempfile.mkdtemp() + self.addCleanup(shutil.rmtree, root, True) + self.bot._pending_reply_path = os.path.join(root, "pending_replies.json") + self.bot._manual_handoff_key = lambda fp: "" + self.state.update(review_reason="命中审核规则:用法用量", staged_user_text=FIRST_CONTACT_PLACEHOLDER, + staged_review_text=INCIDENT_CUSTOMER, confirmed_unread=True, updated_at=time.time()) + self.assertTrue(self.bot._persist_pending_replies_unlocked()) + with mock.patch("builtins.print"): + restored = self.bot._load_pending_replies()[self.key] + self.assertEqual(restored["staged_review_text"], INCIDENT_CUSTOMER) + self.assertEqual(restored["staged_user_text"], FIRST_CONTACT_PLACEHOLDER) + self.config.AI_REVIEW_RULES = [USAGE_RULE] + self.bot._pending_reply_sessions = {self.key: restored} + self.drop() + self.assertTrue(restored["awaiting_review"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/test_review_scope.py b/test_review_scope.py new file mode 100644 index 0000000..115fba7 --- /dev/null +++ b/test_review_scope.py @@ -0,0 +1,249 @@ +# -*- coding: utf-8 -*- +"""审核后发送的审核范围:每条都审核 / 按原规则(医疗助理人工回复后该会话恢复自动)。 + +管理后台「客户端配置」统一下发 AI_REVIEW_EVERY_REPLY;本机可以跟随(默认)或单独设为 +every / rules。只用内存数据。wechat_bot / protocol_engine 的相关方法按 AST 从源码单独编译, +不导入整个模块(导入会初始化运行目录,源码运行时会改写源码目录);请在临时副本里运行。 +""" + +import ast +import sys +import unittest +from pathlib import Path +from types import ModuleType, SimpleNamespace +from unittest import mock + +import review_assistant +import review_assistant_contacts +import review_policy + +ROOT = Path(__file__).resolve().parent + + +def _compile(path, class_name, names): + tree = ast.parse((ROOT / path).read_text(encoding="utf-8-sig"), filename=str(ROOT / path)) + original = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == class_name) + methods = [node for node in original.body if isinstance(node, ast.FunctionDef) and node.name in names] + missing = set(names) - {node.name for node in methods} + if missing: + raise AssertionError(f"{path} 缺少方法:{missing!r}") + assigns = [node for node in tree.body if isinstance(node, ast.Assign) + and any(isinstance(t, ast.Name) and t.id in {"SEND_MODE_AUTO", "SEND_MODE_REVIEW"} for t in node.targets)] + cls = ast.ClassDef(name=class_name, bases=[], keywords=[], body=methods, decorator_list=[]) + module = ast.Module(body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0), + *assigns, cls], type_ignores=[]) + namespace = {} + exec(compile(ast.fix_missing_locations(module), str(ROOT / path), "exec"), namespace) + return namespace[class_name] + + +def _admin_config(every): + """后台下发到本机 ai_config 的那一项。""" + config = ModuleType("ai_config") + config.AI_REVIEW_RULES = [] + config.AI_REVIEW_EVERY_REPLY = every + return mock.patch.dict(sys.modules, {"ai_config": config}) + + +class _Assistant: + def __init__(self, resumed=False, pending=False): + self._resumed, self._pending = resumed, pending + + def has_pending(self, conv_id): + return self._pending + + def resumed(self, conv_id): + return self._resumed + + +class ScopeRuleTest(unittest.TestCase): + """本机选了就按本机,否则跟随后台;只有明确的 True 才算每条都审核。""" + + def test_normalize(self): + for value, expected in (("follow", "follow"), ("every", "every"), ("rules", "rules"), (" EVERY ", "every"), + (True, "every"), (False, "follow"), (None, "follow"), ("", "follow"), ("x", "follow")): + with self.subTest(value=value): + self.assertEqual(review_policy.normalize_review_scope(value), expected) + + def test_effective_value(self): + cases = [("follow", True, True), ("follow", False, False), ("follow", None, False), ("follow", "true", False), + ("every", False, True), ("every", True, True), ("rules", True, False), ("rules", False, False), + ("bogus", True, True)] + for scope, admin, expected in cases: + with self.subTest(scope=scope, admin=admin): + self.assertIs(review_policy.review_every_reply(scope, admin), expected) + + +class VisualDecisionTest(unittest.TestCase): + """视觉链路发送闸:blanket = 审核后发送 且(每条都审核 或 会话没有恢复自动)。""" + + @classmethod + def setUpClass(cls): + cls.bot_class = _compile("wechat_bot.py", "WeChatBot", + {"_reply_review_decision", "_review_mode_enabled", "_review_every_reply"}) + + def decide(self, send_mode, scope, admin, resumed, pending=False): + bot = self.bot_class.__new__(self.bot_class) + bot.send_mode = send_mode + bot.review_scope = scope + assistant = _Assistant(resumed=resumed, pending=pending) + bot._get_review_assistant = lambda verify=False: assistant + bot._review_assistant_context = lambda state: {"conv_id": "conv-1", "account": "acct"} + bot._reply_needs_review = lambda state, customer, reply: (False, "") + with _admin_config(admin): + return bot._reply_review_decision({}, "客户原话", "回复") + + def test_follow_uses_the_admin_setting(self): + self.assertTrue(self.decide("review", "follow", True, resumed=True)[0]) + self.assertFalse(self.decide("review", "follow", False, resumed=True)[0]) + + def test_local_choice_overrides_the_admin_setting(self): + self.assertTrue(self.decide("review", "every", False, resumed=True)[0]) + self.assertFalse(self.decide("review", "rules", True, resumed=True)[0]) + + def test_review_mode_without_resume_always_holds(self): + for scope in ("follow", "every", "rules"): + for admin in (False, True): + with self.subTest(scope=scope, admin=admin): + self.assertTrue(self.decide("review", scope, admin, resumed=False)[0]) + + def test_auto_mode_ignores_the_scope(self): + for scope in ("follow", "every", "rules"): + with self.subTest(scope=scope): + self.assertFalse(self.decide("auto", scope, True, resumed=True)[0]) + self.assertFalse(self.decide("auto", scope, True, resumed=False)[0]) + + def test_pending_review_still_holds(self): + blanket, held, reason = self.decide("review", "rules", False, resumed=True, pending=True) + self.assertTrue(blanket) # has_pending 时 resumed 不成立 + self.assertTrue(held) + self.assertIn("待审核", reason) + + def test_missing_local_scope_follows_the_admin_setting(self): + bot = self.bot_class.__new__(self.bot_class) + bot.send_mode = "review" + with _admin_config(True): + self.assertTrue(bot._review_every_reply()) + bot.send_mode = "auto" + with _admin_config(True): + self.assertFalse(bot._review_every_reply()) + + +class ProtocolDecisionTest(unittest.TestCase): + """协议链路 _needs_review:同一条规则。""" + + @classmethod + def setUpClass(cls): + cls.bot_class = _compile("protocol_engine.py", "ProtocolBot", {"_needs_review", "_review_every_reply"}) + + def decide(self, send_mode, scope, admin, resumed): + bot = self.bot_class.__new__(self.bot_class) + bot.send_mode = send_mode + bot.review_scope = scope + bot._assistant_pending = lambda state: False + bot._assistant_call = lambda name, *args, **kwargs: resumed if name == "resumed" else None + with _admin_config(admin): + return bot._needs_review({"conv_id": "conv-1", "staged_user_text": "在吗", "reply_text": "在的"}) + + def test_follow_uses_the_admin_setting(self): + review, reason = self.decide("review", "follow", True, resumed=True) + self.assertTrue(review) + self.assertIn("通过并发送", reason) + self.assertEqual(self.decide("review", "follow", False, resumed=True), (False, "")) + + def test_local_choice_overrides_the_admin_setting(self): + self.assertTrue(self.decide("review", "every", False, resumed=True)[0]) + self.assertEqual(self.decide("review", "rules", True, resumed=True), (False, "")) + + def test_auto_mode_ignores_the_scope(self): + self.assertEqual(self.decide("auto", "every", True, resumed=False), (False, "")) + + +class NotificationWordingTest(unittest.TestCase): + """发给医疗助理的提醒、界面状态和提醒示例都要说清人工回复后会不会恢复自动。""" + + def episode(self, **extra): + return {"id": "0123456789abcdef", "account": "acct", "name": "客户", "conv": "conv-1", + "created": 0, "handling_kind": "review", "reason": "人工审核", "context": "客户:在吗", + "draft": "在的", **extra} + + def test_rules_scope_keeps_the_resume_sentence(self): + text = review_assistant.notification_text(self.episode()) + self.assertIn("后续新消息恢复自动回复", text) + self.assertEqual(text, review_assistant.notification_text(self.episode(resume_after_manual=True))) + + def test_every_reply_scope_says_review_continues(self): + text = review_assistant.notification_text(self.episode(resume_after_manual=False)) + self.assertNotIn("恢复自动回复", text) + self.assertIn("每条都审核", text) + + def test_preview_follows_the_scope(self): + self.assertIn("后续自动回复仍逐条风控", review_assistant_contacts.notification_preview("acct")) + preview = review_assistant_contacts.notification_preview("acct", every_reply=True) + self.assertIn("每条都审核", preview) + self.assertNotIn("后续自动回复", preview) + + +class SettingsPlumbingTest(unittest.TestCase): + """本机设置归一化、运行中切换、后台下发项,以及待发任务落盘带上这次用的审核范围。""" + + @classmethod + def setUpClass(cls): + tree = ast.parse((ROOT / "gui_runtime.py").read_text(encoding="utf-8-sig")) + func = next(node for node in tree.body if isinstance(node, ast.FunctionDef) + and node.name == "normalize_review_scope") + thread = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "BotThread") + setter = next(node for node in thread.body if isinstance(node, ast.FunctionDef) + and node.name == "set_review_scope") + cls_node = ast.ClassDef(name="BotThread", bases=[], keywords=[], body=[setter], decorator_list=[]) + namespace = {} + exec(compile(ast.fix_missing_locations(ast.Module(body=[func, cls_node], type_ignores=[])), "gui_runtime", "exec"), + namespace) + cls.normalize = staticmethod(namespace["normalize_review_scope"]) + cls.thread_class = namespace["BotThread"] + + def test_gui_runtime_uses_the_shared_normalization(self): + for value in ("follow", "every", "rules", True, False, None, "bogus"): + with self.subTest(value=value): + self.assertEqual(self.normalize(value), review_policy.normalize_review_scope(value)) + + def test_running_thread_updates_its_bot(self): + thread = self.thread_class.__new__(self.thread_class) + thread.bot = SimpleNamespace(review_scope="follow") + thread.set_review_scope("every") + self.assertEqual(thread.review_scope, "every") + self.assertEqual(thread.bot.review_scope, "every") + thread.bot = None + thread.set_review_scope("bogus") + self.assertEqual(thread.review_scope, "follow") + + def test_admin_setting_is_synced_into_ai_config(self): + tree = ast.parse((ROOT / "ai_config.py").read_text(encoding="utf-8-sig")) + keys = next(node.value for node in tree.body if isinstance(node, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "CONFIGURABLE_KEYS" for t in node.targets)) + self.assertIn("AI_REVIEW_EVERY_REPLY", [elt.value for elt in keys.elts]) + default = next(node for node in tree.body if isinstance(node, ast.AnnAssign) + and getattr(node.target, "id", "") == "AI_REVIEW_EVERY_REPLY") + self.assertIs(default.value.value, False) + + def test_pending_state_persists_the_scope(self): + tree = ast.parse((ROOT / "wechat_bot.py").read_text(encoding="utf-8-sig")) + bot = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot") + for name in ("_persist_pending_replies_unlocked", "_load_pending_replies"): + method = next(node for node in bot.body if isinstance(node, ast.FunctionDef) and node.name == name) + keys = {node.value for node in ast.walk(method) if isinstance(node, ast.Constant) and isinstance(node.value, str)} + with self.subTest(method=name): + self.assertIn("review_every_reply", keys) + + def test_gate_records_the_scope_used_for_the_hold(self): + tree = ast.parse((ROOT / "wechat_bot.py").read_text(encoding="utf-8-sig")) + bot = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "WeChatBot") + gate = next(node for node in bot.body if isinstance(node, ast.FunctionDef) and node.name == "_send_reply_inner") + assigned = [node for node in ast.walk(gate) if isinstance(node, ast.Assign) + and any(isinstance(t, ast.Subscript) and isinstance(t.slice, ast.Constant) + and t.slice.value == "review_every_reply" for t in node.targets)] + self.assertTrue(assigned, "发送闸没有记录这次审核用的范围") + + +if __name__ == "__main__": + unittest.main() diff --git a/wechat_bot.py b/wechat_bot.py index 2745866..ebf5385 100644 --- a/wechat_bot.py +++ b/wechat_bot.py @@ -1321,6 +1321,20 @@ def find_blocking_modal_close(img_np: np.ndarray) -> tuple[int, int] | None: return best[0], best[1] +def review_match_text(pending_state) -> str: + """审核规则比对用的客户侧文字;发送闸和审核复查必须用同一份证据。 + + 归档的客户原话(没有就用读到的聊天行),再加上单独暂存的 staged_review_text: + 首次会话归档的是占位文字,只看它永远命中不了规则,复查还会把发送闸的拦截放掉。 + """ + state = pending_state if isinstance(pending_state, dict) else {} + text = str(state.get("staged_user_text") or "\n".join( + str(line) for line in state.get("last_lines") or [])) + if state.get("staged_review_text"): + text += "\n" + str(state["staged_review_text"]) + return text + + # ────────────────────────────────────────────────────────────────────────────── # 主类 # ────────────────────────────────────────────────────────────────────────────── @@ -1380,6 +1394,8 @@ class WeChatBot: self.mouse_idle_seconds = MOUSE_IDLE_SECONDS self.send_delay_seconds = SEND_DELAY_SECONDS self.send_mode = SEND_MODE_AUTO + # 本机审核范围:follow = 跟随管理后台(默认),every = 每条都审核,rules = 按原规则 + self.review_scope = "follow" # 每次开始新的消息合并窗口时读取实例值。GUI 可在监听期间更新它, # 已经开始的窗口保持原截止时间,下一轮回复使用新设置 self.message_batch_window_seconds = MESSAGE_BATCH_WINDOW_SECONDS @@ -8657,13 +8673,23 @@ class WeChatBot: held = True # Cannot exclude an existing review without exact conversation evidence. except Exception: held = True # Missing review state cannot grant an automatic send. - blanket = self._review_mode_enabled() and not resumed + # 按原规则:医疗助理人工回复并核验后,该会话恢复自动(仍逐条过规则闸); + # 选了“每条都审核”就不看恢复记录,审核后发送模式下每条都等人确认。 + blanket = self._review_mode_enabled() and (self._review_every_reply() or not resumed) hit, reason = self._reply_needs_review(pending_state, customer_text, reply_text) return blanket, bool(hit or held), reason or ("本会话仍有待审核消息,等待同账号人工回复" if held else "") def _review_mode_enabled(self) -> bool: return str(getattr(self, "send_mode", SEND_MODE_AUTO)) == SEND_MODE_REVIEW + def _review_every_reply(self) -> bool: + if not self._review_mode_enabled(): + return False + import ai_config + from review_policy import review_every_reply + return review_every_reply(getattr(self, "review_scope", "follow"), + getattr(ai_config, "AI_REVIEW_EVERY_REPLY", False)) + def _reply_needs_review( self, pending_state: dict | None, customer_text: str, reply_text: str ) -> tuple[bool, str]: @@ -9157,6 +9183,7 @@ class WeChatBot: archive_enabled: bool = True, registration_lead: dict | None = None, user_image: str = "", + review_text: str = "", ) -> None: pending = getattr(self, "_pending_exchanges", None) if pending is None: @@ -9169,6 +9196,12 @@ class WeChatBot: state["staged_user_text"] = str(user_text or "") state["staged_reply_text"] = str(reply_text or "") state["staged_user_image"] = str(user_image or "") + # 只给审核规则比对用的客户原话(首次会话归档的是占位文字), + # 不归档、不进模型;发送闸和审核复查都要读它 + if review_text: + state["staged_review_text"] = str(review_text) + else: + state.pop("staged_review_text", None) state["archive_enabled"] = bool(archive_enabled) if not state.get("exchange_id"): seed = ( @@ -9453,6 +9486,7 @@ class WeChatBot: "conv_id": str(value.get("conv_id") or ""), "assistant_review_id": str(value.get("assistant_review_id") or ""), "review_reason": str(value.get("review_reason") or "")[:500], + "review_every_reply": value.get("review_every_reply") is True, "origin_request": str(value.get("origin_request") or ""), "origin_account": str(value.get("origin_account") or ""), "origin_conversation": str(value.get("origin_conversation") or ""), @@ -9466,6 +9500,7 @@ class WeChatBot: "reply_text": str(value.get("reply_text") or ""), "staged_user_text": str(value.get("staged_user_text") or ""), "staged_reply_text": str(value.get("staged_reply_text") or ""), + "staged_review_text": str(value.get("staged_review_text") or ""), "exchange_id": str(value.get("exchange_id") or ""), "knowledge_trace": self._knowledge_trace_metadata(value.get("knowledge_trace")), "model_task_id": str(value.get("model_task_id") or "")[:128], @@ -9648,6 +9683,7 @@ class WeChatBot: "conv_id": str(value.get("conv_id") or ""), "assistant_review_id": str(value.get("assistant_review_id") or ""), "review_reason": str(value.get("review_reason") or "")[:500], + "review_every_reply": value.get("review_every_reply") is True, "origin_request": str(value.get("origin_request") or ""), "origin_account": str(value.get("origin_account") or ""), "origin_conversation": str(value.get("origin_conversation") or ""), @@ -9663,6 +9699,7 @@ class WeChatBot: "reply_text": str(value.get("reply_text") or ""), "staged_user_text": str(value.get("staged_user_text") or ""), "staged_reply_text": str(value.get("staged_reply_text") or ""), + "staged_review_text": str(value.get("staged_review_text") or ""), "exchange_id": str(value.get("exchange_id") or ""), "knowledge_trace": self._knowledge_trace_metadata(value.get("knowledge_trace")), "model_task_id": str(value.get("model_task_id") or "")[:128], @@ -10031,7 +10068,8 @@ class WeChatBot: word in old_reason for word in ("命中审核规则", "模型裁判")) if not known: continue - customer = str(state.get("staged_user_text") or "\n".join(str(line) for line in state.get("last_lines") or [])) + # Same evidence as the send gate, or a first-contact hold is released here. + customer = review_match_text(state) reply = str(state.get("staged_reply_text") or state.get("reply_text") or "") # A legacy rule hold without its evidence cannot be re-evaluated. if old_reason and (not customer.strip() or not reply.strip()): @@ -10344,6 +10382,7 @@ class WeChatBot: state.pop("reply_text", None) state.pop("staged_user_text", None) state.pop("staged_reply_text", None) + state.pop("staged_review_text", None) state.pop("exchange_id", None) state.pop("knowledge_trace", None) state.pop("model_task_id", None) @@ -10356,6 +10395,7 @@ class WeChatBot: state.pop("assistant_review_id", None) state.pop("review_reason", None) state.pop("review_origin", None) + state.pop("review_every_reply", None) state.pop("judge_risk", None) state.pop("judge_mode", None) state.pop("judge_reason", None) @@ -10933,10 +10973,13 @@ class WeChatBot: persisted = handoff_unlocked() if not persisted: return result - from gui_runtime import cancel_assistant_review_for_state + from gui_runtime import handoff_assistant_review_for_state + notified = False for key, state in removed: - if state.get("assistant_review_id"): - cancel_assistant_review_for_state(state, os.path.dirname(self._pending_reply_path)) + # 转人工也提醒医疗助理;提醒没开启或会话核对不了时按原方式取消提醒。 + notified = handoff_assistant_review_for_state( + state, os.path.dirname(self._pending_reply_path), db=getattr(self, "_db_source", None) + ) or notified result["handed_off"].append(key) result["deleted"].append(key) getattr(self, "_pending_exchanges", {}).pop(key, None) @@ -10953,6 +10996,9 @@ class WeChatBot: "本条已移出自动队列,发送证据保留,未标记送达;请在企业微信继续处理") except Exception: pass + assistant = getattr(self, "_review_assistant", None) + if notified and assistant is not None: + assistant.enqueue_notifications() return result @@ -13384,9 +13430,9 @@ class WeChatBot: # 才破例停下来,其余照常自动发送。两者是 OR:任何一个成立都要停。 if self._skip_excluded_reply_session(expected_fp, inspect_open=True): return self._deny_send(str(getattr(self, "_last_session_exclusion_reason", "会话不参与自动回复"))) + # 首次会话归档的是占位文字,客户原话单独暂存,一并比对审核规则 blanket_review, rule_hit, rule_reason = self._reply_review_decision( - pending_state, str((pending_state or {}).get("staged_user_text") or "\n".join( - str(line) for line in (pending_state or {}).get("last_lines") or [])), reply_text, + pending_state, review_match_text(pending_state), reply_text, ) if (blanket_review or rule_hit) and not (pending_state or {}).get( "review_approved", False @@ -13398,6 +13444,8 @@ class WeChatBot: pending_state["last_pasted_draft"] = expected_reply pending_state["review_reason"] = rule_reason pending_state["review_origin"] = "global" if blanket_review else "rule" + # 提醒医疗助理时要说清:人工回复后会话会不会恢复自动 + pending_state["review_every_reply"] = self._review_every_reply() if blanket_review: detail = "AI 回复已填入输入框,等待人工核对并发送" reason = "回复已填入输入框,等待人工审核发送" @@ -16199,8 +16247,12 @@ class WeChatBot: print(" [回复保护] 模型处理期间又出现新消息,已取消旧回复并重新合并。") self._reset_pending_batch(fp) return None + review_text = "" if first_untrusted_batch and not media_types: customer_text = "(首次会话的新消息已由聊天截图确认)" + # 整屏复制的末尾未必是本轮客户原话,所以不归档、不做挂号登记; + # 但拿它比对审核关键词只会多拦、不会放行,占位文字则永远命中不了 + review_text = latest_customer_turn(chat_text or "") else: customer_text = ( media_archive_text( @@ -16279,6 +16331,7 @@ class WeChatBot: archive_enabled=AI_CONTEXT_ENABLED, registration_lead=lead, user_image=media_snapshot, + review_text=review_text, ) else: print(" [AI] [!] AI 未返回有效回复,本次不发送") diff --git a/wechat_gui_qt.py b/wechat_gui_qt.py index 0c6ce9d..49b93b7 100644 --- a/wechat_gui_qt.py +++ b/wechat_gui_qt.py @@ -108,6 +108,7 @@ from gui_runtime import ( normalize_message_batch_window_seconds, normalize_send_delay_seconds, normalize_send_mode, + normalize_review_scope, ) from gui_runtime import ( FOREIGN_DRAFT_AUTOSEND_MAX_MINUTES, @@ -2757,6 +2758,17 @@ class SettingsPage(QScrollArea): mode_row.addWidget(self.auto_send_mode) mode_row.addWidget(self.review_send_mode) layout.addWidget(modes) + # 审核后发送的审核范围:默认跟随管理后台「客户端配置」统一设置,也可以本机单独设为 + # 每条都审核(人工回复过的会话也不恢复自动)或按原规则(人工回复并核验后恢复自动)。 + self.review_scope = QComboBox() + for scope_label, scope_value in (("审核范围:跟随管理后台统一设置", "follow"), + ("审核范围:每条都审核(人工回复过的会话也不恢复自动)", "every"), + ("审核范围:按原规则(人工回复后该会话恢复自动)", "rules")): + self.review_scope.addItem(scope_label, scope_value) + self.review_scope.setCurrentIndex(max(0, self.review_scope.findData( + normalize_review_scope(settings.get("review_scope", "follow"))))) + self.review_scope.currentIndexChanged.connect(self._schedule_save) + layout.addWidget(self.review_scope) layout.addSpacing(7) self.reply = QLineEdit(str(settings["auto_reply_text"])) @@ -2956,16 +2968,15 @@ class SettingsPage(QScrollArea): handoff, handoff_box = _compact_card("高风险转人工") handoff.setFixedHeight(245) handoff_box.setSpacing(4) + # 模型裁判判为高风险一律转人工,内置、关不掉,所以一直是“已开启”; + # 下面的标签按后台下发的审核规则显示,见 refresh_review_rules。 handoff_box.addWidget(_chip("● 已开启", "success"), 0, Qt.AlignRight) self.risk_rule_buttons = [] - for text in ("♧ 诊断", "◇ 用药调整", "♢ 投诉退款"): - button = _button(text) - button.setFixedSize(122, 36) - button.setStyleSheet("QPushButton{background:#FFFFFF;color:#6554E8;border:1px solid #D8D0FB;border-radius:12px;padding:4px 10px;font-size:13px;}QPushButton:hover{color:#5440DA;border-color:#BDAFFA;}") - button.setEnabled(False) - button.setToolTip("内置高风险转人工类别;请通过“规则管理”查看安全策略。") - self.risk_rule_buttons.append(button) - handoff_box.addWidget(button, 0, Qt.AlignLeft) + self._risk_rule_box = QVBoxLayout() + self._risk_rule_box.setContentsMargins(0, 0, 0, 0) + self._risk_rule_box.setSpacing(4) + handoff_box.addLayout(self._risk_rule_box) + self.refresh_review_rules() self.manage_rules_button = _button("⚙ 规则管理") self.manage_rules_button.setFixedSize(145, 36) self.manage_rules_button.setStyleSheet("QPushButton{background:#FFFFFF;color:#6554E8;border:1px solid #D8D0FB;border-radius:12px;padding:4px 10px;font-size:13px;}QPushButton:hover{color:#5440DA;border-color:#BDAFFA;}") @@ -3036,6 +3047,7 @@ class SettingsPage(QScrollArea): if self.review_send_mode.isChecked() else SEND_MODE_AUTO ), + "review_scope": self.review_scope.currentData() or "follow", "message_batch_window_seconds": float(self.batch_window.value()), # 开关关掉就存 0(= 关闭)。分钟数留在控件里不动,下次打开还是老值。 "foreign_draft_autosend_minutes": ( @@ -3045,6 +3057,27 @@ class SettingsPage(QScrollArea): ), } + def refresh_review_rules(self, *_args) -> None: + """按后台下发的 AI_REVIEW_RULES 重建「高风险转人工」的标签,只列启用的规则。""" + labels = [rule["label"] for rule in MainWindow._console_review_rules() if rule["enabled"]] + for button in self.risk_rule_buttons: + self._risk_rule_box.removeWidget(button) + button.deleteLater() + self.risk_rule_buttons = [] + # 卡片定高,只放得下三个标签;多出来的并成“等 N 条规则”,完整清单在提示里。 + shown = labels if len(labels) <= 3 else labels[:2] + [f"等 {len(labels)} 条规则"] + tooltip = (("已启用的审核规则:" + "、".join(labels)) if labels else "没有启用的关键词规则") + ( + "。模型裁判判为高风险的回复同样转人工(内置,关不掉);请通过“规则管理”查看安全策略。") + for text in shown or ["暂无关键词规则"]: + button = _button("◇ " + text) + button.setFixedHeight(36) + button.setMinimumWidth(122) + button.setStyleSheet("QPushButton{background:#FFFFFF;color:#6554E8;border:1px solid #D8D0FB;border-radius:12px;padding:4px 10px;font-size:13px;}QPushButton:hover{color:#5440DA;border-color:#BDAFFA;}") + button.setEnabled(False) + button.setToolTip(tooltip) + self.risk_rule_buttons.append(button) + self._risk_rule_box.addWidget(button, 0, Qt.AlignLeft) + def _refresh_send_mode_buttons(self) -> None: active_style = ( "background:#E8EDFF;color:#245DE7;border:none;border-radius:14px;" @@ -8202,6 +8235,8 @@ class PatientBindingDialog(QDialog): self._binding: dict | None = None self.changed = False self._patient_session_expired = False + # 本窗口里重新验证过 ZYT 登录;之后再报“已过期”就不是重新验证能解决的。 + self._reauthenticated = False self._busy = False layout = QVBoxLayout(self) @@ -8366,13 +8401,32 @@ class PatientBindingDialog(QDialog): self.hint_label.setText(text) def _show_patient_session_expired(self) -> None: - self._patient_session_expired = True self._patients = [] self.result_table.setRowCount(0) + if self._reauthenticated: + # 刚重新验证成功,查询仍报“已过期”:多半是 ZYT 按登录 IP 拒绝了客服后台 + # (旧后台不会单独报 zyt_ip_restricted)。再验证只会重复同样的结果,所以 + # 不再给重新验证按钮;搜索保持可用,稍后可直接重试,关掉窗口重开也会复位。 + self._patient_session_expired = False + self.reauthenticate_button.hide() + self._set_busy(False, "已重新验证 ZYT 登录,但患者查询仍被 ZYT 拒绝," + "可能是 ZYT 登录 IP 校验,请联系管理员。") + return + self._patient_session_expired = True self.reauthenticate_button.show() self._set_busy(False, "ZYT 患者查询登录已过期,请点击下方按钮重新验证当前账号。" "验证后可重新搜索并核对患者,客服监听继续运行。") + def _show_patient_query_rejected(self, message: object = "") -> None: + # ZYT 拒绝的是客服后台的查询(登录 IP 校验),不是登录过期:重新验证只会把 + # 令牌再绑回本机 IP,所以不给重新验证按钮;搜索保持可用,管理员放行后可直接重试。 + self._patient_session_expired = False + self._patients = [] + self.result_table.setRowCount(0) + self.reauthenticate_button.hide() + self._set_busy(False, str(message or "").strip() + or "ZYT 拒绝了客服后台的患者查询(登录 IP 校验),重新验证无法解决,请联系管理员。") + def _reauthenticate(self) -> None: if self._busy: return @@ -8393,15 +8447,19 @@ class PatientBindingDialog(QDialog): person_id = str(self._selected_person().get("id") or "") def work() -> None: + verified = False try: backend_client.reauthenticate_patient_session(password) + verified = True context = backend_client.desktop_patient_context( self.external_account_id, self.conversation_external_id, person_id=person_id, ) payload = {"ok": True, "context": context} except Exception as exc: - payload = {"ok": False, "error": str(exc)} + payload = {"ok": False, "error": str(exc), "verified": verified, + "patient_session_expired": isinstance(exc, backend_client.PatientSessionExpired), + "patient_query_rejected": isinstance(exc, backend_client.PatientQueryRejected)} try: self.reauthenticationFinished.emit(payload) except RuntimeError: @@ -8412,9 +8470,23 @@ class PatientBindingDialog(QDialog): @Slot(object) def _reauthentication_finished(self, payload: object) -> None: values = dict(payload or {}) if isinstance(payload, dict) else {} + if not values.get("ok") and values.get("verified"): + # ZYT 已重新验证,是随后读取患者关联失败,不能再报“验证失败”让人重复验证。 + self._reauthenticated = True + self._patient_session_expired = False + self.reauthenticate_button.hide() + if values.get("patient_query_rejected"): + self._show_patient_query_rejected(values.get("error")) + elif values.get("patient_session_expired"): + self._show_patient_session_expired() + else: + self._set_busy(False, "已重新验证 ZYT 登录,但患者关联读取失败:" + f"{values.get('error') or '未知错误'},可稍后重新搜索。") + return if not values.get("ok"): self._set_busy(False, f"验证失败:{values.get('error') or '请重试'}") return + self._reauthenticated = True self.context = dict(values.get("context") or {}) self.permissions = dict(self.context.get("permissions") or {}) self.can_search = bool(self.permissions.get("can_search")) @@ -8454,7 +8526,8 @@ class PatientBindingDialog(QDialog): payload = {"ok": True, "result": result} except Exception as exc: payload = {"ok": False, "error": str(exc), - "patient_session_expired": isinstance(exc, backend_client.PatientSessionExpired)} + "patient_session_expired": isinstance(exc, backend_client.PatientSessionExpired), + "patient_query_rejected": isinstance(exc, backend_client.PatientQueryRejected)} try: self.searchFinished.emit(payload) except RuntimeError: @@ -8467,6 +8540,9 @@ class PatientBindingDialog(QDialog): self._set_busy(False) values = dict(payload or {}) if isinstance(payload, dict) else {} if not values.get("ok"): + if values.get("patient_query_rejected"): + self._show_patient_query_rejected(values.get("error")) + return if values.get("patient_session_expired"): self._show_patient_session_expired() return @@ -8569,7 +8645,8 @@ class PatientBindingDialog(QDialog): payload = {"ok": True, "action": action, "result": result} except Exception as exc: payload = {"ok": False, "action": action, "error": str(exc), - "patient_session_expired": isinstance(exc, backend_client.PatientSessionExpired)} + "patient_session_expired": isinstance(exc, backend_client.PatientSessionExpired), + "patient_query_rejected": isinstance(exc, backend_client.PatientQueryRejected)} try: self.operationFinished.emit(payload) except RuntimeError: @@ -8582,6 +8659,9 @@ class PatientBindingDialog(QDialog): self._set_busy(False) values = dict(payload or {}) if isinstance(payload, dict) else {} if not values.get("ok"): + if values.get("patient_query_rejected"): + self._show_patient_query_rejected(values.get("error")) + return if values.get("patient_session_expired"): self._show_patient_session_expired() return @@ -9038,6 +9118,14 @@ class ConsoleBridge(QObject): self.host.settings_page._emit_save() self.host._push_console_state() + @Slot(str) + def setReviewScope(self, scope: str) -> None: + # follow = 跟随管理后台;every = 每条都审核;rules = 按原规则(人工回复后恢复自动) + box = self.host.settings_page.review_scope + box.setCurrentIndex(max(0, box.findData(normalize_review_scope(scope)))) + self.host.settings_page._emit_save() + self.host._push_console_state(force=True) + @Slot() def toggleIdle(self) -> None: box = self.host.settings_page.mouse_idle @@ -9938,8 +10026,8 @@ class MainWindow(QMainWindow): import backend_client result = backend_client.keepalive_zyt_session() - except Exception: - result = {"status": "unreachable"} + except Exception as exc: + result = {"status": "unreachable", "message": str(exc)} try: self.patientSessionChecked.emit(result) except RuntimeError: @@ -9954,12 +10042,36 @@ class MainWindow(QMainWindow): state = str(values.get("status") or "unreachable") if state == "skipped": return + # 没问到 ZYT 时不等下一个 30 分钟周期,几分钟后补一次;其余结果取消补查, + # 并从这次请求重新计 30 分钟,免得补查成功后下一次到点又被 25 分钟节流挡掉。 + if state == "unreachable": + # 每次失败都从这次请求重新计时:补查等待中周期检查又失败时,旧的补查 + # 会落在这次失败后的 5 分钟节流里被跳过,之后就没人再补查了。 + self.patient_session_retry_timer.start() + else: + self.patient_session_retry_timer.stop() + if self.patient_session_timer.isActive(): + self.patient_session_timer.start() previous = self._patient_session_state self._patient_session_state = state - if state == "expired" and previous != state: + if state == previous: + return + # 每种状态只在变化时记一条,补查反复失败也不会刷屏。 + detail = str(values.get("message") or "").strip() + if state == "expired": self.append_log("ZYT 患者查询登录已过期,可在绑定患者窗口重新验证;客服监听继续运行。", "warn") elif state == "active" and previous == "expired": self.append_log("ZYT 患者查询登录已恢复。", "ok") + elif state == "active" and previous in {"unreachable", "forbidden", "unsupported"}: + self.append_log("ZYT 患者查询会话保活已恢复正常。", "ok") + elif state == "unreachable": + self.append_log(f"ZYT 患者查询会话保活暂时失败:{detail or '连不上 ZYT 或客服后台'};" + "几分钟后自动重试,客服监听继续运行。", "warn") + elif state == "forbidden": + self.append_log(f"ZYT 患者查询会话保活被拒绝:{detail or '当前账号没有患者会话保活权限'}。", "warn") + elif state == "unsupported": + self.append_log(f"ZYT 未提供患者查询会话保活接口({detail or '接口不存在'})," + "患者查询登录到期后需在绑定患者窗口重新验证。", "warn") def _check_desktop_session(self) -> None: """后台校验桌面令牌;网络故障不误下线,401/403 才进入登录门禁。""" @@ -10239,9 +10351,16 @@ class MainWindow(QMainWindow): self._patient_keepalive_running = False self._patient_session_state = "unknown" self.patientSessionChecked.connect(self._patient_session_checked) + # 30 分钟一次;backend_client 按 25 分钟节流,保证每次到点都真正请求 ZYT。 self.patient_session_timer = QTimer(self) self.patient_session_timer.setInterval(30 * 60 * 1000) self.patient_session_timer.timeout.connect(self._keepalive_patient_session) + # 连不上时的补查:backend_client 对 unreachable 只节流 5 分钟,这里多留 1 分钟 + # 给计时器误差,免得补查刚好被节流掉。 + self.patient_session_retry_timer = QTimer(self) + self.patient_session_retry_timer.setSingleShot(True) + self.patient_session_retry_timer.setInterval(6 * 60 * 1000) + self.patient_session_retry_timer.timeout.connect(self._keepalive_patient_session) if "--qt-smoke-test" not in sys.argv: self.patient_session_timer.start() QTimer.singleShot(5000, self._keepalive_patient_session) @@ -10555,6 +10674,8 @@ class MainWindow(QMainWindow): self.queue_page.stopRequested.connect(self.stop_monitoring) self.queue_page.pageRequested.connect(self.show_page) self.persona_page.saved.connect(self._persona_saved) + # 后台配置同步后,设置页「高风险转人工」的标签跟着新的审核规则走。 + self.persona_page.cloudSyncFinished.connect(self.settings_page.refresh_review_rules) self.capsule.expandRequested.connect(self.expand_console) self.capsule.stopRequested.connect(self.stop_monitoring) self.reviewAssistantUpdated.connect(self._review_assistant_updated) @@ -10574,6 +10695,7 @@ class MainWindow(QMainWindow): "mouse_idle_seconds": 5.0, "send_delay_seconds": SEND_DELAY_SECONDS, "send_mode": SEND_MODE_AUTO, + "review_scope": "follow", "reply_transport": VISUAL, "message_batch_window_seconds": MESSAGE_BATCH_WINDOW_SECONDS, "foreign_draft_autosend_minutes": FOREIGN_DRAFT_AUTOSEND_MINUTES, @@ -10601,6 +10723,9 @@ class MainWindow(QMainWindow): saved = json.loads(APP_SETTINGS_FILE.read_text(encoding="utf-8")) if isinstance(saved, dict): settings.update({key: saved[key] for key in settings if key in saved}) + # 早先的本机开关只有“每条都审核”一个勾;勾过的迁成 every,其余跟随管理后台。 + if "review_scope" not in saved and saved.get("review_every_reply") is True: + settings["review_scope"] = "every" except (OSError, ValueError, TypeError): pass settings["reply_transport"] = normalize_reply_transport(settings["reply_transport"]) @@ -10611,6 +10736,7 @@ class MainWindow(QMainWindow): settings["send_delay_seconds"] ) settings["send_mode"] = normalize_send_mode(settings["send_mode"]) + settings["review_scope"] = normalize_review_scope(settings["review_scope"]) settings["message_batch_window_seconds"] = ( normalize_message_batch_window_seconds( settings["message_batch_window_seconds"] @@ -10690,6 +10816,7 @@ class MainWindow(QMainWindow): self.runtime_settings["send_delay_seconds"] )) thread.set_send_mode(self.runtime_settings["send_mode"]) + thread.set_review_scope(self.runtime_settings.get("review_scope", "follow")) thread.set_foreign_draft_autosend_minutes(float( self.runtime_settings["foreign_draft_autosend_minutes"] )) @@ -11583,9 +11710,17 @@ class MainWindow(QMainWindow): user_text = str(state.get("staged_user_text") or state.get("chat_text") or table_message or "").strip() answer = str(state.get("staged_reply_text") or state.get("reply_text") or "").strip() lines = [line.strip() for line in user_text.splitlines() if line.strip()] + # 首次会话归档的是占位文字,审核规则比对的是整屏复制出的末尾客户消息; + # 它可能混进别的内容,只能标明“未核实”附在后面,不算读取到的消息。 + review_text = " / ".join( + line.strip() for line in str(state.get("staged_review_text") or "").splitlines() if line.strip()) if self.runtime_settings.get("mask_sensitive", True): lines = [self._mask_sensitive_text(line) for line in lines] answer = self._mask_sensitive_text(answer) + review_text = self._mask_sensitive_text(review_text) + messages = [{"time": clock, "text": line} for line in (lines[-6:] or ([table_message] if table_message else []))] + if review_text: + messages.append({"time": "", "text": "屏幕识别文字(仅用于规则匹配,未核实):" + review_text}) step_index = page._queue_stage_index(state_text) transcribing = state.get("stage") == "voice_transcribing" processing = str(state.get("stage") or "") in {"generating", "collecting", "reading", "opening", "sending", "voice_transcribing"} @@ -11641,7 +11776,7 @@ class MainWindow(QMainWindow): "retries": f"{int(state.get('resume_failures') or 0)} 次", "messageCount": f"已读取 {len(lines) or (1 if user_text else 0)} 条消息", "action": "语音转文字" if transcribing else "AI 生成回复中" if processing and not answer else (state_text or current["status"]), - "messages": [{"time": clock, "text": line} for line in (lines[-6:] or ([table_message] if table_message else []))], + "messages": messages, "answer": answer, "confidence": "转文字中" if transcribing else "已生成" if answer else ("生成中" if processing else "—"), # 前端靠这一条决定要不要显示"通过并发送"。不传的话,审核模式下 @@ -12192,6 +12327,22 @@ class MainWindow(QMainWindow): return False, "当前版本不支持医疗助理处理提醒" return True, "" + def _review_assistant_summary(self, account, fallback=None) -> dict: + """面板上的“最近提醒”随界面刷新,最多每 3 秒读一次提醒库(只读)。""" + fallback = dict(fallback or {}) + if not account: + return fallback + now = time.monotonic() + cached = getattr(self, "_review_assistant_summary_cache", None) + if not cached or cached[0] != account or now - cached[1] >= 3.0: + try: + from review_assistant import notification_summary + cached = (account, now, notification_summary(SCRIPT_DIR, account)) + except Exception: + cached = (account, now, fallback) + self._review_assistant_summary_cache = cached + return dict(cached[2] or fallback) + def _review_assistant_console_state(self) -> dict: from review_assistant_contacts import notification_preview, recipient_display, recipient_peer available, reason = self._review_assistant_available() @@ -12215,7 +12366,7 @@ class MainWindow(QMainWindow): "busy": bool(getattr(self, "_review_assistant_busy", False)), "reason": reason or str(state.get("reason") or ("点击读取当前账号后,从我的客户选择医疗助理" if not account else "")), "message": str(state.get("message") or ""), - "notification": dict(state.get("notification") or {}), + "notification": self._review_assistant_summary(account, state.get("notification")), "attention": attention, "recipientWarning": warning, "enabled": config.get("enabled") is True, @@ -12223,7 +12374,10 @@ class MainWindow(QMainWindow): **recipient_display(config.get("recipient_name"), peer or recipient_id, config.get("recipient_name_known")), "kind": kind, "peerId": peer, "label": f"{kind} · 联系编号 {peer or recipient_id}" if recipient_id else ""}, - "preview": notification_preview(state.get("account_name") or account or "当前企微账号")} + "preview": notification_preview( + state.get("account_name") or account or "当前企微账号", + every_reply=(str(self.runtime_settings.get("send_mode") or SEND_MODE_AUTO) == SEND_MODE_REVIEW + and self._review_scope_state()["every"]))} def _refresh_review_assistant(self) -> None: available, reason = self._review_assistant_available() @@ -12351,6 +12505,22 @@ class MainWindow(QMainWindow): self.append_log("[审核提醒] " + self._review_assistant_state["message"], "ok") self._push_console_state(force=True) + def _review_scope_state(self, scope=None) -> dict: + """审核后发送的审核范围:本机选择(跟随后台/每条都审核/按原规则)、后台统一设置、实际生效。""" + from review_policy import normalize_review_scope as normalize, review_every_reply + try: + import ai_config + + admin_every = getattr(ai_config, "AI_REVIEW_EVERY_REPLY", False) is True + except Exception: + admin_every = False + local = normalize(self.runtime_settings.get("review_scope") if scope is None else scope) + return {"scope": local, "admin": admin_every, "every": review_every_reply(local, admin_every)} + + def _review_scope_fields(self, scope=None) -> dict: + state = self._review_scope_state(scope) + return {"reviewScope": state["scope"], "reviewEveryReplyAdmin": state["admin"], "reviewEveryReply": state["every"]} + def _console_automation_state(self, wecom) -> dict: settings = self.settings_page.values() connected = bool(wecom) if isinstance(wecom, bool) else bool((wecom or {}).get("connected")) @@ -12376,11 +12546,15 @@ class MainWindow(QMainWindow): "mouseProtect": bool(settings.get("mouse_idle_enabled")), # 0 = 关闭。控制台靠它决定开关的亮灭和分钟框填什么。 "draftAutosend": settings.get("foreign_draft_autosend_minutes") or 0, + # 审核后发送的审核范围:本机选择、管理后台统一设置、实际生效的结果 + **self._review_scope_fields(settings.get("review_scope")), "reply": settings.get("auto_reply_text"), "context": self.persona_page.rounds.value(), "timeout": timeout, "wecom": "已识别" if connected else "未识别", "account": account, + # 「高风险转人工」卡片按后台下发的审核规则显示,不能写死几个标签。 + "reviewRules": self._console_review_rules(), } def _console_system_state(self) -> dict: @@ -12769,6 +12943,7 @@ class MainWindow(QMainWindow): ), send_delay_seconds=float(self.runtime_settings["send_delay_seconds"]), send_mode=self.runtime_settings["send_mode"], + review_scope=self.runtime_settings.get("review_scope", "follow"), reply_transport=self.runtime_settings.get("reply_transport", VISUAL), foreign_draft_autosend_minutes=float( self.runtime_settings["foreign_draft_autosend_minutes"] diff --git a/wxwork_decrypted/1688856770803435/company.db b/wxwork_decrypted/1688856770803435/company.db index 4f4e343..918ea57 100644 Binary files a/wxwork_decrypted/1688856770803435/company.db and b/wxwork_decrypted/1688856770803435/company.db differ diff --git a/wxwork_decrypted/1688856770803435/message.db b/wxwork_decrypted/1688856770803435/message.db index cdb4500..555e1d4 100644 Binary files a/wxwork_decrypted/1688856770803435/message.db and b/wxwork_decrypted/1688856770803435/message.db differ diff --git a/wxwork_decrypted/1688856770803435/message_lookup.db b/wxwork_decrypted/1688856770803435/message_lookup.db index 62863a7..1dd2d0f 100644 Binary files a/wxwork_decrypted/1688856770803435/message_lookup.db and b/wxwork_decrypted/1688856770803435/message_lookup.db differ diff --git a/wxwork_decrypted/1688856770803435/session.db b/wxwork_decrypted/1688856770803435/session.db index d4af668..a0e2916 100644 Binary files a/wxwork_decrypted/1688856770803435/session.db and b/wxwork_decrypted/1688856770803435/session.db differ diff --git a/wxwork_decrypted/1688856770803435/user.db b/wxwork_decrypted/1688856770803435/user.db index 36a63f2..50f8bc1 100644 Binary files a/wxwork_decrypted/1688856770803435/user.db and b/wxwork_decrypted/1688856770803435/user.db differ diff --git a/wxwork_reply_cache/1688856770803435/company.db b/wxwork_reply_cache/1688856770803435/company.db index 282a909..6922edf 100644 Binary files a/wxwork_reply_cache/1688856770803435/company.db and b/wxwork_reply_cache/1688856770803435/company.db differ diff --git a/wxwork_reply_cache/1688856770803435/message.db b/wxwork_reply_cache/1688856770803435/message.db index 667dbfe..64ba990 100644 Binary files a/wxwork_reply_cache/1688856770803435/message.db and b/wxwork_reply_cache/1688856770803435/message.db differ diff --git a/wxwork_reply_cache/1688856770803435/message_lookup.db b/wxwork_reply_cache/1688856770803435/message_lookup.db index b258dc7..71273d1 100644 Binary files a/wxwork_reply_cache/1688856770803435/message_lookup.db and b/wxwork_reply_cache/1688856770803435/message_lookup.db differ diff --git a/wxwork_reply_cache/1688856770803435/session.db b/wxwork_reply_cache/1688856770803435/session.db index 2035b6a..e4db0d1 100644 Binary files a/wxwork_reply_cache/1688856770803435/session.db and b/wxwork_reply_cache/1688856770803435/session.db differ diff --git a/wxwork_reply_cache/1688856770803435/user.db b/wxwork_reply_cache/1688856770803435/user.db index cd61a5a..50f8bc1 100644 Binary files a/wxwork_reply_cache/1688856770803435/user.db and b/wxwork_reply_cache/1688856770803435/user.db differ