ai-eval-scope 0.3.2__tar.gz → 0.3.4__tar.gz

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/.gitignore

@@ -85,5 +85,8 @@ web/backend/public/
 # evaluator/agent_eval/assets/guides/（仓库规则优先级高于全局 excludesFile）
 !evaluator/agent_eval/assets/guides/
 !evaluator/agent_eval/assets/guides/*.md
+# README / 文档引用的平台截图（部分协作者 ~/.gitignore_global 含 `*.png` 全忽略）
+!docs/assets/
+!docs/assets/*.png
 *.env.local
 

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/CHANGELOG.md

@@ -1,3 +1,25 @@
+## v0.3.4 (2026-09-17)
+
+### Feat
+
+- **workbench**: 写包链路系统性修复——机械防线 + 跨进程续跑（arch/15 v4.10）
+- **workbench**: 场景包首次确认落盘即归位 + 沙盒重定向续改
+- **workbench**: 骨架驱动五阶段创建 + write_sut_config 机械物化
+- **registry**: sut_config 结构白名单校验双层卡口
+- **workbench**: 流式正文 markdown-lite 渲染 + Agent 任务清单
+
+### Fix
+
+- **workbench**: write_sut_config 接受裸文件名并机械归位 sut_configs/
+- **workbench**: 登录探测 422/事件循环/超时三根因修复 + 静态 token 注入通道
+- **cli**: auth 探测对非 JSON 响应体归一为 ProbeError，修端口被占用时裸崩
+
+## v0.3.3 (2026-09-15)
+
+### Fix
+
+- **evaluator**: 观测推送队列目录随 run workspace——容器只读 CWD 吞掉整个上传
+
 ## v0.3.2 (2026-09-15)
 
 ### Feat

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/CLAUDE.md

@@ -46,6 +46,10 @@ uv run ruff format --check agent_eval tests
 uv run pytest tests/unit -q
 ```
 
+## 场景包配置校验（强制）
+
+- **手改 `sut_configs/**` 后必跑** `uv run agent-eval scenario validate <包路径>`：sut_config 以执行器 Pydantic 模型为白名单（`extra="allow"` 会**静默丢弃**未知字段），未知键校验递归覆盖 `request_template.steps[i]` 与 `steps[i].poll`；手写幻觉字段（如 GitHub Actions 风格的 `kind`/`depends_on`/`until`）不经校验会在运行时无声消失，任务集体 run_error。`SUTRegistry.load` 装载时同源复检兜底（违例 raise `SUTChannelError`）。
+
 > 上述为快门禁（仅 `tests/unit`）。功能分支**合入前 / 发布前**跑全量 `make test`（`pytest tests/`，与 Jenkins 质量门禁同口径，含 e2e/golden 慢测试）。
 
 ## 版本发布（PyPI，distribution 名 ai-eval-scope）

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ai-eval-scope
-Version: 0.3.2
+Version: 0.3.4
 Summary: Agent 能力评估系统 — 基于 Agent-Driven 架构的评测框架
 Author: Agent Eval Team
 License-Expression: MIT

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/__init__.py

@@ -1,3 +1,3 @@
 """Agent 能力评估系统"""
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/agent/workbench/agent.py

@@ -76,6 +76,14 @@ __all__ = [
     "run_turn",
 ]
 
+# 任务清单纪律（注入 TodoListMiddleware 的 system_prompt，替代其过长默认版）：
+# 单一事实源在中间件（工具与纪律同源注入），域提示词资产不重复维护
+_TODO_SYSTEM_PROMPT = (
+    "面对多步复杂任务（约 ≥3 步或跨多文件），先用 write_todos 建任务清单再动手："
+    "每项一句话、可独立验证；保持恰好一项 in_progress；每完成一项立即把整份清单"
+    "重写更新状态；过程中发现的新子任务随时补录；简单任务（一两步）不必建清单。"
+)
+
 
 class WorkbenchAgent:
     """工作台会话 Agent（一个实例 = 一次 REPL 会话，跨轮共享历史与暂存）。
@@ -97,14 +105,20 @@ class WorkbenchAgent:
         self.config = config or WorkbenchAgentConfig()
         self.domain = domain  # 域档位：选择提示词段与门禁策略
         self.server = PackageToolServer(Path(pkg_root), ask_fn=ask_fn)
-        # SUT 接入调试工具面：与文件沙盒并列；凭证域隔离到密钥区
+        # SUT 接入调试工具面：与文件沙盒并列；凭证域隔离到密钥区。
+        # fact_sink：探测验证成功的事实由服务端机械回填进创建骨架（五阶段流程，
+        # arch/15）——事实不经 LLM 转述，「验证过了又来一遍」从源头消失
         self.probe = SUTProbeToolServer(
             ask_fn=ask_fn,
             credential_store=CredentialStore(),
             budgets=self.config.probe_budgets,
             timeout_s=self.config.probe_timeout_s,
             log_path=None,  # 探测证据随 agent_logs 统一落盘，见 _log_path
+            fact_sink=self.server.append_skeleton_fact,
         )
+        # 机械物化通道：write_sut_config 从探测账本原样注入 auth（两 server 构造
+        # 互需对方能力，probe 先带 fact_sink 装配，账本在此回绑包沙盒）
+        self.server.ledger = self.probe
         self.llm_role = llm_role
         self._messages: list[Any] = []
         # 预算护栏会话级累计（跨段/跨轮不清零）；内存检查点仅作事故现场保存器
@@ -118,6 +132,23 @@ class WorkbenchAgent:
             paths.default_workspace / "agent_sessions" / session_key(Path(pkg_root)),
             max_entries=self.config.max_dialogue_entries,
         )
+        # 进度恢复（跨进程续作，v4.10）：上次会话的暂存 + 骨架留档 + 证据账本
+        # 随会话记录持久化，重启即恢复——五阶段流程的中间进度不再「跨进程蒸发」
+        # （实测事故：代理超时后建议用户重启续作，暂存与账本实际全丢）。账本
+        # 独立于暂存恢复：已落盘包的续改会话同样免重探
+        restored = self.server.import_staging_snapshot(self._session_store.last_snapshot)
+        ledger_payload = (self._session_store.last_snapshot or {}).get("ledger")
+        restored_logins = self.probe.restore_ledgers(ledger_payload)
+        protocols = (
+            len(ledger_payload.get("verified_protocols", {}))
+            if isinstance(ledger_payload, dict)
+            else 0
+        )
+        self.restored_progress = {
+            "staged": restored,
+            "logins": restored_logins,
+            "protocols": protocols,
+        }
         self._graph: Any | None = None
         self._log_path = (
             log_dir
@@ -139,9 +170,56 @@ class WorkbenchAgent:
         """已续接的此前会话对话条数（0 = 全新会话），宿主据此显示续作提示。"""
         return len(self._session_store.dialogue)
 
+    def _progress_snapshot(self) -> dict[str, Any]:
+        """组装进度快照（暂存 + 骨架留档 + 证据账本，仅事实数据无凭证值）。"""
+        return {
+            **self.server.export_staging_snapshot(),
+            "ledger": self.probe.ledger_snapshot(),
+        }
+
     def _record_turn(self, user_text: str, reply: str) -> None:
         """记录本轮对话要点并持久化（仅 user/assistant 文本，不含工具流量）。"""
-        self._session_store.record(user_text, reply, str(self.server.root))
+        self._session_store.record(
+            user_text, reply, str(self.server.root), snapshot=self._progress_snapshot()
+        )
+
+    def relocate_root(self, final_root: Path) -> None:
+        """包归位后重绑沙盒根：server 重定向 + 提示词重建 + 会话记录迁移。
+
+        首次确认落盘即归位（v4.9）后由宿主调用——同一会话的后续轮次直接自然语言
+        修改已归位的包。图在下一次 ``_invoke`` 时重建（系统提示的 ``{pkg_root}`` 在
+        建图时烘焙；对话消息由宿主持有，重建不丢上下文）。会话记录文件迁移到新
+        session_key——归位后跨进程续作（``--output`` 指回）命中同一记录，上下文不
+        因归位断裂。文件迁移失败仅丢跨进程续作（key 仍切换，后续记录落新位），
+        会话内不受影响。
+        """
+        final = Path(final_root).resolve()
+        previous = self.server.root
+        if final == previous:
+            return
+        old_file = self._session_store.session_file
+        self.server.rebind_root(final)
+        self._graph = None  # 系统提示烘焙了 {pkg_root}——下次调用重建
+        new_file = old_file.parent / session_key(final)
+        try:
+            if old_file.exists():
+                old_file.replace(new_file)
+            skeleton = old_file.with_suffix(".SKELETON.md")
+            if skeleton.exists():
+                skeleton.replace(new_file.with_suffix(".SKELETON.md"))
+        except OSError:
+            pass  # 迁移失败仅影响跨进程续作；key 仍切换，后续记录落新位
+        self._session_store.session_file = new_file
+        self._log("relocate_root", previous=str(previous), final=str(final))
+        # 归位事实进对话（沙盒根变了，Agent 须知道以新位置为准）——同放弃回滚的
+        # 系统注记形态，防 Agent 仍引用旧草稿路径
+        self._messages.append(
+            (
+                "user",
+                f"（包已归位：沙盒根从 {previous} 迁移到 {final}，包内容不变。"
+                "此后的文件读写、校验、落盘以新位置为准）",
+            )
+        )
 
     # ─── 组装 ─────────────────────────────────────────────────────
 
@@ -179,13 +257,24 @@ class WorkbenchAgent:
                 "WorkbenchAgent 需要 deepagents（DeepAgents 底座）。请执行: uv sync --extra agent",
                 details={"missing_module": "deepagents"},
             ) from None
+        from langchain.agents.middleware import TodoListMiddleware
         from langgraph.checkpoint.memory import MemorySaver
 
         from agent_eval.agent.core.model_bridge import build_chat_model
 
         # 内存检查点无 IO、实例销毁即释放（不用文件版检查器：全量读写空转）
         self._checkpointer = MemorySaver()
-        tools = self.server.to_langchain_tools() + self.probe.to_langchain_tools()
+        # 任务清单中间件（Claude Code TodoWrite 同款语义）：复杂任务先拆解再逐步
+        # 执行；todos 走 langgraph state + 检查点，跨段续跑 / 会话续作自然保留。
+        # deepagents 默认栈不含它（其默认 system_prompt 过长，见 deepagents
+        # graph.py 注释）——此处传精简版；其注入的 write_todos 必须并入工具面
+        # 白名单，否则被下方 ToolsetFilter 复位过滤掉（按实例 id 过滤）
+        todo_mw = TodoListMiddleware(system_prompt=_TODO_SYSTEM_PROMPT)
+        tools = [
+            *self.server.to_langchain_tools(),
+            *self.probe.to_langchain_tools(),
+            *todo_mw.tools,
+        ]
         return create_deep_agent(
             model=build_chat_model(self.llm_role),
             tools=tools,
@@ -194,7 +283,7 @@ class WorkbenchAgent:
             # 复位模型可见工具面 = 宿主装配清单：deepagents 内置 ls/glob 跑
             # StateBackend 虚拟 FS（与磁盘无关），曾致「没有场景包」误判
             # （arch/15 v4.4；为何不用全局 harness profile 见 tool_filter 模块注释）
-            middleware=[build_toolset_filter(tools)],
+            middleware=[build_toolset_filter(tools), todo_mw],
         )
 
     # ─── 会话（宿主循环调用） ──────────────────────────────────────
@@ -221,6 +310,22 @@ class WorkbenchAgent:
         self.probe.new_turn()  # 重置 SUT 探测轮内预算（轮内总量约束）
         if not self._messages and self._dialogue:  # 跨进程续作：注入此前对话要点
             self._messages.extend(_resume_messages(self._dialogue, self.config))
+            # 进度恢复注记（v4.10）：暂存与证据账本已在 __init__ 恢复——Agent 须
+            # 知道进度在手上，勿从头重探/重写（实测事故：重启续作把全部进度重做）
+            prog = self.restored_progress
+            if prog["staged"] or prog["logins"] or prog["protocols"]:
+                parts = [f"暂存 {prog['staged']} 个文件"] if prog["staged"] else []
+                if prog["logins"]:
+                    parts.append(f"已验证登录 {prog['logins']} 项")
+                if prog["protocols"]:
+                    parts.append(f"已验证协议 {prog['protocols']} 项")
+                self._messages.append(
+                    (
+                        "user",
+                        f"（已恢复上次会话进度：{'、'.join(parts)}"
+                        "——这些已写内容与已验证事实均有效，无需重新探测或重写，直接继续）",
+                    )
+                )
         self._messages.append(("user", user_text))
         segment = 1
         while True:  # 自动分段续跑：同一对话/预算池/暂存，撞线开新段
@@ -338,6 +443,7 @@ class WorkbenchAgent:
             errors = [*validation["errors"], *sut_evidence_gate(self.server, self.probe)]
             if not errors:
                 files = self.server.commit()
+                self._archive_skeleton()
                 self._log("commit", files=files)
                 return {"committed": True, "files": files}
             self._log("validate_failed", round=round_no, errors=errors)
@@ -355,6 +461,22 @@ class WorkbenchAgent:
             self._messages = list(state.get("messages", self._messages))
         return {"committed": False, "errors": ["校验轮次耗尽"], "reason": "max_fix_rounds"}
 
+    def _archive_skeleton(self) -> None:
+        """创建骨架归档为审计产物（过程事实与证据链不入包，但留档可查）。
+
+        落会话记录同目录（按包根摘要命名，不与其它包撞）：包目录是源资产、会话
+        结束要归位 cwd，过程产物跟进会污染包；写失败不影响提交（同 _log 容错）。
+        """
+        text = self.server.skeleton_archive
+        if not text:
+            return
+        try:
+            dest = self._session_store.session_file.with_suffix(".SKELETON.md")
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_text(text, encoding="utf-8")
+        except OSError:
+            pass  # 归档失败不影响提交
+
     async def _invoke(
         self,
         messages: list[Any],

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/agent/workbench/memory.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import time
 from pathlib import Path
+from typing import Any
 
 from agent_eval.agent.workbench.types import WorkbenchAgentConfig
 
@@ -30,29 +31,44 @@ class SessionStore:
     def __init__(self, session_file: Path, *, max_entries: int) -> None:
         self.session_file = session_file
         self.max_entries = max_entries
+        self.last_snapshot: dict[str, Any] | None = None
         self.dialogue = self._load()
 
     def _load(self) -> list[dict[str, str]]:
+        self.last_snapshot = None
         try:
             data = json.loads(self.session_file.read_text(encoding="utf-8"))
             dialogue = data.get("dialogue", [])
+            snapshot = data.get("snapshot")
+            if isinstance(snapshot, dict):
+                self.last_snapshot = snapshot
         except (OSError, ValueError):
             return []
         return [d for d in dialogue if isinstance(d, dict) and d.get("role") and d.get("text")]
 
-    def record(self, user_text: str, reply: str, root: str) -> None:
-        """追加本轮对话要点并落盘（超出上限从头部丢弃）。"""
+    def record(
+        self, user_text: str, reply: str, root: str, *, snapshot: dict[str, Any] | None = None
+    ) -> None:
+        """追加本轮对话要点并落盘（超出上限从头部丢弃）。
+
+        ``snapshot`` 为当前进度快照（暂存 + 骨架留档 + 证据账本，调用方组装），
+        每轮整体覆写——快照即「当前进度态」而非历史，重启据此续作不丢进度。
+        """
         self.dialogue.append({"role": "user", "text": user_text})
         if reply:
             self.dialogue.append({"role": "assistant", "text": reply})
         self.dialogue = self.dialogue[-self.max_entries :]
+        if snapshot is not None:
+            self.last_snapshot = snapshot
         try:
             self.session_file.parent.mkdir(parents=True, exist_ok=True)
-            payload = {
+            payload: dict[str, Any] = {
                 "root": root,
                 "updated": time.strftime("%Y-%m-%dT%H:%M:%S"),
                 "dialogue": self.dialogue,
             }
+            if self.last_snapshot is not None:
+                payload["snapshot"] = self.last_snapshot
             self.session_file.write_text(
                 json.dumps(payload, ensure_ascii=False, indent=1), encoding="utf-8"
             )

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/agent/workbench/messages.py

@@ -113,6 +113,24 @@ def emit_tool_events(updates: dict[str, Any], emit: Callable[[dict[str, Any]], N
                 )
 
 
+def _todo_items(raw: Any) -> list[dict[str, str]]:
+    """todos 状态 → 规范化清单（dict / Todo TypedDict 兼容，缺字段补空串）。"""
+    items: list[dict[str, str]] = []
+    for todo in raw or []:
+        if isinstance(todo, dict):
+            items.append(
+                {"content": str(todo.get("content", "")), "status": str(todo.get("status", ""))}
+            )
+        else:
+            items.append(
+                {
+                    "content": str(getattr(todo, "content", "")),
+                    "status": str(getattr(todo, "status", "")),
+                }
+            )
+    return items
+
+
 async def stream_collect(
     graph: Any,
     messages: list[Any],
@@ -159,6 +177,16 @@ async def stream_collect(
                 elif block.get("type") == "thinking" and block.get("thinking"):
                     on_event({"type": "thinking", "text": str(block["thinking"])})
         elif mode == "updates" and payload:
+            # write_todos 落状态的增量（TodoListMiddleware 维护的 todos 键）——
+            # 提取成独立事件交宿主渲染任务清单；无该键（普通工具增量）不受影响
+            for delta in payload.values():
+                if isinstance(delta, dict) and "todos" in delta:
+                    on_event(
+                        {
+                            "type": "todos",
+                            "todos": _todo_items(delta.get("todos") or []),
+                        }
+                    )
             emit_tool_events(payload, on_event)
         elif mode == "values" and isinstance(payload, dict):
             final = payload

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/agent/workbench/sut_probe/context.py

@@ -12,11 +12,12 @@
 - **总量约束**：单探测 10s 超时、轮内预算按工具分池、发现阶梯路径清单 ≤10。
 
 状态全部公开名（各域工具类经 ``ctx`` 跨模块协作——下划线私有名跨模块引用是
-反模式）；唯 ``_client_instance`` 为懒建句柄私有。
+反模式）；唯 ``_client_instance``/``_client_loop`` 为懒建句柄私有。
 """
 
 from __future__ import annotations
 
+import asyncio
 import json
 import time
 from pathlib import Path
@@ -44,6 +45,7 @@ class ProbeContext:
         http_client_factory: Any = None,
         budgets: dict[str, int] | None = None,  # 轮内预算按工具分池（缺省 TOOL_BUDGETS）
         timeout_s: float = PROBE_TIMEOUT_S,
+        fact_sink: Any = None,  # (fact_line: str) -> None——验证事实机械回填骨架
     ) -> None:
         self.allowed_hosts = {h.lower() for h in (allowed_hosts or {})}
         # 拒绝拉黑账本（与 workbench_tools._ensure_grant 的 _denied 同款）：被拒
@@ -55,6 +57,9 @@ class ProbeContext:
         self.http_client_factory = http_client_factory
         self.budgets = dict(budgets) if budgets is not None else dict(TOOL_BUDGETS)
         self.timeout_s = timeout_s
+        # 验证事实机械回填骨架的出口（装配壳注入，本包不反向依赖 workbench 文件
+        # 沙盒）——探测成功的事实行由此直达 SKELETON.md，不经 LLM 转述
+        self.fact_sink = fact_sink
         self.turn_calls: dict[str, int] = {}
         # 抓取缓存（url → 完整内容）：前端包分析的存储侧，会话内跨轮有效
         # （预算按轮重置但分析状态不丢——新轮可直接检索续查）
@@ -83,8 +88,11 @@ class ProbeContext:
         # {{ stepN.路径 }} 引用其值（值服务端流动，不经对话）
         self.step_responses: dict[str, Any] = {}
         # 会话级共享 AsyncClient（与执行器 channels/base.py 同构：连接池 +
-        # cookie jar——cookie 型凭证与会话粘性靠它），会话结束 aclose()
+        # cookie jar——cookie 型凭证与会话粘性靠它），会话结束 aclose()。
+        # _client_loop 记录建实例时的事件循环：REPL 每轮 asyncio.run 换循环，
+        # client() 据此废弃绑死旧循环的实例（Event loop is closed 实测事故）
         self._client_instance: Any = None
+        self._client_loop: Any = None
 
     # ── 会话挂点与日志 ────────────────────────────────────────────
 
@@ -117,6 +125,19 @@ class ProbeContext:
         self.verified_protocols[host.lower()] = {"flavor": flavor, "steps": steps}
         self.log("protocol_probed", host=host, flavor=flavor, steps=steps)
 
+    def emit_fact(self, fact_line: str) -> None:
+        """验证成功的事实机械回填创建骨架（fact_sink 注入；失败不阻断探测结论）。
+
+        五阶段创建流程（arch/15）的「进度即回填骨架」：事实行由探测工具服务端
+        写就，落 SKELETON.md「机械实测事实」节，Agent 据此闭合对应开槽。
+        """
+        if self.fact_sink is None:
+            return
+        try:
+            self.fact_sink(fact_line)
+        except Exception:  # noqa: BLE001 — 回填失败不影响账本与工具返回（事实已登记）
+            self.log("fact_sink_error", fact=fact_line[:120])
+
     def verified_login(self, ref: str) -> dict[str, str] | None:
         """查登录实测事实（落盘对账门禁用）。"""
         return self.verified_logins.get(ref.lower())
@@ -125,6 +146,40 @@ class ProbeContext:
         """查协议矩阵事实（落盘对账门禁用）。"""
         return self.verified_protocols.get(host.lower())
 
+    # ── 证据账本跨进程续作（快照/恢复，与 record_* 对称） ─────────
+
+    def ledger_snapshot(self) -> dict[str, Any]:
+        """导出证据账本（纯事实数据，随 SessionStore 每轮持久化）。
+
+        红线：只含实测事实（url/body_template/auth_snippet 均为 credential_ref
+        占位形态）——session_tokens / credential_grants / last_credential_request
+        等凭证态绝不入快照。
+        """
+        return {
+            "verified_logins": self.verified_logins,
+            "verified_protocols": self.verified_protocols,
+        }
+
+    def restore_ledgers(self, verified_logins: Any, verified_protocols: Any) -> int:
+        """恢复账本（类型容错：非 dict 静默置空），返回恢复的登录事实条数。
+
+        会话凭证（session_tokens）不恢复——重启后重新 declare_token 才有值；
+        账本恢复的意义是 write_sut_config 免重探 + 门禁对账有事实源。
+        """
+        if isinstance(verified_logins, dict):
+            self.verified_logins = {
+                ref: fact
+                for ref, fact in verified_logins.items()
+                if isinstance(ref, str) and isinstance(fact, dict)
+            }
+        if isinstance(verified_protocols, dict):
+            self.verified_protocols = {
+                host: fact
+                for host, fact in verified_protocols.items()
+                if isinstance(host, str) and isinstance(fact, dict)
+            }
+        return len(self.verified_logins)
+
     @property
     def login_hosts(self) -> set[str]:
         """本会话登录实测成功过的接口域（小写）——协议探测的候选证据源。"""
@@ -240,22 +295,42 @@ class ProbeContext:
     # ── 会话级共享 client ────────────────────────────────────────
 
     async def client(self) -> Any:
-        """会话级共享 AsyncClient（懒建）：连接池复用 + cookie jar 跨请求保持。
+        """会话级共享 AsyncClient（懒建，绑定创建时的事件循环）。
 
         与执行器通道同构（channels/base.py）：登录态 cookie、会话粘性都靠共享
         client 的 jar——每请求新建 client 丢 cookie 的宽度裂缝在此消灭。
-        会话结束经 aclose() 释放。
+        会话结束经 aclose() 释放。WorkbenchAgent 每用户轮经 asyncio.run 新建
+        事件循环（agent.py），旧 client 的连接池绑定已关闭的循环——跨轮复用的
+        首个请求即 ``RuntimeError: Event loop is closed``（实测事故：暂停恢复/
+        新指令后的轮首必炸，偶发性取决于池中是否有存活连接）。故取用时校验
+        循环一致性：不一致即废弃旧实例换新，cookie jar 同步搬运（纯数据可跨
+        循环转移——cookie 型凭证与会话粘性跨轮不丢），旧实例交 GC 回收。
         """
-        if self._client_instance is None:
+        loop = asyncio.get_running_loop()
+        cached = self._client_instance
+        stale = cached is not None and self._client_loop is not loop
+        if stale:
+            self._client_instance = None
+        if cached is None or stale:
             if self.http_client_factory is not None:
-                self._client_instance = self.http_client_factory()
+                new_client = self.http_client_factory()
             else:
                 import httpx
 
-                self._client_instance = httpx.AsyncClient(
-                    timeout=self.timeout_s, follow_redirects=False
-                )
-        return self._client_instance
+                new_client = httpx.AsyncClient(timeout=self.timeout_s, follow_redirects=False)
+            if stale:
+                # 跨轮废弃旧实例：旧 jar 搬进新实例（cookie 型凭证与会话粘性
+                # 跨轮不丢；非 httpx 形态的测试替身无 cookies 属性，静默跳过）
+                old_jar = getattr(cached, "cookies", None)
+                if old_jar is not None:
+                    try:
+                        new_client.cookies.update(old_jar)
+                    except Exception:  # noqa: BLE001 — jar 形态不兼容时宁缺勿错
+                        pass
+            cached = new_client
+        self._client_instance = cached
+        self._client_loop = loop
+        return cached
 
     def borrow_client(self) -> Any:
         """``async with`` 形态借用共享 client（退出时不关闭——归会话统一释放）。
@@ -279,3 +354,4 @@ class ProbeContext:
             except Exception:  # noqa: BLE001 — 释放失败不阻断收尾
                 pass
             self._client_instance = None
+            self._client_loop = None

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/agent/workbench/sut_probe/protocol.py

@@ -244,6 +244,18 @@ class ProtocolTool:
                 flavor,
                 {m["step"]: m["ok"] for m in matrix if m["step"] != "skipped"},
             )
+            # 骨架机械回填：协议矩阵结论（正反都是事实——「探测过但未支持」同样是
+            # channel 决策的关闭证据）由服务端写进 SKELETON.md，不经 LLM 转述
+            verdict = (
+                f"核心端点 {core} ✅（可声明 channel: agent_protocol）"
+                if core_ok
+                else f"核心端点 {core} ❌（不支持 agent_protocol 的实测证据——改走其他"
+                "通道须先经用户确认）"
+            )
+            self.ctx.emit_fact(
+                f"事实槽：协议矩阵 {host} flavor={flavor}，{verdict}"
+                f"（证据：probe_protocol 实测 {len(matrix)} 个端点）"
+            )
         self.ctx.log("probe_protocol", base_url=base_url, steps=len(matrix))
         result: dict[str, Any] = {
             "matrix": matrix,

{ai_eval_scope-0.3.2 → ai_eval_scope-0.3.4}/agent_eval/agent/workbench/sut_probe/request.py

@@ -161,8 +161,14 @@ class RequestTool:
                 )
             }
         rendered_body = rendered_map["0"]
-        # 渲染值必须压过 req_headers 的模板原文（原文含 {{ 变量 }}，直发即泄漏）
-        rendered_headers = {k: rendered_map[str(i + 1)] for i, k in enumerate(header_names)}
+        # 渲染值必须压过 req_headers 的模板原文（原文含 {{ 变量 }}，直发即泄漏）。
+        # 模板源是整行 "Key: Value"（渲染可落在行内任意位置），回填前须再切出
+        # 值——直接整行回填会把 wire 头发成 "Key: Key: Value"（实测事故：显式
+        # Content-Type 因此从未真正生效，FastAPI 靠子串匹配侥幸解析 JSON）
+        rendered_headers: dict[str, str] = {}
+        for i, name in enumerate(header_names):
+            _, _, rendered_value = rendered_map[str(i + 1)].partition(":")
+            rendered_headers[name] = rendered_value.strip()
         cred_in_headers = any(f in h for h in raw_headers for f in cred_fields)
         if residual := _UNRENDERED_PLACEHOLDER_RE.findall(rendered_body):
             return {
@@ -176,8 +182,10 @@ class RequestTool:
         # 含 " / \ 破坏模板拼接，SUT 都只回一句 422——把我方参数变形伪装成「后端
         # 格式不明」，实测烧掉整轮探测预算（jxb-server 422 误诊事故）。与占位符
         # 守卫同哲学：凡可机械判定的变形不发给 SUT 让 Agent 瞎猜。显式非 JSON
-        # Content-Type（text/plain 等原始报文探测）不适用本校验；数组 body 合法放行
+        # Content-Type 的 JSON 对象 body 走下方机械归一化（标签修正）；原始
+        # 标量/非 JSON 报文探测不适用本校验；数组 body 合法放行
         content_type = next((v for k, v in req_headers.items() if k.lower() == "content-type"), "")
+        content_type_normalized = ""
         if rendered_body and "json" in content_type.lower():
             try:
                 parsed_body = json.loads(rendered_body)
@@ -198,6 +206,25 @@ class RequestTool:
                         "外层引号层以单层对象形态重传；body 直接传 dict 参数会机械序列化"
                     )
                 }
+        elif rendered_body and content_type:
+            # 显式非 JSON Content-Type 会同时旁路上面的 auto 补齐与双重编码门禁：
+            # 实测事故（jxb-server 422 误诊）——正确的 JSON 报文顶着 text/plain/
+            # form-urlencoded 标签上 wire，FastAPI 不做 JSON 解析，Pydantic 把
+            # body 原文当字符串校验回 422 model_attributes_type（input 回显原文
+            # 带引号，形似双重编码），LLM「换格式重试」烧光探测预算。body 实为
+            # JSON 对象/数组时机械归一化标签（凡可机械归一的变形不经 LLM 转述）；
+            # 标量/非 JSON 的原始报文探测原样放行
+            try:
+                raw_parsed = json.loads(rendered_body)
+            except ValueError:
+                raw_parsed = None
+            if isinstance(raw_parsed, (dict, list)):
+                ct_key = next(k for k in req_headers if k.lower() == "content-type")
+                req_headers[ct_key] = "application/json"
+                if ct_key in rendered_headers:
+                    rendered_headers[ct_key] = "application/json"
+                content_type_normalized = content_type
+                self.ctx.log("request", event="content_type_normalized", original=content_type)
         # 凭证注入请求的门禁面（非凭证请求只过 host 门禁）
         if cred_fields:
             if not ref.strip():
@@ -244,8 +271,17 @@ class RequestTool:
                 content=rendered_body.encode() if rendered_body else None,
             )
         except Exception as e:  # noqa: BLE001 — 网络面异常统一转错误数据
-            self.ctx.log("request", method=verb, url=url, event="failed", error=net_err(e)[:200])
-            return {"status": 0, "error": f"请求失败: {net_err(e)}"}
+            err = net_err(e)
+            if "timeout" in err.lower():
+                # 实测事故：本机代理（http_proxy→Clash）把 0.3s 的请求拖到 11.7s，
+                # 顶爆 10s 探测超时，Agent 误判「服务不可用」转向换格式瞎试。
+                # SUT 可能在内网须走用户代理，工具不擅改 trust_env——指引自查
+                err += (
+                    "（超时常见于本机代理劫持：http_proxy/https_proxy 经 Clash 等代理会"
+                    "把 10s 探测超时顶爆——为 SUT 域配置 NO_PROXY 直连或临时 unset 代理后重试）"
+                )
+            self.ctx.log("request", method=verb, url=url, event="failed", error=err[:200])
+            return {"status": 0, "error": f"请求失败: {err}"}
         elapsed_ms = round((time.monotonic() - started) * 1000)
         status = response.status_code
         # 防锁红线（认证层拒绝语义）：带凭证组合被 4xx/5xx 拒绝即入锁不自动重发；
@@ -283,7 +319,7 @@ class RequestTool:
                 },
             }
         self.ctx.log("request", method=verb, url=url, status=status, ref=ref, step=step)
-        return structure_response(
+        result = structure_response(
             self.ctx,
             verb,
             url,
@@ -293,3 +329,9 @@ class RequestTool:
             credentialed=bool(cred_fields),
             ref=ref.lower(),
         )
+        if content_type_normalized:
+            result["content_type_normalized"] = (
+                f"{content_type_normalized} → application/json（body 实为 JSON 对象，"
+                "标签已机械归一化——422 若再现与此无关）"
+            )
+        return result