From 6c2d26e6297f47614a14c8c6e0ae6784998ec3f7 Mon Sep 17 00:00:00 2001 From: Codex Date: Sat, 3 Oct 2026 07:08:38 +0800 Subject: [PATCH] Add execution-model decision handoff and Jev AALC research --- README.md | 16 +- docs/feedback_latency_profile_20261003.json | 141 +++++++++++ docs/jev_aalc_automation_research_20261003.md | 232 ++++++++++++++++++ docs/jev_page_state_example_20261003.json | 69 ++++++ scripts/analyze_feedback.py | 128 ++++++++++ scripts/decision_router.py | 132 ++++++++++ scripts/jev_mirror_agent.py | 61 +++-- scripts/run_state.py | 2 +- tests/test_controller_runtime.py | 61 ++++- tests/test_decision_router.py | 125 ++++++++++ tests/test_jev_mirror_agent.py | 18 +- 11 files changed, 958 insertions(+), 27 deletions(-) create mode 100644 docs/feedback_latency_profile_20261003.json create mode 100644 docs/jev_aalc_automation_research_20261003.md create mode 100644 docs/jev_page_state_example_20261003.json create mode 100644 scripts/analyze_feedback.py create mode 100644 scripts/decision_router.py create mode 100644 tests/test_decision_router.py diff --git a/README.md b/README.md index e322616..f670e19 100644 --- a/README.md +++ b/README.md @@ -110,7 +110,7 @@ vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\mcp_probe.py find_image '{" ## Jev 镜牢执行器与真实反馈 -`scripts/jev_mirror_agent.py` 通过 MCP bridge 操作游戏,普通分支交给 Jev;战斗采用 P → 回车宏,事件先 SKIP,回车失效时使用当前按钮。它保留用户已配好的队伍,商店无可替换出战角色时至多刷新 4 次,加载期间不读取旧库存继续操作。 +`scripts/jev_mirror_agent.py` 通过 MCP bridge 操作游戏,普通分支经统一接口交给 Jev 或执行模型;战斗采用 P → 回车宏,事件先 SKIP,回车失效时使用当前按钮。它保留用户已配好的队伍,商店无可替换出战角色时至多刷新 4 次,加载期间不读取旧库存继续操作。 安装 AALC 依赖并启动常驻服务后,把 `OPENCODE_API_KEY` 设为自己的凭据,再运行: @@ -133,6 +133,20 @@ MCP 客户端默认每次请求等待 30 秒,文字等待工具按自身时长 设置 `LC_FIXED_FALLBACK=1` 可只使用固定候选,无需 Jev API 密钥;仍需运行 MCP 服务。完整 AALC 任务启动时,如有 MCP 工具正在执行,会立即返回忙碌错误,避免与当前输入交错;查询与停止任务不受影响。 +`decisionEngine` 支持 `auto`(默认)、`jev`、`executor`、`fixed`,也可用 `--decision-engine` 覆盖。只有指定非空 `model` 并提供凭据时,`auto`/`jev` 才调用 Jev。未指定模型、缺少凭据或 Jev 请求失败时,转交执行模型;固定策略需显式选择。Python 实际使用配置中的模型,并在动作日志保留概率、confidence 和实际决策来源。 + +不用 Jev 时可以省略配置文件: + +```powershell +vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py --decision-engine executor --seconds 1800 +``` + +独立脚本在需要模型判断时输出 `requires_decision`,将页面观测、合法候选、当前局标识和请求标识写入 `decision_request.json` 及状态文件,随后释放连接与执行器互斥句柄。调用它的执行模型读取该请求,重新核对当前页面后处理动作,再用 `--resume` 继续同一局。请求文件是交接通知,旧请求不能直接用于输入。脚本本身没有访问当前聊天模型的 API。 + +嵌入执行端时,`scripts/decision_router.py` 的 `DecisionRouter` 及主脚本 `main(executor_decider=...)` 接受 `executor_decider(request)` 回调;返回候选 ID,或带同一 `request_id` 及 `choice` 的对象。回调只获得观测和候选,输入仍由执行器完成。未列出的候选、错误请求标识和无效概率会被拒绝。执行端应为自己的模型调用设置等待期限。长期混合执行器由这一接口接入当前执行模型,避免每个分支都重新启动脚本。 + +Jev 与 AALC 配置复用方案、离线页面样例及实测耗时统计见 [2026-10-03 自动化研究](docs/jev_aalc_automation_research_20261003.md)。 + 本轮修复、验证范围与已知限制见 [2026-10-03 运行可靠性改进](docs/mcp_runtime_improvements_20261003.md)。 本次修复、实际失败反馈、操作日志、截图清单、修改源码快照和速通 skill 见 [2026-10-02 实测记录](docs/feedback/2026-10-02/README.md);安装与测试说明见 [INSTALL_TEST_REPORT.md](INSTALL_TEST_REPORT.md)。这些是开发中的真实记录,包含失败和仍未验证的步骤。 diff --git a/docs/feedback_latency_profile_20261003.json b/docs/feedback_latency_profile_20261003.json new file mode 100644 index 0000000..8e0f244 --- /dev/null +++ b/docs/feedback_latency_profile_20261003.json @@ -0,0 +1,141 @@ +{ + "schema_version": 1, + "logs": [ + { + "source": "docs/feedback/2026-10-02/logs/jev_mirror_log.jsonl", + "sha256": "2763abd957bcec7cb7ad0b0b9e29ec9f1f09501f44e506f7d359047397d133e0", + "records": 273, + "action_records": 273, + "tool_counts": { + "advance_dialog": 11, + "battle": 74, + "click": 47, + "click_text": 28, + "drag": 7, + "keypress": 22, + "route": 14, + "wait": 70 + }, + "state_counts": { + "running": 273 + }, + "recorded_latency_ms": { + "jev_ms": { + "present_records": 273, + "missing_records": 0, + "invalid_records": 0, + "zero_records": 51, + "positive_records": 222, + "sum_ms": 331526, + "positive_median_ms": 1203.0, + "positive_p95_nearest_rank_ms": 2296, + "positive_max_ms": 8875 + }, + "ocr_ms": { + "present_records": 0, + "missing_records": 273, + "invalid_records": 0, + "zero_records": 0, + "positive_records": 0, + "sum_ms": null, + "positive_median_ms": null, + "positive_p95_nearest_rank_ms": null, + "positive_max_ms": null + }, + "action_ms": { + "present_records": 0, + "missing_records": 273, + "invalid_records": 0, + "zero_records": 0, + "positive_records": 0, + "sum_ms": null, + "positive_median_ms": null, + "positive_p95_nearest_rank_ms": null, + "positive_max_ms": null + } + }, + "battle_pair_attempts": { + "reported_batches": 74, + "unreported_batches": 0, + "sum": 842 + }, + "action_timestamp_spans": { + "naive_local": { + "records": 273, + "first": "2026-10-02T12:09:25", + "last": "2026-10-02T13:50:40", + "span_seconds": 6075.0 + } + }, + "missing_or_invalid_action_timestamps": 0 + }, + { + "source": "docs/feedback/mirror_20261002_181322/actions.jsonl", + "sha256": "91ddc1edce0b952df9faad3974d008d37d608f0819995d09a6c8115c326741a0", + "records": 409, + "action_records": 408, + "tool_counts": { + "advance_dialog": 35, + "battle": 51, + "click": 92, + "click_text": 28, + "keypress": 31, + "route": 27, + "wait": 144 + }, + "state_counts": { + "new_run": 1, + "running": 408 + }, + "recorded_latency_ms": { + "jev_ms": { + "present_records": 408, + "missing_records": 0, + "invalid_records": 0, + "zero_records": 408, + "positive_records": 0, + "sum_ms": 0, + "positive_median_ms": null, + "positive_p95_nearest_rank_ms": null, + "positive_max_ms": null + }, + "ocr_ms": { + "present_records": 0, + "missing_records": 408, + "invalid_records": 0, + "zero_records": 0, + "positive_records": 0, + "sum_ms": null, + "positive_median_ms": null, + "positive_p95_nearest_rank_ms": null, + "positive_max_ms": null + }, + "action_ms": { + "present_records": 0, + "missing_records": 408, + "invalid_records": 0, + "zero_records": 0, + "positive_records": 0, + "sum_ms": null, + "positive_median_ms": null, + "positive_p95_nearest_rank_ms": null, + "positive_max_ms": null + } + }, + "battle_pair_attempts": { + "reported_batches": 51, + "unreported_batches": 0, + "sum": 1080 + }, + "action_timestamp_spans": { + "naive_local": { + "records": 408, + "first": "2026-10-02T18:17:21", + "last": "2026-10-02T20:52:04", + "span_seconds": 9283.0 + } + }, + "missing_or_invalid_action_timestamps": 0 + } + ] +} diff --git a/docs/jev_aalc_automation_research_20261003.md b/docs/jev_aalc_automation_research_20261003.md new file mode 100644 index 0000000..8b8b42c --- /dev/null +++ b/docs/jev_aalc_automation_research_20261003.md @@ -0,0 +1,232 @@ +# Jev 决策与 AALC 自动化复用研究 + +研究日期:2026-10-03。分析基线:远端 lc-mcp `97eca204`、本地可靠性修复 `7188b4a`,AALC 子模块 `7452fad5`(V1.6.1-beta.3)。 + +本次交付包括代码研究、离线识别样例、可复现日志统计,以及 Jev/执行模型共用的决策预留接口。完整 AALC 混合执行器尚未接入,尚未进行新的游戏速度实测。 + +## 结论:本地识别页面,Jev 判断选择,AALC 执行流程 + +采用用户明确提出的流程:AALC 的图片匹配、地图识别及 OCR 产出页面状态,交给 Jev 判断。Jev 接收文字或结构化状态;截图留在本地用于识别和复核。 + +官方说明 Jev 不支持图片、音频和视频输入,支持字符串、JSON 对象或数组。官方也提示其中文等 CJK 输入准确率目前低于英文。因此应优先用稳定的英文枚举描述场景和节点,保留中文原文供事件判断与审计,实际准确率需要用本项目样本测量。[TypeSafe:State](https://docs.typesafe.ai/concepts/state) + +```mermaid +flowchart LR + A[MCP 启动任务和查询状态] --> B[唯一游戏执行进程] + B --> C[AALC 截图 / 模板匹配 / 局部 OCR] + C --> D[页面状态与证据] + D --> E[代码筛选合法候选] + E --> F{是否需要语义判断} + F -->|需要| G[Jev 选择候选 ID] + F -->|确定步骤| H[AALC 场景流程] + G --> H + H --> I[检查页面变化与目标结果] + I --> C +``` + +这里的自动化单位应是“进入一个节点”“处理一个商店目标”“完成一次事件判定”,让一次决策对应一段有终点的动作。确认按钮、加载等待、已知事件的后续对话、战斗输入等确定步骤可由代码推进。地图及商店需要新的信息或发生分支时再决策。 + +## 当前实现已有的能力与缺口 + +| 位置 | 已有能力 | 对此次优化的影响 | +| --- | --- | --- | +| `lc_mcp/aalc_engine.py:79–114` | AALC 截图与 OCR;返回文字、位置、OCR 分数 | 已能在本地生成文字观测。当前每次 `get_state` 都保存 PNG 并做整帧 OCR | +| `scripts/jev_mirror_agent.py:57–127` | 复用 AALC 总线、箭头、节点图片,以 OpenCV 匹配和 ORB 识别可达节点 | 已能直接产出地图候选,无需视觉模型;匹配数和亮度阈值不是校准后的正确率 | +| `scripts/jev_mirror_agent.py:130–539` | 页面文字规则、卡包限制、场景动作候选 | 部分硬约束已在代码内生效;许多信息仍藏在描述文字或手工更新的运行上下文中 | +| `scripts/jev_mirror_agent.py` 的 `decide()` | 向 Zen System One 发送 OCR 文字,接收候选 ID | 研究开始时硬编码免费模型并丢弃概率;本次已改为读取实际模型、保留概率及 confidence | +| `scripts/jev_decision_client.mjs` | 返回 choice、confidence、probabilities、model | 是独立实现,Python 主循环没有调用它;需要统一行为与配置 | +| `scripts/jev_mirror_agent.py` 的决策分支 | 原来 401/403/429 后持续规则回退 | 本次已改为执行模型交接,并记录决策来源;自动冷却恢复仍待长期执行器实现 | +| `lc_mcp/aalc_task.py` | 通过 `run_task` 启动完整 AALC 镜牢任务 | 当前镜牢参数仅覆盖次数,未提供配置预览、策略选择或决策钩子 | +| `lc_mcp/tasks.py:62–79` | 根据任务子进程退出码报告成功 | 退出码 0 只说明进程结束,不能直接代表完成镜牢及领取奖励 | + +目前 Jev 输入包含全屏 OCR、候选描述、最近动作和所有全局规则。应改成针对当前页面的状态及规则,避免将楼层、技能、卡包、商店、战斗等要求同时塞入每次选择。 + +## 离线证明:现成识别代码已经能输出可用状态 + +对 `tests/fixtures/floor4_white_events.png` 调用现有 `map_candidates()`,识别出: + +- `route_w`:上方可达事件节点,ORB 匹配数 53。 +- `route_d`:正前方可达事件节点,ORB 匹配数 30。 + +导出文件:[页面状态与 Jev 请求样例](jev_page_state_example_20261003.json)。此次只读取现有测试图片,未向 Jev 请求,也未向游戏发送输入。样例中的楼层明确标为未提取,不能因为文件名带有 floor4 就当成识别结果。 + +现成函数返回的是候选描述。下一步应让识别器直接返回 `node_type`、`reachable`、匹配分数、证据区域和动作引用,减少再次解析自然语言描述。候选坐标由执行器持有,Jev 只需要知道节点语义及合法候选 ID。 + +建议的页面状态合同如下,数值仅用于说明结构: + +```json +{ + "schema_version": 1, + "observation_id": "frame-123", + "scene": {"value": "shop", "status": "observed", "evidence": ["shop_coins_template"]}, + "floor": {"value": 3, "status": "confirmed"}, + "coins": {"value": 350, "status": "observed", "source": "shop_coin_ocr"}, + "goals": ["enhance_core_gift", "replace_allowed_skills"], + "legal_candidates": [ + {"id": "enhance_core", "kind": "enhance", "affordable": true}, + {"id": "leave_shop", "kind": "leave"} + ], + "unknown_fields": ["current_gift_upgrade_level"], + "last_action": {"id": "open_enhance", "verified_effect": false} +} +``` + +`status` 要区分本帧观测、先前确认、未知及冲突。OCR 分数、模板分数、场景识别强度、Jev 的 confidence 分别记录,不能混成一个“可信度”。空 OCR 可能是动画或加载,必须结合场景证据和前一动作判断。 + +同一帧的观测供识别与候选生成共用;输入后使旧观测失效。执行前校验 observation ID、页面关键标志和候选是否仍可用。结果没有证据时保留“待确认”,不能仅因点击 API 返回 `ok` 就把库存升级等目标标为完成。 + +## 可以复用的 AALC 配置与流程 + +配置来源为 `vendor/aalc/module/config/config_typing.py`、`assets/config/config.example.yaml`,以下映射根据实际消费配置的代码核对。 + +| 场景 | 现有配置 | 现有执行点 | 复用边界 | +| --- | --- | --- | --- | +| 任务与队伍 | `teams_active_queue`、`teams`、`fixed_team_use`、`fixed_team_use_select`、`hard_mirror` | `script_task_scheme.Mirror_task()`,`Mirror` 初始化与选队 | 复用有效队伍队列及普通/困难适用范围,启动前检查确有可执行队伍 | +| 队伍与编队 | `sinner_order`、`chosen_sinners`、`team_number`、`re_formation_each_floor` | `Mirror.select_mirror_team()`、战斗编队流程 | `sinner_order` 是各罪人的优先序,不能直接当成角色 ID 数组 | +| 开局增益与饰品 | `opening_bonus`、`opening_items`、`opening_items_select`、`opening_items_system`、`use_starlight` | `Mirror.enter_mir_with_star()`、开局饰品选择 | 优先使用已有配置;枚举索引与用户指定饰品需用资源及页面核对 | +| 地图 | `mirror_keyboard_navigation`、`mirror_keyboard_simple_pathfinding` | `MirrorMap`、`Mirror.search_road()`、`enter_next_node()` | 正常模式已有节点图及路线缓存;简单模式总选上方,不能保证更快通关 | +| 卡包 | `theme_pack_list.yaml`、每队 `theme_pack_weight_team_N.yaml`、`use_custom_theme_pack_weight` | `select_theme_pack()` | 权重是偏好,低权重仍可能在最终回退时被选中;不等价于按楼层禁选 | +| 商店购物与刷新 | `shopping_strategy`、`shopping_strategy_select`、`max_keyword_refresh`、`max_normal_refresh`、`ignore_shop` | `Shop.buy_gifts()`、`Shop.in_shop()` | 可复用商品识别及购买流程;需要与当前 MCP 的每店刷新限制统一 | +| 合成与强化 | `shop_strategy`、`do_not_fuse`、`do_not_enhance`、`aggressive_save_systems`、`second_system*` | `Shop.fuse_gift()`、`enhance_gifts()`、`ego_gift_to_power_up()` | 支持体系策略,但不是任意指定核心饰品的保护与预算规则 | +| 技能替换 | `skill_replacement`、`skill_replacement_select`、`skill_replacement_mode` | `Shop.replacement_skill()` | 原生模式按优先角色集合使用同一个替换模式,缺少每角色、每楼层规则 | +| 事件与判定 | 原生事件模板及判定识别 | `Mirror.event_handling()`、`tasks/event` | 复用判定及后续点击;选项未知时需要 Jev 判断,不能套用首项回退 | +| 奖励与结束 | `reward_cards*`、`save_rewards`、`no_weekly_bonuses` 等 | `Mirror.run()` 结算流程、`run_state.py` | 根据配置明确是否领取;正常完整运行需有实际结算与返回大厅的证据 | +| 战斗 | `defense_*` 等 | `battle.fight()` 或已验证的 P+Enter 宏 | 原生完整战斗逻辑包含不同策略,需要匹配本次运行策略后才能替换 | + +### 三个不能只靠原配置解决的要求 + +1. **按楼层严格选择卡包。** 当前 MCP 已实现前四层不选 2 号线、第五层指定 2 号线的部分候选过滤。AALC `select_theme_pack.py:111–149` 在刷新回退后仍选择最高权重,所以把禁选包权重设为 -5 不保证禁选。应保留硬过滤,再复用卡包识别、权重及拖动动作。`select_event_pack` 只是第五层选最左侧包,也不是指定包名。 +2. **按罪人及楼层替换技能。** AALC `in_shop.py:1210–1233` 选择前 1/3/7/12 个优先罪人,所有人用同一 `skill_replacement_mode`。当前规则中的奥提斯 2→3、其他角色 1→3、辛克莱从第三层开始,需额外策略表及对应执行适配。 +3. **跨体系保护核心与先后预算。** AALC 激进合成保护表及体系保护见 `in_shop.py:417–445`,普通合成还依赖舍弃体系及固定资源列表。不能假定破裂队配置会保护标准负载电池等全部指定核心。原生商店顺序为技能→治疗→出售→购买→合成→强化;“先把核心强化到目标等级并保留技能预算”需要明确动作顺序和每次付款后的验证。 + +这些确定约束应放在代码和配置里。Jev 只在通过约束的候选之间判断。 + +## 已接入的决策预留接口 + +新增 `scripts/decision_router.py`,并接入当前 `jev_mirror_agent.py`。支持四个模式: + +| 模式 | 行为 | +| --- | --- | +| `auto`(缺省) | 指定 Jev model 且有凭据时调用 Jev;否则交给执行模型 | +| `jev` | 使用明确配置的 Jev;未配置完整或调用失败时交给执行模型 | +| `executor` | 交给当前执行模型,即使配置里有 Jev 凭据也不调用 Jev | +| `fixed` | 显式使用原固定策略;保留 `LC_FIXED_FALLBACK=1` 的覆盖行为 | + +统一接口接收页面状态、合法候选、最近动作和 run ID,返回候选 ID 及决策来源。Jev 成功时保留 model、confidence、probabilities 和耗时;失败时使用执行模型回调或发布交接请求。 + +嵌入运行时的回调形式是 `executor_decider(request)`,可传给 `DecisionRouter` 或当前主脚本的 `main(executor_decider=...)`。它可返回候选 ID,或 `{"request_id": "同一个请求 ID", "choice": "合法候选 ID"}`。执行模型得到独立的观测和候选副本,不能通过修改请求来改变执行器持有的动作。未列出的候选和不匹配的请求 ID 被拒绝。凭据及 Provider 配置不在交接内容中。 + +独立脚本没有访问当前聊天模型的 API,因此通过 stdout、状态文件及 `decision_request.json` 发布 `requires_decision` 并退出当前控制循环。调用方的执行模型接收交接、重新检查页面并处理,然后 `--resume` 继续本局;这类状态已加入可续跑集合。嵌入长期执行器时由调用方提供回调,可在同一进程中连续完成选择与执行。 + +交接请求包括 run ID、request ID、观测、候选、规则和最近动作,并明确要求外部输入前重新观察。它是一次观测的决策通知,不能自动执行遗留请求文件。当前实现尚未提供从响应文件自动消费答案的命令,也尚未实现执行模型的自动调度连接。 + +### 启动前需要的配置检查 + +本地当前 checkout 没有 `vendor/aalc/config.yaml`,其他电脑实测反馈也没有提供完整运行配置。配置表依据源码和示例文件,不代表已读取另一台电脑的实际配置。 + +未来增加只读配置预览,列出有效队伍、队列、镜牢模式、开局配置、商店策略、卡包权重及与额外约束的冲突。沿用 AALC 现有队列迁移规则,不能随意重建队伍序号。 + +`Mirror_task()` 在没有适用队伍或队列为空时直接退出循环(`script_task_scheme.py:321–325`),当前任务包装仍可能以 0 退出并报告 `succeeded`。启动预检查应阻止这种空执行;运行结果应包含请求次数、实际完成次数和结算状态。 + +## Jev 接入方案 + +OpenCode 官方列出 `jev-1.13`、`jev-1.13-free` 及 `https://opencode.ai/zen/v1/systemone`,支持 `choice`、`noul`、`score` 和单请求多问题。免费别名被标为限时提供,不能把它硬编码为长期可用前提。[OpenCode:Jev](https://opencode.ai/docs/zen/#jev) + +TypeSafe 直连接口使用 `https://api.typesafe.ai/v1/systemone`。Provider、model、endpoint 和对应凭据应成套配置;不能直接把 Zen 凭据或模型别名套入另一个 Provider。[TypeSafe:API](https://docs.typesafe.ai/api) + +统一 Provider 选择已由本次 `DecisionRouter` 落地;后续完善场景输入及客户端生命周期: + +- 已读取实际 model,校验候选 ID 和响应类型;Provider endpoint 与 timeout 的完整配置仍待扩展。 +- 已保留 choice、probabilities、confidence、返回 model 和请求耗时,并记录交接原因。 +- `choice` 用于当前路线、事件选项或合法商品选择;`noul` 可判断某事件描述是否包含额外战斗;数量、预算、刷新次数和楼层比较由代码计算。 +- 同一页面上相互独立的问题可以合并成一次请求,例如事件选项分类与选项选择;需要先买入商品才能知道的新库存不能在旧状态下并行决定。[TypeSafe:多问题模式](https://docs.typesafe.ai/patterns/fan-out) +- 429 使用有上限的退避及可恢复的冷却状态;可行时读取 Retry-After。401/403 单独记录配置问题。重试失败不自动切换到付费模型。 +- 合法确定动作在回退期间可继续执行。未知选择按当前策略重新观察或暂停,不能将回退称为 Jev 已成功判断。 + +Confidence 是根据选项概率计算的统计量,不能直接当作“动作正确率”。应保存它及前两名的差距,用本项目标注样本分别校准事件、卡包和商店阈值。[TypeSafe:Confidence](https://docs.typesafe.ai/confidence) + +官方明确指出 Jev 的精确计算、复杂间接推理、无关长状态和候选顺序等局限。对应本项目应做候选预过滤、使用每场景短规则,并在离线评测中变换候选顺序检查一致性。[TypeSafe:Jev 1.13 局限](https://docs.typesafe.ai/model-jaggedness/jev-1.13) + +JSON 状态经 Zen 网关的实际兼容性仍需真实请求确认;适配层可先将精简 JSON 序列化为字符串,保留同样字段与语义。此次没有做 API 可用性或中文准确率实测。 + +## 实测日志对速度优化的约束 + +由新工具 `scripts/analyze_feedback.py` 统计,完整数据和输入 SHA-256 见 [统计结果](feedback_latency_profile_20261003.json)。 + +| 指标 | 2026-10-02 第一批日志 | mirror_20261002_181322 | +| --- | ---: | ---: | +| JSONL 记录数 | 273 | 409 | +| 动作记录数 | 273 | 408(另 1 条为 new_run) | +| 正值 `jev_ms` 记录 | 222 | 0 | +| 记录的 Jev 耗时之和 | 331.526 秒 | 0 秒 | +| 正值 Jev 中位数 / P95 | 1.203 / 2.296 秒 | 无 | +| battle 批次数 | 74 | 51 | +| 记录的 P+Enter 尝试数 | 842 | 1080 | +| wait 动作数 | 70 | 144 | +| 单独记录 `ocr_ms` / `action_ms` | 均无 | 均无 | + +第一批日志是过程快照,最终记录说明通关后由用户按 Enter 确认领取,不能作为全自动完成证据。第二轮 `run.json` 记录因 HTTP 429 回退、两次游戏重启及最终人工接管,总时长 9738.9 秒;没有记录完成镜牢或领取最终奖励。 + +正值 `jev_ms` 是日志所记录请求耗时,失败或未落盘的请求可能不在其中。P+Enter 次数是输入尝试,不是游戏接受次数或战斗回合数。动作时间戳跨度包含加载、停顿与人工处理,不能按截图或时间差推断 OCR、游戏动画和人工时间的各自占比。 + +从现有证据可以得出:降低 Jev 延迟是可测量的一部分,但无法单独解决第二轮的长时间卡住和接管。必须同时提高状态识别、关键目标完成率和无进展恢复能力。 + +### 优先验证的速度改进 + +| 改进 | 源码依据 | 测量方式 | +| --- | --- | --- | +| 模板先识别场景,再按场景做局部 OCR | 当前 `get_state` 整帧 OCR;许多页面已有 AALC 特征模板 | 同一截图集对比识别准确率与 capture/template/OCR 耗时 | +| 复用一帧观测及已核实目标坐标 | 当前 `click_text` 在 `get_state` 后又做一次 OCR(`protocol.py:151–164`) | 统计一次场景动作中的 OCR 调用数;输入后检查观测失效 | +| 一次 Jev 决策运行一段 AALC 流程 | 当前路线、事件、商店多次 MCP 往返,确定步骤也可能反复决策 | 每节点、每商店的 Jev 次数、MCP 次数、耗时与失败率 | +| 保留地图路线缓存,按需求更新节点成本 | AALC `MirrorMap` 缓存路线;图权重 event=1、shop=2、battle=4 | 选路误判率、实际战斗次数、每层耗时;不能用“总选上方”代替 | +| 以场景变化结束等待,保留有上限的重试 | AALC 商店、卡包、路线有固定等待;当前 agent 也有固定 sleep | 动画完成到下一动作的空闲时间、漏输入率及卡住时间 | +| 检测语义状态无进展并重新识别 | 旧记录存在重复战斗输入、特殊商店漏判和无响应 | 当前回合/场景关键标志等语义状态的停留时间,避免把战斗动画当无进展 | + +**不能仅调配置就宣称当前 MCP 加速。** AALC `auto.take_screenshot()` 默认按 `screenshot_interval`(0.85 秒)节流,但 MCP `_grab()` 直接调用 `ScreenShot.take_screenshot()`,不经过该节流。把配置间隔调小不会直接改变当前 `get_state` 的耗时。`mouse_action_interval` 也只覆盖相关 AALC 操作,不能替代 agent 内部固定等待。 + +当前后台按键的按下/释放持续时间是先前可靠性验证的一部分。应先减少重复观测和跨进程往返,再根据游戏接受率调整间隔,不能用按键尝试数增长作为速度改善证据。 + +## 单一执行进程与接入边界 + +当前 MCP 已在 AALC 长任务运行时阻止手动输入(`protocol.py:145–146`)。混合模式应让同一个任务进程读取配置、观察页面、请求 Jev、执行 AALC 动作并发布状态;主 MCP 负责启动、状态和停止。 + +`Mirror` 初始化时复制 TeamSetting,并持有 Shop、地图缓存与统计状态,适合在一次运行中持续复用。不能每次 Jev 选择后重新启动整套 AALC 任务,也不能让外部 agent 与正在运行的 AALC 同时操作。 + +原生 AALC 尚没有通用决策插件接口。`Mirror.run()` 直接调用模块级 `select_theme_pack()`;仅继承 `Mirror` 不能自动接管该分支。接入需要明确边界: + +1. 先在 lc-mcp 增加配置检查、统一 DecisionClient 和页面状态层。 +2. 建立一个持续的混合任务进程,持有本次 Mirror/Shop 状态。 +3. 为地图、卡包、事件、商店目标添加小范围决策钩子或适配入口;保留已有执行方法。涉及 AALC 调用点的改动需以独立、可维护的补丁管理,避免全局 monkeypatch。 +4. 对带有角色、楼层及核心预算要求的商店流程使用专门适配,不能直接调用整段 `Shop.in_shop()` 并假定其固定顺序符合额外规则。 + +## 实施顺序与验收 + +| 阶段 | 交付 | 先通过的检查 | +| --- | --- | --- | +| 1. 状态与配置 | 只读 profile 预览、队伍预检查、页面状态合同、分段计时 | 不导入有副作用的配置初始化来做静态预览;不泄漏凭据;空队列明确报错 | +| 2. Jev 决策 | 统一 Python 客户端、紧凑输入、概率保留、429 冷却恢复 | 离线响应回放覆盖未知候选、低信息、限流、超时和中止;真实连接测试单独记录 | +| 3. AALC 复用 | 单进程混合执行、地图/事件/卡包入口,再逐步接商店 | 关键目标有结果证据;候选过期停止;运行中可取消;原配置与额外约束同时遵守 | +| 4. 提速实测 | 基线与混合模式在同机、同队伍/规则/分辨率下比较多次运行 | 全自动完成及确认领取、人工接管次数、每层/每商店耗时、无进展时间、OCR/Jev/MCP 次数 | + +新增计时应至少分为 capture、template、ocr、decision、input、等待及验证;为失败的 Jev 请求另记 attempt 延迟。保存实际决策引擎、model、profile 摘要哈希、页面类型、执行目标和结果证据。此前 `ocr_ms` 实际包裹整个 `get_state` 往返,不能称为纯 OCR 内核耗时。 + +离线截图集先覆盖已知问题:紫色可达节点、特殊商店、加载中的旧库存、事件判定、卡包楼层限制、最终领取及返回大厅。用标注页面/选项评估识别和决策,随后做实机验证。没有相同条件的新实测前,不承诺具体通关分钟数。 + +## 本次可复现产物 + +- 本报告:`docs/jev_aalc_automation_research_20261003.md`。 +- 离线页面状态及请求样例:`docs/jev_page_state_example_20261003.json`。 +- 日志统计:`docs/feedback_latency_profile_20261003.json`。 +- 统计工具:`scripts/analyze_feedback.py`(标准库,只读日志,不连接游戏、MCP 或网络)。 + +在仓库根目录运行: + +```powershell +python scripts/analyze_feedback.py docs/feedback/2026-10-02/logs/jev_mirror_log.jsonl docs/feedback/mirror_20261002_181322/actions.jsonl +``` + +决策接口实现:`scripts/decision_router.py`,主脚本接入及续跑支持:`scripts/jev_mirror_agent.py`、`scripts/run_state.py`。验证覆盖 Provider 路由、无配置交接、Jev 限流/超时/无效回复、候选及请求 ID 校验、交接无输入和本局续跑。 + +本次全量离线回归:124 项全部通过,耗时 8.670 秒。执行模型回调到路线动作的闭环使用 mock MCP 验证;图片匹配使用真实测试截图离线验证。日志统计重新生成一致,缺失耗时没有被当成 0。`git diff --check` 通过。 + +本次未改变正在运行的输入方式、系统驱动或 AALC 运行配置;未发送真实 Jev 请求。完整 AALC 混合执行器、配置工具和分段识别方案仍为后续实施设计。 diff --git a/docs/jev_page_state_example_20261003.json b/docs/jev_page_state_example_20261003.json new file mode 100644 index 0000000..361097d --- /dev/null +++ b/docs/jev_page_state_example_20261003.json @@ -0,0 +1,69 @@ +{ + "schema_version": 1, + "source": { + "mode": "offline_fixture", + "fixture": "tests/fixtures/floor4_white_events.png", + "sha256": "55ecd21353493b15c2967a7f6a0de34ce6ce9e3402eac63a42a69f74234ebcc8", + "recognizer": "scripts/jev_mirror_agent.py:map_candidates", + "method": "OpenCV template matching, arrow brightness and ORB icon matching; no vision-model API" + }, + "observed_candidates": { + "route_w": { + "description": "上方有高亮可达节点:事件,图标匹配数53,中心(1059,343)。按方向键选中后直接回车进入,无需二次确认。", + "action": { + "tool": "route", + "args": { + "key": "w" + } + } + }, + "route_d": { + "description": "正前方有高亮可达节点:事件,图标匹配数30,中心(1059,680)。按方向键选中后直接回车进入,无需二次确认。", + "action": { + "tool": "route", + "args": { + "key": "d" + } + } + } + }, + "jev_request_example": { + "model": "jev-1.13-free", + "state": { + "scene": "map", + "scene_evidence": "Bus template and adjacent-node observations from the offline map fixture", + "floor": { + "value": null, + "status": "not_extracted_from_this_image" + }, + "routes": [ + { + "id": "route_w", + "observation": "上方有高亮可达节点:事件,图标匹配数53,中心(1059,343)。按方向键选中后直接回车进入,无需二次确认。" + }, + { + "id": "route_d", + "observation": "正前方有高亮可达节点:事件,图标匹配数30,中心(1059,680)。按方向键选中后直接回车进入,无需二次确认。" + } + ], + "goal": "Prefer a reachable event or shop over battle when the node type is reliably identified." + }, + "questions": { + "next_route": { + "type": "choice", + "instructions": "Choose one supplied route from the current observations. Choose reobserve if the available information is insufficient.", + "criteria": { + "route_w": "上方有高亮可达节点:事件,图标匹配数53,中心(1059,343)。按方向键选中后直接回车进入,无需二次确认。", + "route_d": "正前方有高亮可达节点:事件,图标匹配数30,中心(1059,680)。按方向键选中后直接回车进入,无需二次确认。", + "reobserve": "Refresh the local template/OCR observation if no route has a reliably identified type." + } + } + } + }, + "limitations": [ + "Offline recognition only; the example request was not sent to Jev.", + "The existing recognizer emits textual node descriptions rather than typed node fields.", + "Reachability/icon-match observations do not establish a calibrated accuracy or confidence probability.", + "The adapter must validate structured state support at the configured gateway; JSON-as-text is a compatible fallback." + ] +} diff --git a/scripts/analyze_feedback.py b/scripts/analyze_feedback.py new file mode 100644 index 0000000..a164737 --- /dev/null +++ b/scripts/analyze_feedback.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""Summarize recorded MCP actions without starting the game or importing AALC. + +Only records containing an action object contribute to action/latency statistics. +These records do not prove that the game accepted an input. Missing timings +remain missing: older logs cannot separate observation and execution. +Positive jev_ms values are recorded request latencies, not proof of a successful +decision or an exhaustive account of all API attempts. +""" +import argparse +from collections import Counter +from datetime import datetime +import hashlib +import json +import math +from pathlib import Path +import statistics + + +def latency_summary(records, field): + values = [] + invalid = 0 + for record in records: + if field not in record: + continue + value = record[field] + if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or value < 0: + invalid += 1 + continue + values.append(value) + positive = sorted(value for value in values if value > 0) + return { + 'present_records': len(values), + 'missing_records': sum(field not in record for record in records), + 'invalid_records': invalid, + 'zero_records': sum(value == 0 for value in values), + 'positive_records': len(positive), + 'sum_ms': round(sum(values), 3) if values else None, + 'positive_median_ms': statistics.median(positive) if positive else None, + 'positive_p95_nearest_rank_ms': positive[math.ceil(len(positive) * .95) - 1] if positive else None, + 'positive_max_ms': positive[-1] if positive else None, + } + + +def summarize(path): + path = Path(path) + raw = path.read_bytes() + records = [] + for line_number, line in enumerate(raw.decode('utf-8-sig').splitlines(), 1): + if not line.strip(): + continue + value = json.loads(line) + if not isinstance(value, dict): + raise ValueError(f'{path}:{line_number}: expected a JSON object') + records.append(value) + actions = [row for row in records if isinstance(row.get('action'), dict)] + tools = Counter(str(row['action'].get('tool', 'unknown')) for row in actions) + states = Counter(str(row.get('state', 'missing')) for row in records) + battle_pairs = [] + for row in actions: + if row['action'].get('tool') != 'battle': + continue + result = row.get('result') + value = result.get('pairs') if isinstance(result, dict) else None + if isinstance(value, int) and not isinstance(value, bool) and value >= 0: + battle_pairs.append(value) + # Split aware/naive timestamps rather than silently invent a timezone. + timestamp_groups = {'naive_local': [], 'aware': []} + bad_timestamps = 0 + for row in actions: + stamp = row.get('at') + if not isinstance(stamp, str): + bad_timestamps += 1 + continue + try: + parsed = datetime.fromisoformat(stamp.replace('Z', '+00:00')) + except ValueError: + bad_timestamps += 1 + continue + group = 'aware' if parsed.utcoffset() is not None else 'naive_local' + timestamp_groups[group].append(parsed) + spans = {} + for name, stamps in timestamp_groups.items(): + if not stamps: + continue + ordered = sorted(stamps) + spans[name] = { + 'records': len(ordered), + 'first': ordered[0].isoformat(), + 'last': ordered[-1].isoformat(), + 'span_seconds': (ordered[-1] - ordered[0]).total_seconds(), + } + return { + 'source': path.as_posix(), + 'sha256': hashlib.sha256(raw).hexdigest(), + 'records': len(records), + 'action_records': len(actions), + 'tool_counts': dict(sorted(tools.items())), + 'state_counts': dict(sorted(states.items())), + 'recorded_latency_ms': {field: latency_summary(actions, field) for field in ('jev_ms', 'ocr_ms', 'action_ms')}, + 'battle_pair_attempts': { + 'reported_batches': len(battle_pairs), + 'unreported_batches': tools.get('battle', 0) - len(battle_pairs), + 'sum': sum(battle_pairs) if battle_pairs else None, + }, + 'action_timestamp_spans': spans, + 'missing_or_invalid_action_timestamps': bad_timestamps, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('logs', nargs='+', type=Path, help='JSONL action logs') + parser.add_argument('--output', type=Path, help='Save the summary as JSON; otherwise print it') + args = parser.parse_args() + try: + report = {'schema_version': 1, 'logs': [summarize(path) for path in args.logs]} + except (OSError, ValueError) as error: + parser.error(str(error)) + payload = json.dumps(report, ensure_ascii=False, indent=2) + '\n' + if args.output: + args.output.write_text(payload, encoding='utf-8') + else: + print(payload, end='') + + +if __name__ == '__main__': + main() diff --git a/scripts/decision_router.py b/scripts/decision_router.py new file mode 100644 index 0000000..f5f4ec7 --- /dev/null +++ b/scripts/decision_router.py @@ -0,0 +1,132 @@ +"""Select a decision provider without giving providers control of game input. + +An embedding controller can supply executor_decider(request) for its active +model. Standalone scripts publish DecisionRequired for their caller to handle; +they cannot invoke the caller's model themselves. +""" +from dataclasses import dataclass +import json +import math +import time +import urllib.error +import uuid + + +class DecisionRequired(RuntimeError): + def __init__(self, request): + super().__init__('The execution model must choose a candidate') + self.request = request + + +@dataclass +class Decision: + choice: str + engine: str + latency_ms: int + jev_ms: int = 0 + confidence: float | None = None + probabilities: dict | None = None + model: str | None = None + fallback_reason: str | None = None + failed_jev_ms: int | None = None + + +def _answer(answer, options): + if isinstance(answer, str): + answer = {'choice': answer, 'latency_ms': 0} + elif isinstance(answer, tuple) and len(answer) == 2: + answer = {'choice': answer[0], 'latency_ms': answer[1]} + if not isinstance(answer, dict) or not isinstance(answer.get('choice'), str) or answer['choice'] not in options: + raise ValueError('Decision provider returned an unsupported candidate') + latency = answer.get('latency_ms', 0) + if isinstance(latency, bool) or not isinstance(latency, (int, float)) or not math.isfinite(latency) or latency < 0: + raise ValueError('Decision latency must be a finite non-negative number') + confidence = answer.get('confidence') + if confidence is not None and (isinstance(confidence, bool) or not isinstance(confidence, (int, float)) + or not math.isfinite(confidence) or not 0 <= confidence <= 1): + raise ValueError('Decision confidence must be between 0 and 1') + probabilities = answer.get('probabilities') + if probabilities is not None: + if not isinstance(probabilities, dict) or set(probabilities) != set(options): + raise ValueError('Decision probabilities must describe the supplied candidates') + if any(isinstance(p, bool) or not isinstance(p, (int, float)) or not math.isfinite(p) or not 0 <= p <= 1 + for p in probabilities.values()) or not math.isclose(sum(probabilities.values()), 1, abs_tol=.01): + raise ValueError('Decision probabilities must form a probability distribution') + return answer['choice'], round(latency), confidence, probabilities, answer.get('model') + + +class DecisionRouter: + def __init__(self, config, jev_decider, executor_decider=None, fixed_decider=None, + rules='', force_fixed=False): + self.config = dict(config) + self.mode = 'fixed' if force_fixed else self.config.get('decisionEngine', 'auto') + if self.mode not in ('auto', 'jev', 'executor', 'fixed'): + raise ValueError('decisionEngine must be auto, jev, executor or fixed') + self.jev_decider = jev_decider + self.executor_decider = executor_decider + self.fixed_decider = fixed_decider + self.rules = rules + + def choose(self, state, options, recent=(), run_id=None): + if not options: + raise ValueError('Decision requires at least one candidate') + if self.mode == 'fixed': + if self.fixed_decider is None: + raise ValueError('Fixed decision provider is not configured') + choice, latency, confidence, probabilities, model = _answer(self.fixed_decider(options), options) + return Decision(choice, 'fixed', latency, confidence=confidence, probabilities=probabilities, model=model) + + reason = 'configured_executor' + model = self.config.get('model') + configured_model = isinstance(model, str) and bool(model.strip()) + if self.mode in ('auto', 'jev'): + if not configured_model: + reason = 'no_jev_model' + elif not self.config.get('apiKey'): + reason = 'missing_jev_credentials' + else: + started = time.monotonic() + try: + answer = self.jev_decider(self.config, state, options, recent) + choice, latency, confidence, probabilities, returned_model = _answer(answer, options) + return Decision(choice, 'jev', latency, jev_ms=latency, confidence=confidence, + probabilities=probabilities, model=returned_model or model) + except urllib.error.HTTPError as error: + reason = 'jev_http_%d' % error.code + except (OSError, TimeoutError, ValueError) as error: + reason = 'jev_unavailable_%s' % type(error).__name__ + failed_jev_ms = round((time.monotonic() - started) * 1000) + else: + configured_model = False + request = { + 'schema_version': 1, + 'request_id': uuid.uuid4().hex, + 'run_id': run_id, + 'reason': reason, + 'requested_engine': 'executor', + 'page_state': state, + 'candidates': options, + 'rules': self.rules, + 'recent': list(recent)[-4:], + 'execution_contract': { + 'response': {'request_id': '', 'choice': ''}, + 'requires_fresh_observation_before_external_input': True, + 'note': 'The caller handles this decision. No game input is sent while handing off.', + }, + } + if self.mode in ('auto', 'jev') and configured_model and self.config.get('apiKey'): + request['failed_jev_ms'] = failed_jev_ms + # The request contains observations and candidates, never provider config + # or credentials. Detach it so the callback cannot alter executable actions. + request = json.loads(json.dumps(request, ensure_ascii=False)) + if self.executor_decider is None: + raise DecisionRequired(request) + started = time.monotonic() + expected_request_id = request['request_id'] + answer = self.executor_decider(request) + if isinstance(answer, dict) and answer.get('request_id') != expected_request_id: + raise ValueError('Execution-model response belongs to a different decision request') + choice, _, confidence, probabilities, returned_model = _answer(answer, options) + latency = round((time.monotonic() - started) * 1000) + return Decision(choice, 'executor', latency, confidence=confidence, probabilities=probabilities, + model=returned_model, fallback_reason=reason, failed_jev_ms=request.get('failed_jev_ms')) diff --git a/scripts/jev_mirror_agent.py b/scripts/jev_mirror_agent.py index 5521912..f40fa8c 100644 --- a/scripts/jev_mirror_agent.py +++ b/scripts/jev_mirror_agent.py @@ -14,6 +14,7 @@ from pathlib import Path from mcp_session import Session as Bridge, SessionCancelled, SessionTimeout from game_scenes import battle_is_terminal, battle_is_visible, death_retry_screen from run_state import prepare_run, save_json, record_claim, claim_is_current, complete_run +from decision_router import DecisionRouter, DecisionRequired REPO_ROOT = Path(__file__).resolve().parents[1] RUNTIME_HOME = Path(os.environ.get('LC_JEV_HOME', str(Path.home() / 'lc_mcp' / 'jev'))) @@ -540,7 +541,7 @@ def candidates(state, previous_battle=False, refresh_used=0): def decide(cfg, state, options, recent): - body = {'model': 'jev-1.13-free', + body = {'model': cfg['model'], 'state': '目标:按用户已配置的队伍和速通规则推进当前镜牢。当前楼层:%s\n当前游戏 OCR(坐标仅供辨识):\n' % state.get('floor', '尚未识别') + '\n'.join('%s @%d,%d' % (i['text'], i['x'], i['y']) for i in text_items(state) if not i['text'].upper().startswith('STEAM')) + @@ -572,7 +573,9 @@ def decide(cfg, state, options, recent): choice = answer.get('choice') if answer.get('type') != 'choice' or choice not in options: raise ValueError('Jev returned an unsupported candidate') - return choice, round((time.monotonic() - start) * 1000) + return {'choice': choice, 'latency_ms': round((time.monotonic() - start) * 1000), + 'confidence': answer.get('confidence'), 'probabilities': answer.get('probabilities'), + 'model': result.get('model') or cfg['model']} def fixed_fallback(options): @@ -677,9 +680,10 @@ def execute(bridge, action, deadline=None): return call(action['tool'], action.get('args')) -def main(): +def main(executor_decider=None): parser = argparse.ArgumentParser() - parser.add_argument('config') + parser.add_argument('config', nargs='?', help='Optional Jev JSON config; omit for execution-model handoff') + parser.add_argument('--decision-engine', choices=('auto', 'jev', 'executor', 'fixed')) parser.add_argument('--steps', type=int, default=250) parser.add_argument('--seconds', type=int, default=1200) mode = parser.add_mutually_exclusive_group() @@ -710,13 +714,15 @@ def main(): stable_since = time.monotonic() last_fingerprint = None unknown_since = None - decision_fallback_reason = None try: RUNTIME_HOME.mkdir(parents=True, exist_ok=True) - cfg = json.loads(Path(args.config).read_text(encoding='utf-8-sig')) + cfg = json.loads(Path(args.config).read_text(encoding='utf-8-sig')) if args.config else {} cfg['apiKey'] = os.environ.get('OPENCODE_API_KEY') or cfg.get('apiKey') - if not cfg['apiKey'] and os.environ.get('LC_FIXED_FALLBACK') != '1': - raise RuntimeError('Set OPENCODE_API_KEY or enable LC_FIXED_FALLBACK=1') + if args.decision_engine: + cfg['decisionEngine'] = args.decision_engine + router = DecisionRouter(cfg, decide, executor_decider=executor_decider, + fixed_decider=fixed_fallback, rules=SYSTEM_RULES, + force_fixed=os.environ.get('LC_FIXED_FALLBACK') == '1') if STOP_FILE.exists(): save_json(status, {'state': 'stopped', 'reason': 'stop_requested'}) return @@ -779,6 +785,7 @@ def main(): unknown_since = None # User explicitly prescribed the complete battle loop. Only scene # transitions return to Jev; combat does not require new decisions. + decision = None if any(re.search(r'CON+ECTING|LOADING', i['text'].upper()) for i in text_items(state)): choice, latency = 'wait', 0 elif len(options)==2 and time.monotonic() - unknown_since < 10: @@ -792,21 +799,35 @@ def main(): elif 'battle' in options: choice, latency = 'battle', 0 else: - if os.environ.get('LC_FIXED_FALLBACK') == '1' or decision_fallback_reason: - choice, latency = fixed_fallback(options), 0 - else: - try: - choice, latency = decide(cfg, state, options, recent) - except urllib.error.HTTPError as error: - if error.code not in (401,403,429): - raise - decision_fallback_reason='Jev HTTP %d; deterministic fallback for this session' % error.code - choice, latency=fixed_fallback(options),0 + try: + decision = router.choose(state, options, recent, run['run_id']) + choice, latency = decision.choice, decision.jev_ms + except DecisionRequired as required: + record = {'state': 'requires_decision', 'step': step, 'run_id': run['run_id'], + 'decision_engine': 'executor', 'decision_request': required.request, + 'ocr_ms': observation_ms, 'screen': state.get('screen'), + 'at': time.strftime('%Y-%m-%dT%H:%M:%S')} + if 'failed_jev_ms' in required.request: + record['failed_jev_ms'] = required.request['failed_jev_ms'] + run['status'] = 'requires_decision' + save_json(RUNTIME_HOME / 'mirror_current_run.json', run) + save_json(RUNTIME_HOME / 'decision_request.json', required.request) + save_json(status, record) + with log.open('a', encoding='utf-8') as output: + output.write(json.dumps(record, ensure_ascii=False) + '\n') + print(json.dumps(record, ensure_ascii=False), flush=True) + return action = options[choice]['action'] record = {'step': step, 'run_id': run['run_id'], 'choice': choice, 'action': action, 'jev_ms': latency, 'ocr_ms':observation_ms,'screen': state.get('screen'), 'at': time.strftime('%Y-%m-%dT%H:%M:%S')} - if decision_fallback_reason: - record['decision_fallback_reason']=decision_fallback_reason + record['decision_engine'] = decision.engine if decision else 'rules' + if decision: + record.update(decision_ms=decision.latency_ms + (decision.failed_jev_ms or 0), confidence=decision.confidence, + probabilities=decision.probabilities, model=decision.model) + if decision.failed_jev_ms is not None: + record['failed_jev_ms'] = decision.failed_jev_ms + if decision.fallback_reason: + record['decision_fallback_reason'] = decision.fallback_reason if choice == 'run_complete': complete_run(RUNTIME_HOME, run, context, state.get('screen')) record['state'] = 'completed' diff --git a/scripts/run_state.py b/scripts/run_state.py index 23b1f4f..577d9e3 100644 --- a/scripts/run_state.py +++ b/scripts/run_state.py @@ -6,7 +6,7 @@ import uuid from datetime import datetime, timezone from pathlib import Path -RESUMABLE = {'running', 'requires_analysis', 'stopped', 'user_takeover'} +RESUMABLE = {'running', 'requires_analysis', 'requires_decision', 'stopped', 'user_takeover'} def save_json(path, value): diff --git a/tests/test_controller_runtime.py b/tests/test_controller_runtime.py index ffb943e..bff6676 100644 --- a/tests/test_controller_runtime.py +++ b/tests/test_controller_runtime.py @@ -77,9 +77,9 @@ class AgentRuntimeTest(unittest.TestCase): self.kernel.CreateMutexW.return_value = 12345 self.kernel.GetLastError.return_value = 0 - def run_agent(self, bridge, extra_args=(), constructor_error=None): + def run_agent(self, bridge, extra_args=(), constructor_error=None, fixed=True, executor_decider=None): output = io.StringIO() - environment = dict(os.environ, LC_FIXED_FALLBACK='1') + environment = dict(os.environ, LC_FIXED_FALLBACK='1' if fixed else '0') environment.pop('OPENCODE_API_KEY', None) with mock.patch.object(agent, 'RUNTIME_HOME', self.home), \ mock.patch.object(agent, 'STOP_FILE', self.home / 'JEV_STOP'), \ @@ -90,8 +90,8 @@ class AgentRuntimeTest(unittest.TestCase): mock.patch.object(agent.time, 'sleep'), \ mock.patch.object(agent, 'button_enabled', return_value=False), \ contextlib.redirect_stdout(output): - agent.main() - status = json.loads((self.home / 'jev_mirror_status.json').read_text()) + agent.main(executor_decider=executor_decider) + status = json.loads((self.home / 'jev_mirror_status.json').read_text(encoding='utf-8')) return status, factory def test_old_claim_context_does_not_complete_new_run_at_lobby(self): @@ -151,6 +151,59 @@ class AgentRuntimeTest(unittest.TestCase): self.run_agent(bridge) self.assertEqual(self.kernel.CloseHandle.call_count, 1) + def test_no_jev_config_publishes_execution_model_request_without_input(self): + bridge = mock.Mock() + bridge.call.return_value = {'ok': True, 'items': [{'text': '路线', 'score': 1}]} + options = { + 'wait': {'description': 'wait', 'action': {'tool': 'wait', 'args': {'seconds': .7}}}, + 'requires_analysis': {'description': 'inspect', 'action': {'tool': 'requires_analysis', 'args': {}}}, + 'route_w': {'description': 'event above', 'action': {'tool': 'route', 'args': {'key': 'w'}}}, + } + with mock.patch.object(agent, 'candidates', return_value=options), mock.patch.object(agent, 'decide') as decide: + status, _ = self.run_agent(bridge, fixed=False) + self.assertEqual(status['state'], 'requires_decision') + self.assertEqual(status['decision_request']['reason'], 'no_jev_model') + self.assertEqual(bridge.call.call_args_list, [mock.call('get_state')]) + decide.assert_not_called() + bridge.close.assert_called_once() + self.assertEqual(self.kernel.CloseHandle.call_count, 1) + pending = json.loads((self.home / 'decision_request.json').read_text(encoding='utf-8')) + run = json.loads((self.home / 'mirror_current_run.json').read_text()) + self.assertEqual(pending['run_id'], run['run_id']) + self.assertEqual(run['status'], 'requires_decision') + + def test_pending_execution_model_decision_can_resume_same_run(self): + save_json(self.home / 'mirror_current_run.json', { + 'run_id': 'pending-run', 'start_utc': '2026-10-02T00:00:00+00:00', + 'status': 'requires_decision', 'dungeon_completed': False, 'final_reward_claimed': False}) + save_json(self.home / 'jev_shop_context.json', {'run_id': 'pending-run', 'floor': 3}) + bridge = mock.Mock() + bridge.call.return_value = {'ok': True, 'items': []} + status, _ = self.run_agent(bridge, extra_args=['--resume']) + self.assertEqual(status['state'], 'stopped') + self.assertEqual(status['run_id'], 'pending-run') + + def test_embedded_execution_model_selects_and_executes_without_jev(self): + bridge = mock.Mock() + bridge.call.return_value = {'ok': True, 'items': [{'text': '路线', 'score': 1}]} + options = { + 'wait': {'description': 'wait', 'action': {'tool': 'wait', 'args': {'seconds': .7}}}, + 'requires_analysis': {'description': 'inspect', 'action': {'tool': 'requires_analysis', 'args': {}}}, + 'route_w': {'description': 'event above', 'action': {'tool': 'route', 'args': {'key': 'w'}}}, + } + executor = mock.Mock(side_effect=lambda request: {'request_id': request['request_id'], 'choice': 'route_w'}) + with mock.patch.object(agent, 'candidates', return_value=options), mock.patch.object(agent, 'decide') as decide: + status, _ = self.run_agent(bridge, fixed=False, executor_decider=executor) + self.assertEqual(status['state'], 'stopped') + executor.assert_called_once() + decide.assert_not_called() + self.assertEqual(bridge.call.call_args_list, [mock.call('get_state'), + mock.call('keypress', {'key': 'w'}), mock.call('keypress', {'key': 'enter'}), + mock.call('keypress', {'key': 'enter'})]) + rows = [json.loads(line) for line in (self.home / 'jev_mirror_log.jsonl').read_text(encoding='utf-8').splitlines()] + self.assertEqual(rows[-1]['decision_engine'], 'executor') + self.assertEqual(rows[-1]['jev_ms'], 0) + if __name__ == '__main__': unittest.main() diff --git a/tests/test_decision_router.py b/tests/test_decision_router.py new file mode 100644 index 0000000..969d332 --- /dev/null +++ b/tests/test_decision_router.py @@ -0,0 +1,125 @@ +"""Provider routing regressions; no game or network calls.""" +import json +from pathlib import Path +import sys +import unittest +from unittest import mock +import urllib.error + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts')) +from decision_router import DecisionRequired, DecisionRouter + + +class DecisionRouterTest(unittest.TestCase): + def setUp(self): + self.options = { + 'route_up': {'description': 'Reachable event', 'action': {'tool': 'route', 'args': {'key': 'w'}}}, + 'wait': {'description': 'Observe again', 'action': {'tool': 'wait', 'args': {'seconds': .7}}}, + } + self.state = {'scene': 'map', 'items': [{'text': '事件'}]} + self.jev = mock.Mock(return_value={'choice': 'route_up', 'latency_ms': 10, + 'confidence': .8, 'probabilities': {'route_up': .9, 'wait': .1}}) + self.config = {'decisionEngine': 'jev', 'model': 'jev-test', 'apiKey': 'private-key'} + + def router(self, config=None, **kwargs): + return DecisionRouter(self.config if config is None else config, self.jev, **kwargs) + + def test_configured_jev_keeps_model_and_probabilities(self): + result = self.router().choose(self.state, self.options) + self.assertEqual((result.engine, result.choice, result.model, result.jev_ms), ('jev', 'route_up', 'jev-test', 10)) + self.assertEqual(result.confidence, .8) + self.assertEqual(result.probabilities, {'route_up': .9, 'wait': .1}) + + def test_no_model_hands_off_without_using_a_key_from_environment(self): + with self.assertRaises(DecisionRequired) as raised: + self.router({'apiKey': 'private-key'}).choose(self.state, self.options, run_id='run-1') + self.jev.assert_not_called() + request = raised.exception.request + self.assertEqual((request['reason'], request['run_id']), ('no_jev_model', 'run-1')) + self.assertEqual(request['candidates'], self.options) + self.assertNotIn('private-key', json.dumps(request)) + + def test_model_without_credentials_hands_off(self): + with self.assertRaises(DecisionRequired) as raised: + self.router({'model': 'jev-test'}).choose(self.state, self.options) + self.assertEqual(raised.exception.request['reason'], 'missing_jev_credentials') + self.jev.assert_not_called() + + def test_executor_mode_never_calls_jev_even_when_configured(self): + result = self.router(dict(self.config, decisionEngine='executor'), executor_decider=lambda request: 'wait').choose(self.state, self.options) + self.assertEqual((result.engine, result.choice, result.jev_ms), ('executor', 'wait', 0)) + self.jev.assert_not_called() + + def test_auto_uses_jev_when_model_and_key_are_both_present(self): + executor = mock.Mock() + result = self.router({'model': 'jev-test', 'apiKey': 'private-key'}, executor_decider=executor).choose(self.state, self.options) + self.assertEqual(result.engine, 'jev') + executor.assert_not_called() + + def test_callback_receives_request_and_returns_matching_id(self): + def executor(request): + self.assertEqual(request['page_state']['scene'], 'map') + self.assertNotIn('apiKey', request) + return {'request_id': request['request_id'], 'choice': 'route_up', 'model': 'active-executor'} + result = self.router({}, executor_decider=executor).choose(self.state, self.options) + self.assertEqual((result.engine, result.model), ('executor', 'active-executor')) + + def test_http_limit_hands_off_with_failed_attempt_timing(self): + self.jev.side_effect = urllib.error.HTTPError('https://example.invalid', 429, 'rate limit', {}, None) + with self.assertRaises(DecisionRequired) as raised: + self.router().choose(self.state, self.options) + request = raised.exception.request + self.assertEqual(request['reason'], 'jev_http_429') + self.assertGreaterEqual(request['failed_jev_ms'], 0) + self.assertNotIn('private-key', json.dumps(request)) + + def test_timeout_uses_available_execution_model(self): + self.jev.side_effect = TimeoutError('timed out') + result = self.router(executor_decider=lambda request: 'route_up').choose(self.state, self.options) + self.assertEqual((result.engine, result.choice), ('executor', 'route_up')) + self.assertEqual(result.fallback_reason, 'jev_unavailable_TimeoutError') + + def test_jev_unknown_candidate_hands_off_instead_of_sending_input(self): + self.jev.return_value = {'choice': 'invented_click'} + result = self.router(executor_decider=lambda request: 'wait').choose(self.state, self.options) + self.assertEqual(result.fallback_reason, 'jev_unavailable_ValueError') + + def test_executor_cannot_return_unlisted_action(self): + with self.assertRaisesRegex(ValueError, 'unsupported candidate'): + self.router({}, executor_decider=lambda request: 'invented_click').choose(self.state, self.options) + + def test_executor_response_from_another_request_is_rejected(self): + with self.assertRaisesRegex(ValueError, 'different decision request'): + self.router({}, executor_decider=lambda request: {'request_id': 'old-request', 'choice': 'wait'}).choose(self.state, self.options) + + def test_callback_cannot_change_request_id_or_executable_actions(self): + def executor(request): + request['request_id'] = 'changed' + request['candidates']['route_up']['action']['args']['key'] = 'enter' + return {'request_id': 'changed', 'choice': 'route_up'} + with self.assertRaisesRegex(ValueError, 'different decision request'): + self.router({}, executor_decider=executor).choose(self.state, self.options) + self.assertEqual(self.options['route_up']['action']['args']['key'], 'w') + + def test_forced_fixed_mode_preserves_explicit_legacy_choice(self): + result = self.router(force_fixed=True, fixed_decider=lambda options: 'wait').choose(self.state, self.options) + self.assertEqual((result.engine, result.choice), ('fixed', 'wait')) + self.jev.assert_not_called() + + def test_empty_candidates_and_invalid_mode_are_errors(self): + with self.assertRaisesRegex(ValueError, 'at least one candidate'): + self.router().choose(self.state, {}) + with self.assertRaisesRegex(ValueError, 'decisionEngine'): + self.router({'decisionEngine': 'unknown'}) + + def test_non_finite_confidence_or_invalid_probabilities_hands_off(self): + for invalid in ({'confidence': float('nan')}, {'probabilities': {'route_up': 1}}, + {'probabilities': {'route_up': .8, 'wait': .8}}): + with self.subTest(invalid=invalid): + self.jev.return_value = dict(choice='route_up', **invalid) + result = self.router(executor_decider=lambda request: 'wait').choose(self.state, self.options) + self.assertEqual(result.engine, 'executor') + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_jev_mirror_agent.py b/tests/test_jev_mirror_agent.py index 0f18799..a9c6d40 100644 --- a/tests/test_jev_mirror_agent.py +++ b/tests/test_jev_mirror_agent.py @@ -93,10 +93,26 @@ class SceneRegressionTest(unittest.TestCase): error=agent.urllib.error.HTTPError('https://example.test',429,'rate limit',{},None) with mock.patch.object(agent.urllib.request,'urlopen',side_effect=error) as request, mock.patch.object(agent.time,'sleep') as sleep: with self.assertRaises(agent.urllib.error.HTTPError): - agent.decide({'apiKey':'test'}, {'items':[]},{'wait':{'description':'wait'}},[]) + agent.decide({'apiKey':'test','model':'jev-test'}, {'items':[]},{'wait':{'description':'wait'}},[]) self.assertEqual(request.call_count,1) sleep.assert_not_called() + def test_jev_uses_configured_model_and_returns_probabilities_without_images(self): + response = mock.MagicMock() + response.__enter__.return_value = response + response.read.return_value = b'{"model":"jev-test","answers":{"action":{"type":"choice","choice":"wait","confidence":0.5,"probabilities":{"wait":0.75,"inspect":0.25}}}}' + state = {'screen': {'path': 'LOCAL_SCREENSHOT_ONLY.png'}, + 'items': [{'text': 'EVENT', 'x': 10, 'y': 20}]} + options = {'wait': {'description': 'wait'}, 'inspect': {'description': 'inspect'}} + with mock.patch.object(agent.urllib.request, 'urlopen', return_value=response) as request: + result = agent.decide({'apiKey': 'test', 'model': 'jev-test'}, state, options, []) + payload = agent.json.loads(request.call_args.args[0].data.decode('utf-8')) + self.assertEqual(payload['model'], 'jev-test') + self.assertIsInstance(payload['state'], str) + self.assertNotIn('LOCAL_SCREENSHOT_ONLY', payload['state']) + self.assertEqual(result['confidence'], .5) + self.assertEqual(result['probabilities'], {'wait': .75, 'inspect': .25}) + def test_single_extra_gift_decline_preserves_core_and_multi_cards(self): state = {'items': [{'text':t,'x':100,'y':100,'w':100,'h':40} for t in ('获得E.G.O饰品','石版字符','拒绝饰品','选择')]}