thincoder 0.12.52 → 0.12.53

package/src/mcp.mjs

@@ -7,29 +7,159 @@ import { stdioTransport } from "./mcp/transport-stdio.mjs"
 import { httpTransport } from "./mcp/transport-http.mjs"
 import { wsTransport } from "./mcp/transport-ws.mjs"
 
+
+/** Race a pending MCP request against an abort signal — a hung MCP server must not
+ *  hold the turn hostage. signal absent → passthrough. */
+async function sendWithSignal(promise, signal) {
+  if (!signal) return promise
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      const e = new DOMException("The operation was aborted", "AbortError")
+      e.reason = signal.reason
+      reject(e)
+    }
+    if (signal.aborted) return onAbort()
+    signal.addEventListener("abort", onAbort, { once: true })
+    promise.then(
+      (v) => { signal.removeEventListener("abort", onAbort); resolve(v) },
+      (e) => { signal.removeEventListener("abort", onAbort); reject(e) },
+    )
+  })
+}
+
 // ---- MCP lifecycle ----
 
-function buildTools(mcpTools, transport, config) {
+/** 2026-08-31 MCP 会诊 P5：CLI session 注册表（serverName → session）。
+ *  session.state.transport 可变（重连替换）；buildTools 的 execute 动态取
+ *  session.state.transport——server 崩溃后无需重建 agent.tools 即自愈。 */
+const _sessions = new Map()
+/** 退避重连进行中（serverName → promise）——与 vscode 语义对齐；延迟表见 _mcpHooks。 */
+const _reconnecting = new Map()
+
+/** 2026-08-31 MCP 会诊 P5：测试钩子（退避延迟可替换，惯例同 rate.mjs _rateHooks）。
+ *  scheduleReconnect 与 ensureAlive 读这里的 delay/reconnectDelays——测试可注入微秒级延迟。 */
+export const _mcpHooks = {
+  delay: (ms) => new Promise((r) => setTimeout(r, ms)),
+  reconnectDelays: [1000, 2000, 4000, 8000],
+}
+
+/** 按 config 创建并完成握手的 transport（findTransportConfig 与 vscode 对齐）。 */
+async function createConnectedTransport(config, serverName) {
+  let transport
+  if (config.wsUrl) {
+    transport = wsTransport(config.wsUrl, config.headers ?? {})
+    await transport.connect()
+  } else if (config.url) {
+    transport = httpTransport(config.url, config.headers ?? {})
+    try {
+      await transport.openSSE()
+    } catch {
+      // Server doesn't support GET SSE — degrade to pure Streamable HTTP POST mode
+    }
+  } else {
+    transport = stdioTransport(config.command, config.args ?? [], config.env)
+  }
+  const mcpTools = await doInitialize(transport, serverName)
+  return { transport, mcpTools }
+}
+
+/** onDead → 后台退避重连；成功替换 session.state.transport（tools 闭包动态引用，
+ *  agent.tools 无需重建）；失败静默（下次 execute 前置检查再试）。 */
+function scheduleReconnect(name, config) {
+  if (_reconnecting.has(name)) return _reconnecting.get(name)
+  const p = (async () => {
+    let lastErr
+    for (const delayMs of _mcpHooks.reconnectDelays) {
+      await _mcpHooks.delay(delayMs)
+      try {
+        const { transport } = await createConnectedTransport(config, name)
+        const session = _sessions.get(name)
+        if (!session || session.closed) { transport.close(); return false }
+        attachSession(session, transport)
+        return true
+      } catch (error) {
+        lastErr = error
+      }
+    }
+    console.error(`[mcp] ${name} reconnect failed after ${_mcpHooks.reconnectDelays.length} attempts: ${lastErr?.message ?? lastErr}`)
+    return false
+  })().finally(() => _reconnecting.delete(name))
+  _reconnecting.set(name, p)
+  return p
+}
+
+/** 给 session 绑定一个新 transport（建连 onDead 钩子 → 自愈链）。 */
+function attachSession(session, transport) {
+  session.state.transport = transport
+  transport.onDead?.(() => {
+    if (session.state.transport !== transport) return // 已再替换，旧钩子作废
+    scheduleReconnect(session.config.name ?? session.config.command ?? session.config.url ?? session.config.wsUrl, session.config)
+  })
+}
+
+function buildTools(mcpTools, session, config) {
   const prefix = config.name ? `${config.name}_` : "mcp_"
-  return mcpTools.map((t) => ({
-    name: sanitizeToolName(prefix + t.name),
-    description: t.description ?? `MCP tool: ${t.name}`,
-    parameters: t.inputSchema ?? { type: "object", properties: {} },
-    readonly: false,
-    async execute(args) {
-      const resp = await transport.send("tools/call", { name: t.name, arguments: args })
-      if (resp.error) throw new Error(`MCP tool "${t.name}": ${resp.error.message}`)
-      const content = resp.result?.content ?? []
-      return content
-        .map((c) => (c.type === "text" ? c.text : c.type === "resource" ? `[resource: ${c.resource?.uri}]` : JSON.stringify(c)))
-        .join("\n") || "(no output)"
-    },
-    _mcpTransport: transport,
-    _mcpName: config.name,
-  }))
+  // 2026-08-31 MCP 会诊 P6：sanitize 碰撞/空名防御 + schema/description 类型守卫 + 输出防御
+  const seen = new Set()
+  const out = []
+  for (const t of mcpTools) {
+    const rawName = sanitizeToolName(prefix + t.name)
+    if (!rawName || rawName === "mcp_") continue
+    let name = rawName
+    for (let n = 2; seen.has(name); n++) name = `${rawName}_${n}`
+    seen.add(name)
+    out.push({
+      name,
+      description: typeof t.description === "string" ? t.description : `MCP tool: ${t.name}`,
+      parameters: (t.inputSchema && typeof t.inputSchema === "object") ? t.inputSchema : { type: "object", properties: {} },
+      readonly: false,
+      async execute(args, ctx) {
+        // 2026-08-31 会诊 #11：上层 signal 中断 + send 第 3 参底层取消（pending 即刻作废）
+        // P5：执行前动态取 session.transport——死亡时等重连 promise/触发一次重连再试
+        const transport = await ensureAlive(session)
+        const send = transport.send("tools/call", { name: t.name, arguments: args }, ctx?.signal)
+        const resp = await sendWithSignal(send, ctx?.signal)
+        if (resp.error) throw new Error(`MCP tool "${t.name}": ${resp.error.message}`)
+        if (resp.result?.isError) throw new Error(`MCP tool "${t.name}": ${extractMcpText(resp.result.content) || "(server reported an error)"}`)
+        return truncateMcpOutput(extractMcpText(resp.result?.content ?? [])) || "(no output)"
+      },
+      _mcpTransport: session.state.transport,
+      _mcpName: config.name,
+    })
+  }
+  return out
 }
 
-async function doInitialize(transport, name) {
+/** P5：拿到活的 transport——死连接等待/触发重连；耗尽后抛错（工具错误透给模型）。 */
+async function ensureAlive(session) {
+  const t = session.state.transport
+  if (t?.isAlive?.()) return t
+  const name = session.config.name ?? session.config.command ?? session.config.url ?? session.config.wsUrl
+  let reconnect = _reconnecting.get(name)
+  if (!reconnect) reconnect = scheduleReconnect(name, session.config)
+  const ok = await reconnect
+  if (!ok || !session.state.transport?.isAlive?.()) {
+    throw new Error(`MCP server "${name}" is unavailable (reconnect failed)`)
+  }
+  return session.state.transport
+}
+
+/** MCP content 数组 → 文本（非数组/元素非对象防御）。 */
+function extractMcpText(content) {
+  if (!Array.isArray(content)) return typeof content === "string" ? content : JSON.stringify(content)
+  return content
+    .filter((c) => c && typeof c === "object")
+    .map((c) => (c.type === "text" ? c.text : c.type === "resource" ? `[resource: ${c.resource?.uri}]` : JSON.stringify(c)))
+    .join("\n")
+}
+
+/** 输出截断（32KB 上限，防 server 回 10MB 撑爆上下文）。 */
+function truncateMcpOutput(text) {
+  if (text.length <= 32_000) return text
+  return text.slice(0, 32_000) + "\n[… truncated: " + (text.length - 32_000) + " chars omitted]"
+}
+
+async function doInitialize(transport, _name) {
   const initResp = await withTimeout(
     transport.send("initialize", {
       protocolVersion: "2024-11-05",
@@ -41,68 +171,77 @@ async function doInitialize(transport, name) {
   if (initResp.error) throw new Error(`initialize error: ${initResp.error.message}`)
   transport.notify?.("notifications/initialized", {})
 
-  const toolsResp = await transport.send("tools/list", {})
-  if (toolsResp.error) throw new Error(`tools/list failed: ${toolsResp.error.message}`)
-  return toolsResp.result?.tools ?? []
+  // 2026-08-31 MCP 会诊 P6：tools/list 分页被忽略（nextCursor 多页工具静默丢失）——
+  // 循环跟随 cursor 直到 server 不再返回（上限 20 页防死循环）。
+  const tools = []
+  let cursor
+  for (let page = 0; page < 20; page++) {
+    const toolsResp = await transport.send("tools/list", cursor ? { cursor } : {})
+    if (toolsResp.error) throw new Error(`tools/list failed: ${toolsResp.error.message}`)
+    tools.push(...(toolsResp.result?.tools ?? []))
+    cursor = toolsResp.result?.nextCursor
+    if (!cursor) break
+  }
+  return tools
 }
 
-/** Connect to an MCP server (stdio/http/ws), initialize, and return built tool wrappers */
+/** Connect to an MCP server (stdio/http/ws), initialize, and return built tool wrappers.
+ *  2026-08-31 MCP 会诊 P5：session 幂等——同 name 活连接复用（make-agent 每进程一次，
+ *  cmd-mcp 重复 add 同一 server 不会双实例），崩溃后下次调用/execute 自愈。 */
 export async function connectMcpServer(config) {
-  if (config.wsUrl) {
-    const transport = wsTransport(config.wsUrl, config.headers ?? {})
-    try {
-      await transport.connect()
-      const mcpTools = await doInitialize(transport, config.name ?? config.wsUrl)
-      return buildTools(mcpTools, transport, config)
-    } catch (error) {
-      transport.close()
-      throw error
-    }
-  }
+  if (!config || (!config.command && !config.url && !config.wsUrl))
+    throw new Error(`MCP server "${config?.name ?? ""}": needs either 'wsUrl' (websocket), 'command' (stdio), or 'url' (http)`)
+  const name = config.name ?? config.command ?? config.url ?? config.wsUrl
+  const configFingerprint = JSON.stringify([config.command ?? null, config.args ?? null, config.url ?? null, config.wsUrl ?? null, config.env ?? null, config.headers ?? null])
 
-  if (config.url) {
-    const transport = httpTransport(config.url, config.headers ?? {})
-    try {
-      await transport.openSSE()
-    } catch {
-      // Server doesn't support GET (pure Streamable HTTP POST): degrade to no-SSE mode
+  const existing = _sessions.get(name)
+  if (existing && !existing.closed) {
+    const sameConfig = existing.configFingerprint === configFingerprint
+    if (sameConfig && existing.state.transport?.isAlive?.()) {
+      return existing.state.tools
     }
-    try {
-      const mcpTools = await doInitialize(transport, config.name ?? config.url)
-      return buildTools(mcpTools, transport, config)
-    } catch (error) {
-      transport.close()
-      throw error
+    if (!sameConfig) {
+      // config 变更：主动关闭旧连接（不触发 onDead 重连）并丢弃 session
+      existing.closed = true
+      try { existing.state.transport?.close() } catch { /* ignore */ }
+      _sessions.delete(name)
     }
   }
 
-  if (config.command) {
-    const transport = stdioTransport(config.command, config.args ?? [], config.env)
-    try {
-      const mcpTools = await doInitialize(transport, config.name ?? config.command)
-      return buildTools(mcpTools, transport, config)
-    } catch (error) {
-      transport.close()
-      throw error
-    }
+  const { transport, mcpTools } = await createConnectedTransport(config, name)
+  const session = {
+    config, configFingerprint,
+    state: { transport, tools: null },
+    closed: false,
   }
-
-  throw new Error(`MCP server "${config.name}": needs either 'wsUrl' (websocket), 'command' (stdio), or 'url' (http)`)
+  session.state.tools = buildTools(mcpTools, session, config)
+  attachSession(session, transport)
+  _sessions.set(name, session)
+  return session.state.tools
 }
 
 /** Close all MCP transport connections on an agent's tools */
 export function closeAllMcp(agent) {
   for (const t of agent.tools) {
-    if (t._mcpTransport) t._mcpTransport.close()
+    if (t._mcpTransport) closeSession(t._mcpName)
   }
 }
 
+/** 主动关闭 session（不触发 onDead 重连）：transport close + 登记关闭标记 + 清注册表。 */
+function closeSession(name) {
+  const session = _sessions.get(name)
+  if (!session) return
+  session.closed = true
+  try { session.state.transport?.close() } catch { /* ignore */ }
+  _sessions.delete(name)
+}
+
 /** Remove MCP tools belonging to a specific server from the agent's tool list */
 export function removeMcpTools(agent, serverName) {
   const keep = []
   for (const t of agent.tools) {
     if (t._mcpName === serverName) {
-      if (t._mcpTransport) t._mcpTransport.close()
+      closeSession(serverName)
     } else {
       keep.push(t)
     }

package/src/prompts/discipline.md

@@ -19,6 +19,7 @@ UI & interface design:
 - A value with a FIXED set of choices (enum, level, mode, flag) must be OPTIONS — picker / menu / choices / buttons. Never free-text input.
 - Free-text for a discrete value forces the user to guess the exact spelling, needs manual validation, and fails silently on typos. This has happened repeatedly (e.g. reasoning-effort levels typed by hand).
 - Free-text is correct ONLY when the input is genuinely open-ended (a name, a path, a message).
+- **用户约定执行纪律（2026-08-31，两次违约教训）**：用户对交互/行为的约定以用户原话为准——实现时逐字对照，不得用"等效实现"替换约定本身（已发生：滚动→点击翻窗、滚动到头自动加载→PgUp 键触发）。已确认约定的简化/降级必须提前上报，不得包装成"升级路径"交付。注释里的 parity with X / 对齐 X 只描述来源，不代表 X 就是正确语义——以用户约定为唯一判据，实现后真机验证用户原话的每个承诺点。
 
 Tool routing — use the dedicated tool, not bash:
 - **git operations** → `git` tool (action=status/diff/log/show/add/commit/push/tag/branch/checkout/restore/stash/fetch/pull/reset/revert/merge/cherry-pick; `workdir` for sub-repos). Never run git via bash.
@@ -29,6 +30,48 @@ Tool routing — use the dedicated tool, not bash:
 - Each tool's description carries a "Route to X instead of bash" mapping.
 - **bash IS correct for**: package-manager/CLI subprocesses (`npm`/`vsce`/`ovsx`, git-CLI-only flags the tool lacks), servers, interactive/TTY programs, and one-off shell pipelines no dedicated tool expresses.
 
+**Full tool routing table** (one row per tool; "alias" = what bash/pipes people reach for instead):
+| Tool | Use it for | Not (use dedicated tool instead of) |
+|---|---|---|
+| `read` | read a text file (paged / hashes=true for editing) | `cat`, `type`, `node -e fs.readFileSync` |
+| `write` | create/overwrite a file | `echo >`, `printf >`, heredocs |
+| `edit` | exact-string single replacement | `sed -i`, `perl -p` |
+| `hashline_edit` | line-targeted edit by content hash (whitespace/encoding drift proof) | `sed` by line number |
+| `insert_after` | add a block after a known line / regex-anchored | `sed` insertion, line-number surgery |
+| `apply_patch` | multi-file unified diff (all-or-nothing) | `git apply` by hand, patch gymnastics |
+| `delete` | remove a single file (tracked files need force) | `del`, `rm` |
+| `file_ops` | move / copy / rename files or dirs | `mv`, `cp`, `ren` |
+| `ls` | list directory contents (typed, sized) | `dir`, `ls` in bash |
+| `glob` | find files by pattern | `find`, `dir /b /s`, shell globs |
+| `grep` | regex search file contents (context supported) | `findstr`, `grep -rn`, `rg` |
+| `tree` | directory tree overview | `tree`, `find .` |
+| `repo_outline` | module dependency / symbol map | ad-hoc scripts |
+| `code_search` | natural-language code search | grep gymnastics |
+| `doc_search` | search project docs (design/AGENTS) | `findstr` in docs |
+| `read_image` | view an image (vision models) | external viewers |
+| `execute` | run JS inline / scriptFile (+ nodeArgs for `node --test`/`--check`) | `bash node -e`, `node <script>` via bash |
+| `bash` | npm/vsce/CLI subprocess, servers, TTY programs, one-off pipelines no tool expresses | always; see allowed list above |
+| `git` | ALL git ops (status/diff/log/show/add/commit/push/tag/branch/checkout/restore/stash/fetch/pull/reset/revert/merge/cherry-pick/ls-remote) | `git` in bash |
+| `process` | list running processes | `tasklist`, `ps`, `wmic` |
+| `get_current_time` | current date/time | `date` |
+| `timer` | thinking budget / wait reminder | `sleep`, `timeout` (for real waits) |
+| `lint` | lint / syntax check after edits (full=true for cascade) | ad-hoc eslint runs |
+| `verify` | pre-completion self-check (syntax/tests/diff/checklist) | manual diff/test runs |
+| `task` / `checklist` | session-level tasks / persistent requirements tracking | README-style todo lists |
+| `goal` | long-running autonomous goal (machine-checkable criteria) | prose promises |
+| `plan` / `eng` | plan mode / engineering mode entry-exit | none (mode transitions only here) |
+| `skill` | load project skills (.thincoder/skills/) | re-inventing workflows |
+| `question` | ask the user (ambiguity, design decisions) | guessing |
+| `advisor` | independent review of code/design | self-review only |
+| `subagent` | delegate subtasks to isolated contexts | inlining exploration |
+| `consult_start` / `consult_check` / `consult_stop` | parallel multi-model consultation | single-model guessing |
+| `escalate` | fly in a stronger model for hard implementation | burning attempts |
+| `memory_put` / `memory_search` | long-term knowledge save/search | session notes |
+| `checkpoint` | git snapshots / rewind safety | manual branches |
+| `fetch` | fetch a URL (explicit proxy per target; config proxy NOT auto-applied) | `curl` |
+| `websearch` | Bing search (weak for technical; MCP search tool first) | `curl` scraping |
+| `glm-websearch_web_search_prime` | technical lookups (primary when available) | Bing fallback loop |
+
 Review discipline (standard mode only — engineering mode has its own review timing rules):
 - **Advisor:** call after changing code. Must provide scope: `paths` (files/dirs to review) or `documents` (context).
 - **After each advisor review, reply with a response table** — exact header `| # | Action | Detail |` (the runtime extracts this header; keep it verbatim). One row per issue; `#` = the advisor's issue number (`Orig#` on rounds 2+).

package/src/provider/anthropic.mjs

@@ -6,9 +6,21 @@
 
 import { specForModel } from "../config.mjs"
 import { proxyFetch } from "../proxy.mjs"
+import { requestWithRetry } from "./retry.mjs"
 
 const ANTHROPIC_VERSION = "2023-06-01"
 
+/** OpenAI 语义 tool_choice → Anthropic tool_choice（2026-08-31 能力层）。
+ *  传入值形态：undefined | "auto" | "required" | "none" | {type:"function",function:{name}} */
+function mapToolChoice(choice) {
+  if (choice === "auto") return { type: "auto" }
+  if (choice === "required") return { type: "any" }
+  if (choice === "none") return { type: "none" }
+  if (choice && typeof choice === "object" && choice.function?.name) return { type: "tool", name: choice.function.name }
+  throw new Error(`Invalid tool_choice for Anthropic format: ${JSON.stringify(choice).slice(0, 120)}`)
+}
+
+
 /** Convert OpenAI-format tools to Anthropic format */
 export function normalizeTools(tools) {
   return (tools || []).map((t) => ({
@@ -18,8 +30,11 @@ export function normalizeTools(tools) {
   }))
 }
 
-/** Build and send an Anthropic chat request. Returns the same shape as core.mjs chat. */
-export async function chat(provider, { messages, tools, onToken, onReasoning, signal }) {
+/** Build and send an Anthropic chat request. Returns the same shape as core.mjs chat.
+ *  2026-08-31 会诊 #6：接入 rateGate/recordRate + 429 Retry-After 单次重试
+ *  （原实现完全绕过 TPM/RPM 闸门与记账——用户配了 tpm 以为受控实际不受控）。
+ *  注：5xx/网络退避重试未与 OpenAI 格式对齐（三 transport 共用那步工作量大，见报告）。 */
+export async function chat(provider, { messages, tools, onToken, onReasoning, onWait, signal, toolChoice, parallelToolCalls }) {
   // Extract system message(s) — Anthropic uses top-level `system` field
   const systemMessages = []
   const chatMessages = []
@@ -40,6 +55,9 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
   }
   if (systemMessages.length > 0) body.system = systemMessages.join("\n\n")
   if (tools?.length) body.tools = tools
+  // 2026-08-31：tool_choice 能力层——OpenAI 语义映射到 Anthropic tool_choice
+  // （auto→{type:"auto"} / required→{type:"any"} / none→{type:"none"} / 具体函数→{type:"tool",name}）
+  if (toolChoice !== undefined) body.tool_choice = mapToolChoice(toolChoice)
   if (provider.temperature != null) {
     let t = provider.temperature
     // Anthropic API hard limit is 0-1; models without a declared tempRange still get clamped
@@ -59,23 +77,37 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
   // Active signal check
   if (signal?.aborted) throw Object.assign(new DOMException("Aborted", "AbortError"), { reason: signal.reason })
 
-  const response = await proxyFetch(`${provider.baseURL}/messages`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    signal: signal
-      ? AbortSignal.any([signal, AbortSignal.timeout(FETCH_TIMEOUT_MS)])
-      : AbortSignal.timeout(FETCH_TIMEOUT_MS),
-  }, provider.proxyUri)
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "")
-    throw new Error(`Anthropic API error ${response.status}: ${text}`)
-  }
+  // 会诊 #6：TPM/RPM 闸门 + 记账（rate.mjs 与 OpenAI 格式共用同一窗口）
+  const { rateGate, recordRate } = await import("./rate.mjs")
+  const estimated = await (async () => {
+    const { estimateRequestTokens } = await import("./rate.mjs")
+    return estimateRequestTokens(body)
+  })()
+  await rateGate(provider, estimated, onWait, signal)
+
+  // 2026-08-31：4xx/5xx/网络与 OpenAI 格式统一退避重试链（原仅 429 Retry-After 单次重试，
+  // 5xx 直接抛——DeepSeek/Claude 排队 503 时其他格式可自动恢复，这里语义割裂）
+  const response = await requestWithRetry(
+    () => proxyFetch(`${provider.baseURL}/messages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: signal
+        ? AbortSignal.any([signal, AbortSignal.timeout(FETCH_TIMEOUT_MS)])
+        : AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      _headerTimeoutMs: FETCH_TIMEOUT_MS,
+      _bodyIdleMs: 120_000,
+    }, provider.proxyUri),
+    { signal, onWait, buildMessage: (status, text) => `Anthropic API error ${status}: ${text}` },
+  )
 
   const result = await parseAnthropicStream(response, { onToken, onReasoning, signal })
+  recordRate(provider, estimated, result.usage)
+  return finishAnthropic(result)
+}
 
-  // Convert Anthropic usage format to OpenAI-compatible
+/** Convert the parsed stream to the core.mjs result shape (usage → OpenAI-compatible). */
+function finishAnthropic(result) {
   const usage = result.usage
   if (usage) {
     return {
@@ -91,7 +123,6 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
       toolCalls: result.toolCalls,
     }
   }
-
   return { content: result.content, reasoning: result.reasoning, toolCalls: result.toolCalls }
 }
 
@@ -157,6 +188,8 @@ async function parseAnthropicStream(response, { onToken, onReasoning, signal })
       throw e
     }
     buffer += decoder.decode(chunk, { stream: true })
+    // BOM 剥除（会诊 #12）：首个 chunk 可能带 \uFEFF，否则 message_start 事件被静默丢失（含 usage）
+    if (buffer.charCodeAt(0) === 0xfeff) buffer = buffer.slice(1)
     const lines = buffer.split("\n")
     buffer = lines.pop()
 
@@ -167,7 +200,7 @@ async function parseAnthropicStream(response, { onToken, onReasoning, signal })
         currentData = ""
       } else if (line.startsWith("data: ")) {
         currentData = line.slice(6).trim()
-      } else if (line === "") {
+      } else if (line === "" || line === "\r") { // CRLF 空行是 "\r"（会诊 #13）
         if (currentEvent) processEvent(currentEvent, currentData)
         currentEvent = ""
         currentData = ""