@thincoder/core 0.10.2 → 0.10.4

package/provider/anthropic.mjs

@@ -110,6 +110,15 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
   return finishAnthropic(result)
 }
 
+/** Anthropic `stop_reason` ⇒ 核统一 `finishReason`（§6.31.7 F-DA5——归一只喂既有分类；
+ *  余者原样透传）。缺席 ⇒ null（缺席支 = agent/run-stages.mjs 同面提醒 + 留痕）。 */
+function mapAnthropicStopReason(reason) {
+  if (reason === "end_turn" || reason === "stop_sequence") return "stop"
+  if (reason === "tool_use") return "tool_calls"
+  if (reason === "max_tokens") return "length"
+  return reason
+}
+
 /** Convert the parsed stream to the core.mjs result shape (usage → OpenAI-compatible). */
 function finishAnthropic(result) {
   const usage = result.usage
@@ -117,6 +126,7 @@ function finishAnthropic(result) {
     return {
       content: result.content,
       reasoning: result.reasoning,
+      finishReason: result.finishReason ?? null, // §6.31.7 F-DA5（原三 transport 恒 null——字段值收正）
       usage: {
         prompt_tokens: usage.input_tokens ?? 0,
         completion_tokens: usage.output_tokens ?? 0,
@@ -127,7 +137,7 @@ function finishAnthropic(result) {
       toolCalls: result.toolCalls,
     }
   }
-  return { content: result.content, reasoning: result.reasoning, toolCalls: result.toolCalls }
+  return { content: result.content, reasoning: result.reasoning, finishReason: result.finishReason ?? null, toolCalls: result.toolCalls }
 }
 
 /**
@@ -135,7 +145,7 @@ function finishAnthropic(result) {
  * Events: message_start, content_block_start, content_block_delta, content_block_stop, message_delta, message_stop
  */
 async function parseAnthropicStream(response, { onToken, onReasoning, signal }) {
-  const result = { content: "", reasoning: "", toolCalls: [], usage: null }
+  const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
   const decoder = new TextDecoder()
   let buffer = ""
   const toolBlocks = new Map()
@@ -172,6 +182,8 @@ async function parseAnthropicStream(response, { onToken, onReasoning, signal })
       }
       case "message_delta":
         if (json.usage) result.usage = json.usage
+        // §6.31.7 F-DA5（#929 · 批 digest-accounting）：`stop_reason` 捕获——缺席 ⇒ 留 null（窄口）
+        if (json.delta?.stop_reason) result.finishReason = mapAnthropicStopReason(json.delta.stop_reason)
         break
       case "message_stop":
         for (const [, block] of toolBlocks) {

package/provider/core.mjs

@@ -126,6 +126,8 @@ async function chatImpl(provider, { messages, tools, onToken, onReasoning, onWai
   // window/clamping logic below reads the overridden value where it matters.
   const spec = providerSpec(provider)
   messages = stripImagesForTextModel(messages, spec)
+  // #853 D-PR32：历史图片累计字节预算——发送前对消息副本累计驱逐（最老先弃；history 本体零触）。
+  messages = capHistoryImages(messages)
   // SESSION.md §6.9 T-S3: local-only message fields (ts/transient) never reach the wire.
   // Stripped BEFORE format dispatch — anthropic/responses transports pass whole message
   // objects through verbatim (only the OpenAI path ran escapeMessages). Copy-on-write:
@@ -330,7 +332,7 @@ export function buildContinuationMessages(messages, result, spec) {
 // Pre-send payload normalization lives in normalize.mjs (2026-08-31 extract,
 // TODO #2); re-exported so provider/index.mjs and tool-pairing.test.mjs keep
 // their import paths.
-import { stripImagesForTextModel, normalizeToolPairing } from "./normalize.mjs"
+import { stripImagesForTextModel, normalizeToolPairing, capHistoryImages } from "./normalize.mjs"
 export { stripImagesForTextModel, normalizeToolPairing }
 /** Merge tool calls from a retry/continuation into the accumulated result.
  *  2026-08-31 会诊 #7/#17：readSSE 输出的 tc 已 finalize（无 index 字段），
@@ -392,9 +394,9 @@ async function requestWithRetry(provider, body, signal, onWait) {
         _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
         _bodyIdleMs: FETCH_BODY_IDLE_MS,
       }
-      response = provider.proxyUri
-        ? await proxyFetch(url, opts, provider.proxyUri)
-        : await fetch(url, opts)
+      // #878 D-PX8：请求调用点收口——恒走 `proxyFetch`（无 proxyUri 即直连分支，内部 abort 通道单点建设；
+      // 原 call-site 分叉删除）。
+      response = await proxyFetch(url, opts, provider.proxyUri)
     } catch (error) {
       // AGENT-LOOP-SUBAGENT.md §6.12 站点 #2（第 24 批）：fetch 拒否面补标来源（undici 拒否的 AbortError 现场无 reason）
       if (error.name === "AbortError") throw annotateAbort(error, signal, "provider", "request")
@@ -406,6 +408,10 @@ async function requestWithRetry(provider, body, signal, onWait) {
 
     const text = await response.text().catch(() => "")
     let message = `LLM API error ${response.status}: ${text}`
+    // #853 D-PR32：413 可操作化——长会话图片累积的高频形态，从裸 HTTP 码变为可执行指引。
+    if (response.status === 413) {
+      message += " — request body too large (HTTP 413): run /compact to compress the conversation history, or remove historical images."
+    }
     // 401 双平台提示 + 诊断回显（2026-08-31 会诊 #15）：
     // Kimi 双平台 key 不互通的提示保留；通用加 baseURL host + key 前 6 位掩码，
     // 帮用户快速分辨"配错平台还是配错账号"。

package/provider/errors.mjs

@@ -99,3 +99,26 @@ export function assertProviderModel(provider) {
     throw new ProviderError(provider, "model is undefined — provider cloned without model re-derivation (set providers[].model — the channel default model)")
   }
 }
+
+/**
+ * #907-D8：Responses 流内错误码 → 分类（最小集五码）。宿主 = 本文件（分类族单源——与
+ * parseRetryAfter / isNonRetryableError 同族）；消费面 = responses.mjs 流内错误出口
+ * （response.failed onFailed ∥ type:"error" 帧处置）。HTTP 级分类（isNonRetryableError）
+ * 零改——本函数只服务流内错误面。未列码 → null（不发明分类，服务端消息原样透传）。
+ * retryable 是信息位：本批不接自动重试（无流内重试消费面），仅供上层展示/上报。
+ */
+export function classifyResponsesErrorCode(code) {
+  switch (code) {
+    case "context_length_exceeded":
+      return { kind: "context_overflow", retryable: false, hint: "上下文超限——/compact 压缩历史后重试" }
+    case "insufficient_quota":
+      return { kind: "quota", retryable: false, hint: "配额/计费不足——检查 provider 余额或套餐额度" }
+    case "invalid_prompt":
+      return { kind: "invalid_request", retryable: false, hint: null }
+    case "server_is_overloaded":
+    case "server_error":
+      return { kind: "server", retryable: true, hint: null }
+    default:
+      return null
+  }
+}

package/provider/google.mjs

@@ -8,6 +8,7 @@ import { proxyFetch } from "../proxy.mjs"
 import { requestWithRetry } from "./retry.mjs"
 import { effectiveFetchTimeoutMs } from "./core.mjs"
 import { abortError, timeoutError } from "../abort-provenance.mjs"
+import { terminateBody } from "../stream-destroy.mjs"
 
 /** OpenAI 语义 tool_choice → Gemini FunctionCallingConfig（2026-08-31 能力层）。 */
 function mapFunctionCallingConfig(choice) {
@@ -135,6 +136,7 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
     return {
       content: result.content,
       reasoning: result.reasoning,
+      finishReason: result.finishReason ?? null, // §6.31.7 F-DA5（原三 transport 恒 null——字段值收正）
       usage: {
         prompt_tokens: usage.prompt_tokens ?? 0,
         completion_tokens: usage.completion_tokens ?? 0,
@@ -144,7 +146,15 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
     }
   }
 
-  return { content: result.content, reasoning: result.reasoning, toolCalls: result.toolCalls }
+  return { content: result.content, reasoning: result.reasoning, finishReason: result.finishReason ?? null, toolCalls: result.toolCalls }
+}
+
+/** Gemini `finishReason` ⇒ 核统一 `finishReason`（§6.31.7 F-DA5——归一只喂既有分类；
+ *  余者原样透传）。缺席 ⇒ null（缺席支 = agent/run-stages.mjs 同面提醒 + 留痕）。 */
+function mapGeminiFinishReason(reason) {
+  if (reason === "STOP") return "stop"
+  if (reason === "MAX_TOKENS") return "length"
+  return reason
 }
 
 /**
@@ -152,7 +162,7 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
  * Format: data: {...}\n\n (each line is a complete JSON object)
  */
 async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
-  const result = { content: "", reasoning: "", toolCalls: [], usage: null }
+  const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
   const decoder = new TextDecoder()
   let buffer = ""
 
@@ -171,6 +181,8 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
 
     const candidate = json.candidates?.[0]
     if (!candidate) return
+    // §6.31.7 F-DA5（#929 · 批 digest-accounting）：`candidate.finishReason` 捕获——缺席 ⇒ 留 null（窄口）
+    if (candidate.finishReason) result.finishReason = mapGeminiFinishReason(candidate.finishReason)
 
     const parts = candidate.content?.parts || []
     for (const part of parts) {
@@ -197,10 +209,14 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
   // 2026-09-01 读侧 idle 超时（同 sse.mjs）：body 有数据流动即不超时；连续 120s 无新 chunk 判死
   const READ_IDLE_MS = 120_000
   let idleTimer = null
+  let idleError = null
   const armIdle = () => {
     if (idleTimer) clearTimeout(idleTimer)
     idleTimer = setTimeout(() => {
-      try { response.body?.destroy(timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "google-sse-idle")) } catch { /* already gone */ }
+      // #878：断流单点分流——直连 fetch（web 流）走 `IDLE_ABORT` 内部 abort 通道；
+      // proxy 形回落 destroyBody（原契约）。相位串 = 本腿专属 google-sse-idle。
+      idleError = timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "google-sse-idle")
+      try { terminateBody(response, idleError) } catch { /* already gone */ }
     }, READ_IDLE_MS)
     idleTimer.unref?.()
   }
@@ -238,6 +254,16 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
       result.interruptMessage = signal.reason.message
       return result
     }
+    // #878：看门狗终结两径归一（idleFired）——无内容 ⇒ idle 超时错误；有内容 ⇒ partial
+    //（已流出内容保留，不整轮报废）。非 idle 错误照旧走下方 hasPartial 径（原语义零变）。
+    if (idleError) {
+      if (result.content || result.reasoning || result.toolCalls.length) {
+        result.partial = true
+        result.networkError = idleError.message ?? String(idleError)
+        return result
+      }
+      throw idleError
+    }
     if (hasPartial(e)) {
       result.partial = true
       result.networkError = e.message ?? String(e)
@@ -251,7 +277,8 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
   return result
 }
 
-/** google.mjs 无 hasChoices 追踪——只有流中途死且已有内容才标 partial（同 sse.mjs 语义的简化版） */
+/** google.mjs 无 hasChoices 追踪——非 idle 网络错误按文案判 partial（同 sse.mjs 语义的简化版）；
+ *  idle 径两分（有内容 ⇒ partial ∥ 无内容 ⇒ 超时错误）归 catch（#878）。 */
 function hasPartial(e) {
   return /ECONNRESET|terminated|idle timeout|network/i.test(e?.message ?? "")
 }

package/provider/normalize.mjs

@@ -10,6 +10,63 @@
 
 const RASTER_IMAGE_URL = /^data:image\/(png|jpe?g|gif|webp);base64,/
 
+/** 历史图片累计字节预算（D-PR32——40MB 级请求体的保守下界，留两张大图余量；可调）。 */
+export const IMAGE_HISTORY_BYTES_BUDGET = 32 * 1024 * 1024
+
+/** 图片驱逐占位文本（D-PR32 逐字）。 */
+const IMAGE_BUDGET_PLACEHOLDER = "[image omitted — dropped to keep the request under the history image budget]"
+
+/** 单 part 的 base64 载荷长度（仅 data URL；非 data 引用不过请求体、零计账）。 */
+function imagePartBytes(p) {
+  if (p?.type !== "image_url") return 0
+  const url = p.image_url?.url
+  if (typeof url !== "string" || !url.startsWith("data:")) return 0
+  const comma = url.indexOf(",")
+  return comma >= 0 ? url.length - comma - 1 : 0
+}
+
+/**
+ * 历史图片累计字节预算（D-PR32）：全部 image part 的 base64 载荷和超 budgetBytes 时，
+ * 从**最老**图起替换为占位文本，直到剩余 ≤ 预算。纯函数 + 拷贝语义（未改动时返回原引用；
+ * 改动时仅重建涉及的消息对象）——发送前对消息副本用；注入面对 `history` 本体回写（同函数同预算）。
+ * @param {Array} messages
+ * @param {number} [budgetBytes]
+ */
+export function capHistoryImages(messages, budgetBytes = IMAGE_HISTORY_BYTES_BUDGET) {
+  if (!Array.isArray(messages)) return messages
+  const hits = []
+  let total = 0
+  for (let mi = 0; mi < messages.length; mi++) {
+    const parts = messages[mi]?.content
+    if (!Array.isArray(parts)) continue
+    for (let pi = 0; pi < parts.length; pi++) {
+      const bytes = imagePartBytes(parts[pi])
+      if (bytes <= 0) continue
+      total += bytes
+      hits.push({ mi, pi, bytes })
+    }
+  }
+  if (total <= budgetBytes || hits.length === 0) return messages
+  const drop = new Set()
+  let remaining = total
+  for (const hit of hits) {
+    if (remaining <= budgetBytes) break
+    drop.add(`${hit.mi}:${hit.pi}`)
+    remaining -= hit.bytes
+  }
+  return messages.map((m, mi) => {
+    const parts = m?.content
+    if (!Array.isArray(parts)) return m
+    let changed = false
+    const next = parts.map((p, pi) => {
+      if (!drop.has(`${mi}:${pi}`)) return p
+      changed = true
+      return { type: "text", text: IMAGE_BUDGET_PLACEHOLDER }
+    })
+    return changed ? { ...m, content: next } : m
+  })
+}
+
 export function stripImagesForTextModel(messages, spec) {
   let changed = false
   const out = messages.map((m) => {

package/provider/responses-request.mjs

@@ -196,7 +196,9 @@ export function buildBody(provider, messages, tools, opts = {}) {
     store: wantStateful && hostStateful && isStoreRequiredHost(provider.baseURL),
     ...(extracted ? { instructions: extracted } : {}),
     ...(toolsFlat ? { tools: toolsFlat } : {}),
-    ...(spec.maxOutput || provider.maxTokens ? { max_output_tokens: provider.maxTokens ?? spec.maxOutput } : {}),
+    // 显式才发（#907-D5）：仅 provider.maxTokens 显式设定时发送——spec.maxOutput 是规格侧
+    // 保守猜测非渠道合同值，恒发 = 渠道口径漂移 400 风险；无显式值 ⇒ 服务端默认（模型上限兜底）。
+    ...(provider.maxTokens != null ? { max_output_tokens: provider.maxTokens } : {}),
   }
   // 内置工具声明追加（2026-08-31 用户拍板）：web_search 与本地 function 工具共存
   const builtin = builtinToolsFor(provider.baseURL, provider.builtinTools)

package/provider/responses.mjs

@@ -16,6 +16,7 @@ import { proxyFetch } from "../proxy.mjs"
 import { requestWithRetry } from "./retry.mjs"
 import { rateGate, recordRate, estimateRequestTokens } from "./rate.mjs"
 import { buildBody, normalizeUsage } from "./responses-request.mjs"
+import { classifyResponsesErrorCode } from "./errors.mjs"
 // 同名 re-export（2026-09-29 structure-split-2 · 台账 #620——缝 = 同名再出口）：请求构造面出档 `provider/responses-request.mjs`；
 // `buildBody` / `isStoreRequiredHost` / `builtinToolsFor` 三名既有导出经本档转口——消费者 import 面零改。
 export { buildBody, isStoreRequiredHost, builtinToolsFor } from "./responses-request.mjs"
@@ -27,6 +28,19 @@ export function isChainInvalidError(status) {
   return status === 404 || status === 400
 }
 
+/** #907-D9/D8：error 帧处置回调（handleEvent 消费）——按 D8 码级标注定形后抛「标记错误」，catch 双支零丢失转发。 */
+function errFrameError(ev) {
+  const err = ev?.error
+  const msg = err?.message ?? JSON.stringify(err ?? ev ?? {}).slice(0, 300)
+  const cls = classifyResponsesErrorCode(err?.code)
+  const e = new Error(cls?.hint ? `${msg}（${cls.hint}）` : msg)
+  if (cls?.kind) e.errorKind = cls.kind
+  e.retryable = cls?.retryable ?? false
+  if (typeof err?.code === "number") e.status = err.code
+  e.responsesErrFrame = true // #907-D9 哨兵标记（不用 message 锚定——消息必须原样保留）
+  return e
+}
+
 /**
  * Responses 事件流解析（事件状态机）。输出与 chat completions 同形：
  * { content, reasoning, toolCalls, usage, finishReason, interrupted? }
@@ -67,17 +81,21 @@ export async function parseStream(response, { onToken, onReasoning, signal }) {
       if (!slot) return
       if (fullArgs && fullArgs !== slot.arguments) slot.arguments = fullArgs
     },
-    onCompleted: seal,
+    onCompleted: (resp) => { result.finishReason = "stop"; seal(resp) }, // §6.31.7 F-DA5：completed ⇒ stop（原恒 null ⇒ agent 面缺席）
     onIncomplete: (resp) => {
       seal(resp)
       // 非长度原因（content_filter 等）不能报成 "length"——agent 层按原因给用户提示（`agent/run-stages.mjs:43`）
       result.finishReason = resp?.incomplete_details?.reason === "content_filter" ? "content_filter" : "length"
     },
     onFailed: (resp) => {
+      // #907-D8：码级标注——errorKind/retryable 信息位 ∥ hint 拼入消息 ∥ status 仅数值（字符串码塞 status 是缺陷）
       const err = resp?.error
       const msg = err?.message ?? JSON.stringify(err ?? {}).slice(0, 500)
-      const e = new Error(`responses API failed: ${msg}`)
-      e.status = resp?.error?.code
+      const cls = classifyResponsesErrorCode(err?.code)
+      const e = new Error(cls?.hint ? `responses API failed: ${msg}（${cls.hint}）` : `responses API failed: ${msg}`)
+      if (cls?.kind) e.errorKind = cls.kind
+      e.retryable = cls?.retryable ?? false
+      if (typeof err?.code === "number") e.status = err.code
       throw e
     },
   })
@@ -88,6 +106,18 @@ export async function parseStream(response, { onToken, onReasoning, signal }) {
       seal(null)
       return { ...result, interrupted: true, interruptMessage: signal.reason.message }
     }
+    // #907-D9：error 帧双支——有流出（content ∥ toolCalls）⇒ partial 抢救返回；无流出 ⇒ 转抛（上抛为主）。
+    if (e?.responsesErrFrame) {
+      if (result.content.length > 0 || result.toolCalls.length > 0) {
+        const existing = result._warnings ??= []
+        if (!existing.some((w) => w.name === "responses-error-frame")) existing.push({ name: "responses-error-frame", message: e.message })
+        result.partial = true
+        result.errorDetail = e.message.slice(0, 300)
+        seal(null) // 无 responseId ⇒ finish() 链重置自动生效（错误后下轮全量重发）
+        return result
+      }
+      throw e
+    }
     throw e
   }
 
@@ -185,6 +215,8 @@ function handleEvent(ev, h) {
     case "response.failed":
       h.onFailed?.(ev.response)
       break
+    case "error": // #907-D9：标准 error 帧（原 default 静默跳过 = 空内容当回复——本件修复）
+      throw errFrameError(ev)
     default:
       break
   }
@@ -268,6 +300,8 @@ async function finish(provider, response, { onToken, onReasoning, signal, newCha
   } else {
     provider._responsesChain = null
   }
-  result._warnings = warnings
+  // #907-D9：合并而非覆盖——parseStream partial 抢救支已注入 responses-error-frame 警告
+  if (result._warnings?.length) result._warnings = [...warnings, ...result._warnings]
+  else result._warnings = warnings
   return result
 }

package/provider/sse.mjs

@@ -3,6 +3,7 @@
  * Extracted from core.mjs. Parses Server-Sent Events for LLM chat responses.
  */
 import { abortError, timeoutError } from "../abort-provenance.mjs"
+import { terminateBody } from "../stream-destroy.mjs"
 
 /**
  * Normalize provider cache fields into DeepSeek-style prompt_cache_hit/miss_tokens.
@@ -20,29 +21,43 @@ export function normalizeUsageCache(u) {
   }
   return u
 }
+/** 帧形状分派用前缀补差（D-PR31）：全同 ⇒ ""（零再增）；已收为前缀 ⇒ 只补差量；
+ *  无前缀关系 ⇒ 整段按增量追加（不吞真实内容——无法判定时不丢文本）。 */
+function snapshotSuffix(accumulated, text) {
+  if (text === accumulated) return ""
+  if (text.startsWith(accumulated)) return text.slice(accumulated.length)
+  return text
+}
+
 /** Defensive tool-call merge (PROVIDER.md §10): skip null/malformed elements and count them;
- *  merge slots by index / id / name / tail, accumulate arguments. */
-function mergeToolCalls(result, delta) {
+ *  merge slots by index / id / name / tail, accumulate arguments.
+ *  `snapshot: true`（D-PR31——`choice.message` 完整快照帧）：已有 slot（index / id 命中）的
+ *  arguments **覆盖**（非 +=）——修快照帧二次拼接；新 slot 照常建、其余路径零变。 */
+function mergeToolCalls(result, delta, { snapshot = false } = {}) {
   for (const tc of delta.tool_calls ?? []) {
     if (!tc || typeof tc !== "object") { result.droppedToolCalls++; continue }
     let slot
+    let existed = false
     if (Number.isInteger(tc.index) && tc.index >= 0) {
+      existed = result.toolCalls[tc.index] != null
       slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
     } else if (tc.id) {
       slot = result.toolCalls.find((s) => s && s.id === tc.id)
+      existed = !!slot
       if (!slot) { slot = { id: tc.id, name: "", arguments: "" }; result.toolCalls.push(slot) }
     } else if (tc.function?.name) {
       slot = { id: "", name: "", arguments: "" }
       result.toolCalls.push(slot)
     } else {
       slot = result.toolCalls[result.toolCalls.length - 1]
+      existed = !!slot
       if (!slot) { result.droppedToolCalls++; continue }
     }
     if (tc.id && !slot.id) slot.id = tc.id
     if (tc.function?.name && !slot.name) slot.name = tc.function.name
     const arg = tc.function?.arguments
-    if (typeof arg === "string") slot.arguments += arg
-    else if (arg != null) slot.arguments += JSON.stringify(arg)
+    if (typeof arg === "string") slot.arguments = snapshot && existed ? arg : slot.arguments + arg
+    else if (arg != null) slot.arguments = snapshot && existed ? JSON.stringify(arg) : slot.arguments + JSON.stringify(arg)
   }
 }
 
@@ -135,19 +150,29 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
     hasChoices = true
     if (choice.finish_reason) result.finishReason = choice.finish_reason
 
-    const delta = choice.delta ?? choice.message ?? {}
+    // 帧形状分派（D-PR31）：`delta == null && message != null` = 完整快照帧（MiniMax v2 类端点）——
+    // content / reasoning 前缀补差、tool_calls 覆盖；`delta` 在场 = 纯增量语义照旧
+    //（真增量文本天然可重复——不做去重）。
+    const snapshot = choice.delta == null && choice.message != null
+    const delta = snapshot ? choice.message : (choice.delta ?? {})
     // reasoning 方言：DeepSeek/Kimi/GLM 用 reasoning_content，OpenAI o 系和部分
     // 路由器用 reasoning —— 两个都认（2026-08-31 会诊 #9）
     const rDelta = delta.reasoning_content ?? delta.reasoning
     if (rDelta) {
-      result.reasoning += rDelta
-      onReasoning?.(rDelta)
+      const add = snapshot ? snapshotSuffix(result.reasoning, rDelta) : rDelta
+      if (add) {
+        result.reasoning += add
+        onReasoning?.(add)
+      }
     }
     if (delta.content) {
-      result.content += delta.content
-      onToken?.(delta.content)
+      const add = snapshot ? snapshotSuffix(result.content, delta.content) : delta.content
+      if (add) {
+        result.content += add
+        onToken?.(add)
+      }
     }
-    mergeToolCalls(result, delta)
+    mergeToolCalls(result, delta, { snapshot })
   }
 
   const processLines = (lines) => {
@@ -172,10 +197,14 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
   // 直连 fetch 与 proxyFetch 统一走这里（proxy 的 _bodyIdleMs 语义与之等价，双保险）。
   const READ_IDLE_MS = 120_000
   let idleTimer = null
+  let idleError = null
   const armIdle = () => {
     if (idleTimer) clearTimeout(idleTimer)
     idleTimer = setTimeout(() => {
-      try { response.body?.destroy(timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "sse-idle")) } catch { /* already gone */ }
+      // #878：断流单点分流——直连 fetch（web 流）走 `IDLE_ABORT` 内部 abort 通道，
+      // proxy 形回落 destroyBody（原契约）。
+      idleError = timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "sse-idle")
+      try { terminateBody(response, idleError) } catch { /* already gone */ }
     }, READ_IDLE_MS)
     idleTimer.unref?.()
   }
@@ -224,20 +253,23 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
       if (idleTimer) clearTimeout(idleTimer)
       return result
     }
+    // #878：看门狗终结归类归一（abort 通道下底层错误形不定）——无内容 ⇒ idle 超时错误；
+    // 有部分内容 ⇒ partial + networkError（原径语义保持）。
+    const err = idleError ?? e
     // 2026-08-31 会诊 #2（流中断丢全部已收内容）：网络级失败（ECONNRESET / 半截 EOF /
     // proxy 断连）时若已解析出内容，把 partial 交回上层而不是整轮报废重试。
     // 标记 partial:true + networkError（上层可决定续写/重试/展示部分结果）。
     if (hasChoices && (result.content || result.toolCalls.length)) {
       finalizeToolCalls(result)
       result.partial = true
-      result.networkError = e.message ?? String(e)
+      result.networkError = err.message ?? String(err)
       const existing = result._warnings ??= []
       if (!existing.some((w) => w.name === "network-partial")) {
         existing.push({ name: "network-partial", message: `stream interrupted by network error after partial output: ${result.networkError}` })
       }
       return result
     }
-    throw e
+    throw err
   }
 
   if (idleTimer) clearTimeout(idleTimer)

package/proxy.mjs

@@ -7,6 +7,7 @@ import { connect as tlsConnect } from "node:tls";
 import { PassThrough } from "node:stream";
 import { URL } from "node:url";
 import { abortError, timeoutError } from "./abort-provenance.mjs";
+import { IDLE_ABORT, destroyBody } from "./stream-destroy.mjs";
 
 const FETCH_TIMEOUT = 15_000
 
@@ -91,12 +92,12 @@ export function streamHttpResponse(sock, urlStr, opts = {}, timeout = FETCH_TIME
     function fail(err) {
       cleanup()
       if (!settled) { settled = true; reject(err) }
-      else body.destroy(err)
+      else destroyBody(body, err)
     }
     /** body 阶段空闲看门狗：每次数据到达重置；无数据超时 → 断流（流式消费方抛错） */
     function armIdle() {
       clearTimeout(idleTimer)
-      if (bodyIdleMs > 0) idleTimer = setTimeout(() => body.destroy(timeoutError("Response body timeout (idle)", "provider", "proxy-body-idle")), bodyIdleMs)
+      if (bodyIdleMs > 0) idleTimer = setTimeout(() => destroyBody(body, timeoutError("Response body timeout (idle)", "provider", "proxy-body-idle")), bodyIdleMs)
     }
 
     sock.on("data", (d) => {
@@ -261,9 +262,18 @@ function tcpConnectProxy(proxyUri, signal, timeout) {
 /**
  * Generic fetch with proxy support.
  * No proxy → native fetch. Proxy + HTTPS → CONNECT tunnel. Proxy + HTTP → 经典代理转发（绝对 URI 请求行）。
+ * 直连分支 = 内部 abort 通道建设点（#878 D-PX8）：建 `AbortController` + signal 合成（`AbortSignal.any`，
+ * 无 user signal 时单独用）后经 `IDLE_ABORT` 挂 response——web `ReadableStream` 的读侧看门狗
+ * （`readSSE` ∥ `parseGeminiStream`）经 `terminateBody` 恢复有效；proxy 两分支不挂（自有 `_bodyIdleMs`）。
  */
 export async function proxyFetch(urlStr, opts, proxyUri) {
-  if (!proxyUri) return globalThis.fetch(urlStr, opts)
+  if (!proxyUri) {
+    const idleAbort = new AbortController()
+    const signal = opts?.signal ? AbortSignal.any([opts.signal, idleAbort.signal]) : idleAbort.signal
+    const response = await globalThis.fetch(urlStr, { ...opts, signal })
+    response[IDLE_ABORT] = idleAbort
+    return response
+  }
   const target = new URL(urlStr)
   if (target.protocol === "https:") return tunnelHttps(urlStr, opts, proxyUri)
   // http:// 目标：TCP 直连代理，请求行发绝对 URI（GET http://host/path HTTP/1.1）

package/session.mjs

@@ -106,8 +106,11 @@ function digestFromStore(fields, counters, mtimeMs) {
  *  Restore now always rebuilds from history (lazy, see startup.mjs).
  *  2026-08-31 会诊 F1：slot 粘性——首次认领后缓存 agent._slot，永不重跑 ensureActive
  *  （原实现每次保存重推，manifest active 被并发方翻动时会话静默迁移）。
- *  返回轮转的 .bak 路径或 null。 */
-export function saveSession(agent) {
+ *  返回轮转的 .bak 路径或 null。
+ *  **`opts.prefsSeedOnly`（加性 · 2026-10-04 解锁批 · R2——唯一传者 = 桌面两落盘点）**：回合关联落盘
+ *  **不携会话级三键**（`provider` / `model` / `effort`）——写前读槽：复合在场（`activeProvider` 非空串 ∧
+ *  `activeModel` 真值）⇒ 槽值赢 ∥ 缺 ⇒ 记忆值播种；`effort` 单键在场（值可 `null`）⇒ 槽值保留。 */
+export function saveSession(agent, opts = {}) {
   // _fullHistory is written at the source via pushReal — no flush needed here.
   // history        = FULL, never-compacted (human-readable; VS Code panel & CLI resume read this)
   // contextHistory = machine context (possibly compacted) so CLI resume keeps the token savings
@@ -168,6 +171,14 @@ export function saveSession(agent) {
   // 原值——`"off"` 记号原样写盘，不回填为具体档）；缺之 ⇒ 下一次回合保存把槽写面结果整对象抹除。
   // `undefined` = 本会话未携带（老槽无该键 / 未经 `applySession`）⇒ 键不落盘（禁回填）。
   if (agent._slotEffort !== undefined) fields.effort = agent._slotEffort
+  // R2（2026-10-04 解锁批 · 加性 `prefsSeedOnly`）：回合关联落盘**不携三键**——写前读槽（守卫后：轮转现场不参与判据），
+  // 复合在场（`activeProvider` 非空串 ∧ `activeModel` 真值）⇒ 槽值赢（防起跑快照覆写忙期新选定）∥ 缺 ⇒ 记忆值播种。
+  if (opts.prefsSeedOnly === true) {
+    const onDisk = loadSlotFile(agent.cwd, slot) ?? {}
+    const compositeOn = typeof onDisk.activeProvider === "string" && onDisk.activeProvider !== "" && Boolean(onDisk.activeModel)
+    if (compositeOn) Object.assign(fields, { activeProvider: onDisk.activeProvider, activeModel: onDisk.activeModel })
+    if (Object.hasOwn(onDisk, "effort")) fields.effort = onDisk.effort ?? null
+  }
   // 绑定态 → 流式投影（段原文拼接——VSC 兼容面逐字同形）；未绑定 → 既有全量物化写
   if (agent._recordStore) saveProjectedSlot(agent, p, fields, contextHistory)
   else writeSessionFile(p, { ...fields, history: legacyHistory(agent), contextHistory })