@qwen-code/arena-agent 0.0.10-dev.10 → 0.0.10-dev.12

package/.env.example

@@ -64,6 +64,16 @@ ARENA_HARNESS_MODE=arena
 # ARENA_TOOL_CHOICE=auto
 # JSON array of exact tool names hidden from the model and rejected if called.
 # ARENA_DISALLOWED_TOOLS=["bash","write_file"]
+# Agent Arena connectors through Merge MCP (unset, blank or [] disables it).
+# Enable the captured catalog in the Tool Pack; connect apps for the Registered
+# User through Merge Link. The key and user must belong to the same environment.
+# One configured Registered User is shared by all sessions of this process.
+# ARENA_CONNECTORS=["notion","google_calendar"]
+# ARENA_MERGE_ACCESS_KEY=
+# ARENA_MERGE_TOOL_PACK_ID=
+# ARENA_MERGE_REGISTERED_USER_ID=
+# ARENA_MERGE_API_BASE=https://ah-api.merge.dev
+# ARENA_CONNECTOR_TIMEOUT_MS=60000
 # ARENA_THINKING_BUDGET=81920
 # ARENA_ENABLE_THINKING=true
 # ARENA_PRESERVE_THINKING=true
@@ -150,6 +160,7 @@ ROUTIFY_API_KEY=
 # ROUTIFY_WEB_SEARCH_URL=https://routify-pub.alibaba-inc.com/protocol/compatible-mode/res/v1/llm/context
 # ROUTIFY_IMAGE_SEARCH_URL=https://routify-pub.alibaba-inc.com/protocol/brave/res/v1/images/search
 # ROUTIFY_VERTEX_BASE_URL=https://routify-pub.alibaba-inc.com/protocol/vertex/v1beta
+# ROUTIFY_OPENAI_BASE_URL=https://routify-pub.alibaba-inc.com/protocol/openai/v1
 # ARENA_WEB_SEARCH_MODEL=brave.llm-context
 # CODE_HARNESS_WEB_SEARCH_MODEL=brave.llm-context
 # Optional fetch_page/web_fetch path: Firecrawl first, then Jina Reader.
@@ -159,7 +170,7 @@ ROUTIFY_API_KEY=
 # CODE_HARNESS_WEB_FETCH_MAX_BYTES=40000
 # ARENA_IMAGE_MODEL=gemini-3.1-flash-image
 # ARENA_IMAGE_SIZE=1024*1024
-# CODE_HARNESS_IMAGE_MODEL=gemini-3.1-flash-image
+# CODE_HARNESS_IMAGE_MODEL=gpt-image-2.5-sunburst
 # CODE_HARNESS_IMAGE_SIZE=1024*1024
 # ARENA_SPEECH_MODEL=gemini-3.1-flash-tts-preview
 # ARENA_SPEECH_VOICE=Kore

package/CHANGELOG.md

@@ -12,6 +12,40 @@
 
 ## [Unreleased]
 
+## [0.0.10-dev.12] - 2026-10-15
+
+### Agent Arena
+
+- 摘要压缩接入服务端 token 用量，并支持长单轮工具任务。
+
+### Code Arena
+
+- 摘要压缩接入服务端 token 用量，支持长单轮工具任务，并在续跑时恢复已应用的摘要。
+- 固定 React 和 Full Stack 模板的完整安装依赖，避免上游新版本发布导致初始化失败，并保留已有项目的依赖锁。
+- React 与 Full Stack 的命令执行支持毫秒级 `timeout`，默认 180 秒，并拒绝空命令；React 可执行 Codex 的 `shell_command` 调用。
+
+### 通用
+
+- 压缩计数改善 SVG 等大工具输出的估算，避免重复计入已压缩内容。
+- 模型因长度限制截断时保留部分输出并报告失败，避免将未完成的任务标为成功。
+- 修复 Responses 多工具调用的事件错配，确保工具结果、文件展示和用户输入请求对应正确调用。
+
+## [0.0.10-dev.11] - 2026-10-11
+
+### Agent Arena
+
+- 新增实验性 Notion、Google Calendar 接入，使用 `ARENA_CONNECTORS` 选择应用，并通过 `ARENA_MERGE_*` 配置已授权的 Merge 账号。
+- Headless Hook 新增 `before_compaction` 事件，可按压缩次数在摘要式或 rolling session memory 压缩前快照暂停，续跑时延续计数。
+
+### Code Arena
+
+- `generate_image` 默认模型改为 `gpt-image-2.5-sunburst`，继续通过 ModelRouter 调用。
+
+### 通用
+
+- 修复 Claude Haiku 5.5 开启 thinking 时因旧参数格式报 400 的问题。
+- 修复 Gemini 通过 Chat Completions 调用工具后因签名丢失而无法继续的问题。
+
 ## [0.0.10-dev.10] - 2026-10-07
 
 ### Agent Arena
@@ -214,7 +248,9 @@
 - `bash` 用于一次性命令，区分超时与信号终止，并清理遗留后台进程；需要持续运行
   的任务改用进程工具。预览端口支持 E2B Host 探测及按需返回告警。
 
-[Unreleased]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.10...master
+[Unreleased]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.12...master
+[0.0.10-dev.12]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.11...v0.0.10-dev.12
+[0.0.10-dev.11]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.10...v0.0.10-dev.11
 [0.0.10-dev.10]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.9...v0.0.10-dev.10
 [0.0.10-dev.9]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.8...v0.0.10-dev.9
 [0.0.10-dev.8]: https://gitlab.alibaba-inc.com/know-how/arena-harness/-/compare/v0.0.10-dev.7...v0.0.10-dev.8

package/README.md

@@ -3,14 +3,17 @@
 版本变化见 [Changelog](CHANGELOG.md)，发布前请按[发版流程](docs/MODES_AND_RELEASES.md#发布节奏)
 更新变更记录并运行 `npm run check:changelog`。
 
-这是一个基于 `message.json` 与 `tools.json` 所定义消息和工具契约的 TypeScript
+这是一个基于各模式正式提示词与工具契约的 TypeScript
 CodeAgent harness。运行时只依赖 Node.js，不再依赖 Python：
 
 - `arena -p ...` / `arena --file prompt.txt`：headless 单轮入口，支持文本、完整 JSON 和 NDJSON 流。
 - `arena tui`：终端多轮对话，实时输出并自动保存、恢复历史。
 - `arena serve`：HTTP daemon、Web UI 与双通道 SSE 实时接口。
 - Agent loop：流式 assistant → tool call → tool result → assistant。
-- 15 个工具按照 `tools.json` 中的 Draft-07 schema 提供参数校验。
+- Agent Arena 的 15 个工具按照 `spec/tools.json` 中的 Draft-07 schema 提供参数校验；Code Arena 使用各模式的工具契约。
+
+查看代码或修改配置前，可先看[源码入口与历史资料](docs/MODES_AND_RELEASES.md#源码入口与历史资料)，
+其中区分了当前提示词、生成文件、测试样本和历史审计脚本。
 
 本文提及的第三方产品、模型与服务名称仅用于说明兼容性和配置方式，不表示相关
 权利人对本项目的认可或背书；相关商标归各自权利人所有。使用者应自行确认并遵守
@@ -111,7 +114,8 @@ code-harness --file prompt.txt --mode react
 ### 中途快照与单步执行
 
 Headless CLI 可通过 JavaScript Hook 决定何时继续或创建 Harbor 快照。工具校验在
-整批工具执行前触发；输出重复在主模型生成正文或 reasoning 时触发。
+整批工具执行前触发；输出重复在主模型生成正文或 reasoning 时触发；Agent Arena
+的压缩事件在达到阈值且存在可压缩历史时、执行压缩前触发。
 
 | 类型 | 含义 |
 | --- | --- |
@@ -120,12 +124,13 @@ Headless CLI 可通过 JavaScript Hook 决定何时继续或创建 Harbor 快照
 | `invalid_json` | 工具参数不是合法 JSON |
 | `invalid_arguments` | 参数不符合工具 schema |
 | `repetitive_output` | 模型持续重复同一字符或片段 |
+| `before_compaction` | Agent Arena 即将执行摘要式或 rolling session memory 压缩 |
 
 | Hook 返回值 | 后续行为 |
 | --- | --- |
 | `continue` 或 `false` | 正常继续 |
-| `snapshot_continue` 或 `true` | 快照后继续当前生成与工具执行 |
-| `snapshot_exit` | 停止当前生成，保存快照后退出，本批工具不执行 |
+| `snapshot_continue` 或 `true` | 快照后继续当前生成、工具执行或压缩 |
+| `snapshot_exit` | 保存快照后暂停退出；触发处的生成、工具批次或压缩不再继续 |
 
 例如，将以下内容保存为 `policy.mjs`：
 
@@ -145,14 +150,34 @@ export HARBOR_REMOTE_COMMAND_BASE_URL="http://<harbor-host>:<port>"
 export HARBOR_REMOTE_COMMAND_API_KEY="<api-key>"
 ```
 
+要在第 `k` 次压缩执行前停止，可将 `policy.mjs` 写成：
+
+```js
+const k = 3; // 正整数；1 表示第一次压缩前停止
+export default event =>
+  event.type === "before_compaction" && event.compaction.count >= k
+    ? "snapshot_exit"
+    : "continue";
+```
+
+两种压缩模式共用 `event.compaction.count`：历史中已完成且未撤销的压缩次数 + 1，
+因此第 `k` 次暂停时只完成了 `k - 1` 次压缩。续跑或切换 `ARENA_COMPACTION_MODE`
+会从历史恢复计数；后台记忆更新、失败的压缩和已撤销的记录不增加次数。
+事件还提供 `compaction.mode`（`summary` / `rolling`）、`source`（`outer` / `inner`）、
+`estimatedTokensBefore` 和 `thresholdTokens`，以及空的 `toolCalls` 数组。
+暂停不会发起本次摘要或强制记忆更新，也不会应用已缓存的记忆；在途后台更新会收束后再快照。
+结果为 `status: "paused"`、`stop_reason: "checkpoint"`，CLI 退出码为 0。
+续跑前需提高 `k` 或调整 Hook，否则会在同一次压缩前再次暂停。
+
 配置 Hook 后自动检测输出重复，命中时由 Hook 决定继续、快照或退出；未配置 Hook
 时按默认流程执行。检测连续重复至少 512 个 Unicode 字符、至少 4 次的片段，
 片段最长 1024 字符，忽略纯空白和标点填充。
 正文与 reasoning 分开检测，工具参数和工具结果不参与；每次生成最多触发一次重复事件。
 事件的 `repetition.channel` 和 `repetition.sample` 提供通道与最多 256 字符的诊断片段。
 
-快照保存当前回复生成前的 `history.json`。恢复快照对应环境后，使用原 session ID
-续跑同一个 user turn，不追加用户消息；被中止的那一步会重新生成：
+快照保存触发点之前的 `history.json`；压缩事件保留完整的压缩前历史。
+恢复快照对应环境后，使用原 session ID 续跑同一个 user turn，不追加用户消息；
+被中止的生成或压缩会重新执行：
 
 ```bash
 arena --continue --session-id demo
@@ -291,7 +316,7 @@ claude-code-proxy），收到 401 后会自动切换鉴权方式并记住。流
 Anthropic 直连在原生协议上完整支持 thinking。旧版 Claude 和非 Claude
 兼容网关把 `ARENA_ENABLE_THINKING` / `ARENA_THINKING_BUDGET` 映射为
 `thinking.type=enabled` / `thinking.budget_tokens`；Claude Opus/Sonnet 4.6+
-以及 Claude 5、Fable、Mythos 使用 `thinking.type=adaptive`，不再发送固定
+以及 Haiku 5.5+、Fable、Mythos 使用 `thinking.type=adaptive`，不再发送固定
 budget。Anthropic 要求启用 thinking 时不调整 temperature，此时不发送该
 参数。带签名的 thinking/redacted_thinking block 会原样保存在对应 assistant
 消息的 `reasoning_details` 字段——
@@ -339,6 +364,46 @@ ARENA_DISALLOWED_TOOLS=["bash","write_file"]
 
 被禁用的工具不会发送给模型；即使模型仍构造了该工具调用，执行层也会
 在产生副作用前拒绝。
+
+Agent Arena 可通过 Merge MCP 调用 Notion 和 Google Calendar，应用范围由
+`ARENA_CONNECTORS` JSON 数组控制。先在 Merge 创建 Tool Pack 和 Registered User，
+让该用户通过 Merge Link 连接目标应用，再配置同一环境的 Access Key：
+
+```sh
+# 写入本地 .env；三个 Merge 值从自己的 Merge 环境取得。
+ARENA_CONNECTORS='["notion","google_calendar"]'
+ARENA_MERGE_ACCESS_KEY=...
+ARENA_MERGE_TOOL_PACK_ID=...
+ARENA_MERGE_REGISTERED_USER_ID=...
+```
+
+首次可运行 `arena -p '加载 Google Calendar 工具并读取我的时区，不要修改日历'`。
+Tool Pack 需启用所选应用的完整捕获目录：Notion 22 个、Calendar 42 个，见
+[目录源文件](spec/connectors/catalog.json)。缺少工具时会明确报错；上游新增的工具不会自动暴露给模型。
+
+未设置、空字符串或 `[]` 时，提示词和工具集合保持原样。非空时在基础工具后注册
+`list_connector_tools`，并在普通／Repo 系统提示词末尾加入捕获的 `Connected apps`
+段落，列出数组中的应用。目前只接受 `notion`、`google_calendar`；重复项去重，
+保留输入顺序，未知名称或非法 JSON 会在启动时报错。Code Arena 忽略此配置。
+
+模型调用 `list_connector_tools` 后，harness 才连接 Merge、加载该应用的参数定义，
+并注册业务工具。每条新用户消息都需要重新发现；暂停续跑只恢复目录，不重放已经执行的操作。
+数组表示本次会话允许哪些应用，加载目录成功也不保证账号具有全部读写权限。
+缺少配置、授权失败或目录不完整时返回明确错误；业务调用按历史日志包装结果。
+`ARENA_DISALLOWED_TOOLS` 禁用发现工具时也会省略应用提示词；显式 `--system-prompt`
+仍然完整覆盖系统提示词。
+
+默认连接 `https://ah-api.merge.dev`，可用 `ARENA_MERGE_API_BASE` 配置区域地址；
+`ARENA_CONNECTOR_TIMEOUT_MS` 默认 60000。超时或取消不会自动重试写操作，但远端可能
+已经完成写入，需先查询确认。当前一个进程使用一个 Registered User，Web 会话共用该账号；
+尚未提供各 Web 用户独立登录和账号绑定界面。
+
+可选应用提示词的唯一维护源是 `spec/connectors/system-prompt.txt`，由构建脚本嵌入
+生成数据；关闭 connector 时继续使用 `spec/message.json` 的原始提示词。
+工具名称、描述和顺序来自日志；完整参数使用 Merge 实时 schema，发现入口仍是根据
+`service` 参数实现的最小结构。已通过 40 次历史调用的本地回放比对，尚未用真实账号验证。
+配置步骤、已验证范围和剩余差异见 [Connector 接入分析](docs/research/AGENT_ARENA_CONNECTOR_BACKEND.md)。
+
 `ARENA_EXTRA_BODY` 会在配置加载时解析为 JSON 对象，既作为最后一层请求
 参数覆盖，也会原样写入 `history.json` 的
 `metadata.parameters.extra_body`。
@@ -357,21 +422,24 @@ Agent Arena 通过 `ARENA_COMPACTION_MODE` 选择压缩方式，默认 `rolling`
 ARENA_COMPACTION_MODE=summary arena -p "继续任务" --session-id demo
 ```
 
-`summary` 达到阈值时同步生成完整摘要，保留当前用户回合及其工具调用，不启动或恢复
-后台记忆缓存。它复用 `src/legacy-compaction.ts` 中的原实现：在引入 rolling 的
-提交 `c56456e9` 中，这份代码由旧 `src/compaction.ts` 完整保留；原 Agent Arena
-与当前 Code Arena 使用相同的摘要系统提示词、请求提示词和 continuation preamble。
+`summary` 达到阈值时同步生成完整摘要，优先保留当前用户回合，不启动或恢复
+后台记忆缓存。当前实现位于 `src/summary-compaction.ts`，与 Code Arena 共用
+摘要系统提示词、请求提示词和 continuation preamble。
 摘要按 `Goal`、`Instructions`、`Discoveries`、`Accomplished` 等章节生成，使用
 主模型、temperature=0、关闭 thinking，默认输出上限为 8192。
 `ARENA_COMPACTION_SUMMARY_MAX_TOKENS` 可覆盖上限；`rolling` 的默认上限仍为 131072。
 两种模式默认阈值均为 250k；只有窗口和比例两个环境变量都配置有效时才使用乘积。
-摘要模式沿用旧的
-本地 token 估算。旧实现只归档当前用户回合之前的内容，因此单个长用户回合没有
-可归档前缀时不会强制裁切。Code Arena 保持摘要式压缩，不受此环境变量影响。
-
-Agent Arena 在两种模式下都保存已应用的 `compaction` 历史记录；resume 或切换模式
-后继续使用这些记录，不丢失已压缩内容。历史 metadata 记录本次压缩方式，但下一次
-运行仍以当前环境变量为准，未设置时回到 `rolling`。
+两种模式及 Code Arena 都优先使用最近一次主请求的服务端 usage，仅估算此后新增的内容。
+大段文本取字符估算与带 10% 余量的 `o200k_base` 分词估算的较大值，减少 SVG 等
+密集文本的低估；本地分词不保证与所选模型完全一致。长用户回合没有更早回合可归档，
+或当前回合本身达到阈值时，摘要模式也可归档回合内较早的步骤，保留最近完整步骤的
+工具调用、全部结果及图片；Code Arena 的摘要压缩也支持此行为。
+Code Arena 始终使用摘要模式，阈值仍为窗口与比例的乘积，默认比例 70%。
+
+Agent Arena 两种模式和 Code Arena 都保存已应用的 `compaction` 历史记录，续跑时恢复
+压缩后的上下文。原始历史保留服务端 usage，但已压缩上下文中的旧 usage 不再作为计数基线。
+Agent Arena 历史 metadata 记录本次压缩方式；下一次运行仍以当前环境变量为准，
+未设置时回到 `rolling`，切换模式也会恢复已应用的压缩记录。
 
 以下后台记忆机制适用于 `rolling` 模式。
 
@@ -434,7 +502,9 @@ Agent Arena 记忆更新使用主模型、temperature=1、thinking
 
 `ARENA_CONTEXT_WINDOW` 应设置为所用模型的真实上下文窗口；默认 `1000000` 是
 当前默认模型的暂定值。Agent Arena 的 usage 基线来自 provider；最近 assistant
-之后的新增上下文以及缺少 usage 时的完整上下文仍使用本地保守估算。如果摘要请求失败，Harness 会保留原历史并继续正常模型请求，避免
+之后的新增上下文以及缺少 usage 时的完整上下文仍使用本地保守估算。压缩后，保留消息
+中的旧 usage 仅用于原始历史的用量统计；下一次主请求完成后重新建立计数基线。
+如果摘要请求失败，Harness 会保留原历史并继续正常模型请求，避免
 摘要服务的瞬时故障直接中断任务。
 
 Responses 与其他协议一样，会在每个工具 step 前检查是否需要压缩。由于所有
@@ -935,7 +1005,10 @@ curl -N -X POST \
 
 构建时会将两份规范生成为 `dist` 内的 JS 数据模块；npm 包不包含原始
 `spec/` 目录，运行时也不依赖仓库文件。执行工具前仍使用 AJV 校验原始
-Draft-07 schema。repo mode 的动态提示词模板保存在 `src/prompts.ts`：
+Draft-07 schema。普通模式的审计模板也从同一份生成数据取得；`src/prompts.ts`
+中直接维护的正文用于 Repo 模式。
+
+Agent Arena 提供以下工具：
 
 `bash`、`ask_user`、`add_voice`、`edit_file`、`read_file`、`fetch_page`、
 `web_search`、`write_file`、`image_search`、`present_file`、`stop_process`、
@@ -944,8 +1017,10 @@ Draft-07 schema。repo mode 的动态提示词模板保存在 `src/prompts.ts`
 新版生产导出的前 50 条脱敏请求单独保存在
 [`tasks/v2`](tasks/v2/README.md)，没有与原有 replay 数据混放。该目录记录了
 2 GB 源文件的 SHA-256、全量解析统计、tool schema 变体和可重复执行的拆分命令；
-`npm run refresh:arena-v2-contract` 用它刷新 canonical prompt/tool fixtures 并重新
-生成 `src/canonical-data.ts`。
+每条历史样本在 `request.messages` 中保留当时的系统提示词，不另存一份提示词 TXT。
+`npm run refresh:arena-v2-contract` 是从这批旧数据重新导入契约的历史维护命令，
+会用首条样本覆盖 `spec/message.json` 并重新生成派生数据；它不用于日常构建或
+获取最新官方提示词。
 
 `bash` 只用于一次性命令：超时结果为 `status=timeout`，被信号终止为
 `status=killed`，并会清理命令遗留的后台进程。需要跨 tool call 存活的 server、
@@ -984,9 +1059,10 @@ Arena 的 `fetch_page` 和 Code Arena 的 `web_fetch` 默认仍使用本地抓
 `ROUTIFY_API_KEY`。
 
 `generate_image`、`generate_speech` 使用 ModelRouter/Routify，并从工作区
-`.env` 读取同一个 `ROUTIFY_API_KEY`。图片使用 Google 兼容协议调用；可用
-`ROUTIFY_VERTEX_BASE_URL` 覆盖默认根地址。语音默认也通过该 Google 协议
-调用 Gemini TTS，不需要新增服务密钥。
+`.env` 读取同一个 `ROUTIFY_API_KEY`。GPT Image 图片生成与编辑使用 OpenAI 图片
+协议，可用 `ROUTIFY_OPENAI_BASE_URL` 覆盖 ModelRouter 根地址。显式选择 Gemini
+图片模型及默认 Gemini TTS 时使用 Google 协议，可用 `ROUTIFY_VERTEX_BASE_URL`
+覆盖对应根地址，不需要新增服务密钥。
 
 `fetch_page` 使用 Defuddle 将 HTML 正文转换为 Markdown，并使用
 `pdf-parse` 提取 PDF 的前 30 页。响应按 Markdown 边界稳定分块，同一轮内
@@ -1001,8 +1077,10 @@ XLSX 仍可提取文字和表格内容，旧版 DOC、PPT、XLS 会先通过 Lib
 内容继续发送给模型。所有工具结果另有 1,000,000 字符的最终兜底。当前不做
 OCR，扫描版 PDF 只会返回无可提取文字的提示。
 
-图片和语音的默认 ModelRouter 路由分别为 `gemini-3.1-flash-image` 和
-`gemini-3.1-flash-tts-preview`，可用 `ARENA_IMAGE_MODEL`、`ARENA_SPEECH_MODEL` 覆盖。图片生成结果和
+Agent Arena 图片和语音的默认 ModelRouter 路由分别为 `gemini-3.1-flash-image` 和
+`gemini-3.1-flash-tts-preview`，可用 `ARENA_IMAGE_MODEL`、`ARENA_SPEECH_MODEL` 覆盖。
+Code Arena 图片默认使用 `gpt-image-2.5-sunburst`；配置时优先使用
+`CODE_HARNESS_IMAGE_MODEL`，其次使用显式设置的 `ARENA_IMAGE_MODEL`。图片生成结果和
 搜索到的图片会立即下载到工作区；每次图片搜索的结果按生产命名保存为
 `image-search/<query slug>-<序号>.<扩展名>`，并作为可预览文件显示在 Web UI。
 语音生成先由 `add_voice` 生成两个试听候选并让用户选择，选择结果注册为稳定的

package/dist/agent.d.ts

@@ -16,7 +16,7 @@ interface AgentOptions {
     clientContext?: ClientContext;
     workspaceContext?: WorkspaceContext;
     onCheckpoint?: (messages: readonly Message[], tools: readonly ToolDefinition[], sessionMemory?: StoredSessionMemory | null) => Promise<void>;
-    /** Inspect output repetition and complete tool-call batches before recording them. */
+    /** Inspect repetition, tool-call batches and pending Agent Arena compactions. */
     midturnCheckpointHook?: MidturnCheckpointHook;
     /** Materialize the current history and create the external snapshot. */
     onMidturnCheckpoint?: (messages: readonly Message[], tools: readonly ToolDefinition[], event: MidturnCheckpointHookEvent, action: Exclude<CheckpointAction, "continue">) => Promise<void>;

package/dist/agent.js

@@ -389,6 +389,7 @@ export class Agent {
             return await this.runTurn(prompt, history, runOptions);
         }
         finally {
+            await this.tools.closeConnectors?.();
             await settleSessionMemory(this.memoryCache);
             await this.checkpointQueue;
         }
@@ -412,9 +413,11 @@ export class Agent {
         // carrying the old runtime configuration into the next request.
         const dialogue = withoutLeadingSystemMessage(history || []).map((message) => normalizeToolCallHistory(message, this.config.mode));
         const trajectory = completeInterruptedToolCalls(this.options.reuseHistoryMessages ? [...dialogue] : structuredClone(dialogue));
+        const connectors = this.config.disallowedTools?.includes("list_connector_tools")
+            ? undefined : this.config.connectors;
         const runtimeSystemMessage = repoContext
-            ? repoSystemMessage(clientContext, repoContext, this.config.mode, this.workspaceContext, this.config.maxTurns)
-            : systemMessage(clientContext, this.workspaceContext, this.config.mode, this.config.maxTurns);
+            ? repoSystemMessage(clientContext, repoContext, this.config.mode, this.workspaceContext, this.config.maxTurns, connectors)
+            : systemMessage(clientContext, this.workspaceContext, this.config.mode, this.config.maxTurns, connectors);
         applySystemPromptConfig(runtimeSystemMessage, this.config);
         if (runOptions.resumeFromHistory) {
             if (!isContinuableHistory(dialogue)) {
@@ -424,6 +427,9 @@ export class Agent {
         else {
             trajectory.push(userMessage);
         }
+        // A new human reply requires discovery again. Same-turn continuation only
+        // reloads schemas from paired discovery results; it never repeats writes.
+        await this.tools.beginConnectorTurn?.(runOptions.resumeFromHistory ? dialogue : undefined);
         // Compaction projects model input with a runtime system prefix; the lossless
         // trajectory and its checkpoints remain in the official dialogue format.
         const messages = modelContextFromTrajectory([runtimeSystemMessage, ...trajectory]);
@@ -466,9 +472,11 @@ export class Agent {
             this.sink.message(this.sessionId, recorded, trajectory);
             await this.checkpoint(trajectory);
         };
-        await this.maybeCompact(messages, trajectory);
-        this.sink.start(this.sessionId, trajectory);
         try {
+            const compaction = await this.maybeCompact(messages, trajectory);
+            this.sink.start(this.sessionId, trajectory);
+            if (compaction === "checkpoint")
+                return await this.pause(trajectory, "checkpoint");
             await this.checkpoint(trajectory);
             const maxTurns = this.config.maxTurns
                 ? Math.max(1, Math.floor(this.config.maxTurns))
@@ -483,13 +491,15 @@ export class Agent {
                 // Every transport is replayable from local history. Native Responses
                 // stores its encrypted reasoning output items there, so compaction is
                 // safe at the same tool-step boundaries as the other protocols.
-                if (step > 1)
-                    await this.maybeCompact(messages, trajectory, "inner");
+                if (step > 1 && await this.maybeCompact(messages, trajectory, "inner") === "checkpoint") {
+                    return await this.pause(trajectory, "checkpoint");
+                }
                 const offeredTools = this.tools.availableTools();
                 this.sink.modelStart(this.sessionId, step, offeredTools.map((tool) => tool.function.name));
                 let assistant;
+                let finishReason;
                 try {
-                    assistant = await this.assistantTurn(messages, offeredTools, trajectory);
+                    ({ assistant, finishReason } = await this.assistantTurn(messages, offeredTools, trajectory));
                 }
                 catch (error) {
                     if (error instanceof CheckpointExit) {
@@ -509,8 +519,14 @@ export class Agent {
                     this.options.onModelFailure?.(trajectory, error);
                     throw error;
                 }
-                const finishReason = assistant.tool_calls?.length ? "tool_calls" : "stop";
                 this.sink.modelComplete(this.sessionId, step, finishReason, assistant.usage);
+                if (finishReason === "length") {
+                    // A completed but truncated request is not a transport failure. Keep
+                    // its evidence without retrying it or executing unfinished tool calls.
+                    await recordMessage(assistant);
+                    throw new Error("Model response was truncated (finish_reason=length). " +
+                        "The turn did not complete; any partial output has been preserved.");
+                }
                 if (assistant.tool_calls?.length &&
                     this.options.midturnCheckpointHook) {
                     const event = {
@@ -609,7 +625,7 @@ export class Agent {
         return this.sink.result(this.sessionId, status, messages, error, undefined, this.memoryCache.update);
     }
     async makeCheckpoint(messages, tools, event, action) {
-        await settleSessionMemory(this.memoryCache);
+        await settleSessionMemory(this.memoryCache, event.type !== "before_compaction" || action !== "snapshot_continue");
         await this.checkpoint(messages);
         if (!this.options.onMidturnCheckpoint) {
             throw new Error("mid-turn checkpoint hook triggered without a snapshot handler");
@@ -636,6 +652,30 @@ export class Agent {
                 compactionThresholdTokens: isCodeArenaMode(this.config.mode) ? undefined
                     : this.options.compactionThresholdTokens ?? this.config.compactionThresholdTokens,
                 legacy: isCodeArenaMode(this.config.mode) || this.config.compactionMode === "summary",
+                onBeforeCompaction: !isCodeArenaMode(this.config.mode) && this.options.midturnCheckpointHook
+                    ? async (estimatedTokensBefore, thresholdTokens) => {
+                        const event = {
+                            type: "before_compaction", sessionId: this.sessionId, toolCalls: [],
+                            compaction: {
+                                count: trajectory.filter(message => message.role === "compaction" && !message.undone).length + 1,
+                                mode: this.config.compactionMode === "summary" ? "summary" : "rolling",
+                                source, estimatedTokensBefore, thresholdTokens,
+                            },
+                        };
+                        let action;
+                        try {
+                            action = checkpointAction(await this.options.midturnCheckpointHook(event));
+                            if (action !== "continue") {
+                                await this.makeCheckpoint(trajectory, this.tools.availableTools(), event, action);
+                            }
+                        }
+                        catch (error) {
+                            throw new CheckpointFailure(error);
+                        }
+                        if (action === "snapshot_exit")
+                            throw new CheckpointExit(event);
+                    }
+                    : undefined,
             };
             const contextLength = messages.length;
             const result = settings.legacy
@@ -647,26 +687,27 @@ export class Agent {
                     return this.checkpoint(trajectory).catch(() => undefined);
                 });
             if (result.compacted) {
+                const covered = settings.legacy ? result.coveredMessages : this.memoryCache.state.coveredMessages;
+                const retained = contextLength - covered;
+                // Insert at the covered boundary, before the retained original tail.
+                // Marker position is the resume boundary; no separate index is stored.
+                let insertion = trajectory.length;
+                let remaining = retained;
+                while (remaining > 0 && insertion > 0) {
+                    if (trajectory[--insertion].role !== "compaction")
+                        remaining--;
+                }
+                trajectory.splice(insertion, 0, {
+                    role: "compaction", content: [{ type: "text", text: result.memory }],
+                    undone: false,
+                    compaction: {
+                        ratio: result.estimatedTokensBefore / this.config.contextWindow,
+                        tokens_at_compaction: result.estimatedTokensBefore,
+                        source,
+                        retained_messages: retained,
+                    },
+                });
                 if (!isCodeArenaMode(this.config.mode)) {
-                    const covered = settings.legacy ? result.coveredMessages : this.memoryCache.state.coveredMessages;
-                    const retained = contextLength - covered;
-                    // Insert at the covered boundary, before the retained original tail.
-                    // Marker position is the resume boundary; no separate index is stored.
-                    let insertion = trajectory.length;
-                    let remaining = retained;
-                    while (remaining > 0 && insertion > 0) {
-                        if (trajectory[--insertion].role !== "compaction")
-                            remaining--;
-                    }
-                    trajectory.splice(insertion, 0, {
-                        role: "compaction", content: [{ type: "text", text: result.memory }],
-                        undone: false,
-                        compaction: {
-                            ratio: result.estimatedTokensBefore / this.config.contextWindow,
-                            tokens_at_compaction: result.estimatedTokensBefore,
-                            source,
-                        },
-                    });
                     // Coverage indices referred to the pre-compaction history. The next
                     // update reads its prior memory from the newly embedded block.
                     this.memoryCache.state = undefined;
@@ -680,7 +721,11 @@ export class Agent {
             }
             return result.compacted;
         }
-        catch {
+        catch (error) {
+            if (error instanceof CheckpointExit)
+                return "checkpoint";
+            if (error instanceof CheckpointFailure)
+                throw error.cause;
             // Compaction is protective rather than task-critical. If its dedicated
             // summary request fails, keep the original history and let the normal
             // model request (and its retry policy) decide whether it still fits.
@@ -707,6 +752,7 @@ export class Agent {
             const calls = new Map();
             const responseItems = new Map();
             let usage;
+            let finishReason;
             let reasoningDetails;
             const detectors = this.options.midturnCheckpointHook ? {
                 content: new RepetitiveOutputDetector(),
@@ -775,6 +821,9 @@ export class Agent {
                     // letting the last non-empty value win.
                     if (chunk.usage)
                         usage = chunk.usage;
+                    if (chunk.choices?.[0]?.finish_reason) {
+                        finishReason = chunk.choices[0].finish_reason;
+                    }
                     if (chunk.reasoning_details?.length) {
                         reasoningDetails = chunk.reasoning_details;
                     }
@@ -813,6 +862,11 @@ export class Agent {
                         if (fragment.function?.arguments) {
                             call.function.arguments += String(fragment.function.arguments);
                         }
+                        // Metadata is an opaque value for this index, not a text delta.
+                        // Later fragments that omit it must not erase an earlier signature.
+                        if (fragment.extra_content !== undefined) {
+                            call.extra_content = structuredClone(fragment.extra_content);
+                        }
                         calls.set(index, call);
                         this.sink.delta(this.sessionId, {
                             tool_calls: [
@@ -824,6 +878,9 @@ export class Agent {
                                         name: String(fragment.function?.name || ""),
                                         arguments: String(fragment.function?.arguments || ""),
                                     },
+                                    ...(fragment.extra_content !== undefined
+                                        ? { extra_content: structuredClone(fragment.extra_content) }
+                                        : {}),
                                 },
                             ],
                         });
@@ -896,7 +953,10 @@ export class Agent {
                     .sort(([left], [right]) => left - right)
                     .map(([, call]) => call);
             }
-            return assistant;
+            return {
+                assistant,
+                finishReason: finishReason ?? (assistant.tool_calls?.length ? "tool_calls" : "stop"),
+            };
         }
     }
     async retryBackoff(attempt) {