mslxdff 0.1.188 → 0.1.194

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.188",
+  "version": "0.1.194",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/anthropic/count-tokens.js

@@ -13,7 +13,9 @@ const CHAR_CAP = 32_000_000;
 // （每条消息 content 整段一次 + 每个 tool_call 一次）。逐块各套会把「非空至少 1」下限乘上块数
 // —— 几十个 1 字符 text 块能被高报几十倍（评审 P3：方向虽偏高安全，但与生成侧口径分叉就是第二个真相源）。
 function add(acc, text) {
-  if (acc.chars > CHAR_CAP) return; // 超限后停止累计，只保留已计部分与图片面值
+  // 超限后停止累计（chars 与 tokens 一起停）：只护 chars 会让 tokens 无界增长，
+  // 客户端拿这个读数决定何时压实上下文 ⇒ 超长请求触发一次毫无必要的激进压缩。
+  if (acc.chars > CHAR_CAP) return;
   const s = text == null ? "" : String(text);
   const c = createTokenCounter();
   c.add(s);
@@ -36,8 +38,13 @@ function countMessage(m, acc) {
     else if (b.type === "thinking") put(String(b.thinking || ""));
     else if (b.type === "image") acc.images += 1;
   }
-  if (acc.chars <= CHAR_CAP) acc.chars += chars;
-  acc.tokens += c.tokens();
+  // tokens 与 chars 必须**同受 CHAR_CAP 约束**：只护 chars 不护 tokens 时，超长请求（readBody 无大小上限，
+  // 实测 10 条 4000 万字符消息 → 1.11 亿 tokens）会把读数推到天文数字，而客户端正是拿它决定何时压实上下文
+  // ⇒ 一次毫无必要的激进压缩。超限后不再累加，保留已计部分。
+  if (acc.chars <= CHAR_CAP) {
+    acc.chars += chars;
+    acc.tokens += c.tokens();
+  }
 }
 
 /** 字符估算版 token 计数（Anthropic 官方：端点缺失时客户端本来就退回字符估算，精度非目标）。 */

package/src/cli/commands/provider/raccoon-login.js

@@ -1,11 +1,15 @@
 // mslxdff -provider raccoon login — 扫码登录（终端二维码 + 轮询）。
-// 实测该链路匿名可达且**不需要验证码**；成功后落盘 auths/raccoon-<uid>.json（0600）
+// ⚠ 2026-10 上游改版：二维码必须**先由服务端签发**（POST /api/iam/v1/auth/mp/qrcode），
+//   拿到 qrcode_code + scan_path 才能渲染。旧的「本地自造 code」在新通道下没有服务端会话，
+//   微信扫码后查不到该码 → 手机端报「二维码已过期或已被使用」。详见 src/providers/raccoon/login.js。
+// 该链路匿名可达且**不需要验证码**；成功后落盘 auths/raccoon-<uid>.json（0600）
 // 并把兜底目录只增不减补齐进 allowlist（避免「登录成功却处处 403」）。
 import { normalizeProviderId } from "../../../providers/model-id.js";
 import { compatFetch } from "../../../compat.js";
 import {
   buildQrUrl,
-  createQrCode,
+  cancelQrSession,
+  createQrSession,
   fetchRaccoonUserInfo,
   pollQrLogin,
 } from "../../../providers/raccoon/login.js";
@@ -17,6 +21,8 @@ import { claimRaccoonLoginReward, raccoonClaimStatus } from "../../../providers/
 
 const LOGIN_SUBS = new Set(["login", "auth", "oauth"]);
 
+const RELOGIN_HINT = "   （可重试：mslxdff -provider raccoon login）";
+
 export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
   const pid = normalizeProviderId(id) || String(id || "").toLowerCase();
   if (pid !== "raccoon") return false;
@@ -26,9 +32,6 @@ export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
   const log = deps.log || ((m) => console.log(m));
   const exit = deps.exit || ((code) => process.exit(code));
 
-  const code = deps.qrCode || createQrCode();
-  const url = buildQrUrl(code);
-
   log("=".repeat(60));
   log("  Raccoon 登录（商汤小浣熊 · 积分制模型池）");
   log("=".repeat(60));
@@ -37,12 +40,26 @@ export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
   log("  2. 确认后本机自动继续（CLI 轮询，无需回调）");
   log("");
 
+  // 签发二维码：这一步失败就没有可扫的码，必须当场说清楚，不能拿一个假码糊过去
+  let session;
+  try {
+    session = deps.qrSession || await createQrSession({ fetchImpl });
+  } catch (error) {
+    log(`❌ 无法获取二维码：${error?.message ?? error}`);
+    log("   （多为网络不通或上游改版；可重试：mslxdff -provider raccoon login）");
+    exit(1);
+    return true;
+  }
+  const code = deps.qrCode || session.qrcodeCode;
+  const url = deps.qrUrl || buildQrUrl(code, session.scanPath);
+
   const art = renderTerminal(encodeQr(url));
   if (art) {
     log(art);
     log("");
   }
   log(`  登录链接：${url}`);
+  log(`  有效期：${Math.round(session.expiresInMs / 1000)} 秒（过期请重跑本命令）`);
   log("");
   log("🔄 等待扫码确认…");
 
@@ -51,28 +68,26 @@ export async function handleRaccoonLogin(id, sub, rest = [], deps = {}) {
     out = await pollQrLogin(code, {
       fetchImpl,
       sleepFn: deps.sleepFn,
-      intervalMs: deps.intervalMs,
-      timeoutMs: deps.timeoutMs,
+      intervalMs: deps.intervalMs ?? session.pollIntervalMs,
+      timeoutMs: deps.timeoutMs ?? session.expiresInMs,
       onTick: deps.onTick,
     });
   } catch (error) {
     log("");
     log(`❌ 登录失败：${error?.message ?? error}`);
-    log("   （可重试：mslxdff -provider raccoon login）");
+    log(RELOGIN_HINT);
     exit(1);
     return true;
   }
 
-  if (out.status === "canceled") {
-    log("");
-    log("❌ 已在手机端取消登录（未写入任何凭据）");
-    exit(1);
-    return true;
-  }
   if (out.status !== "success") {
+    // 非终态失败：回收服务端会话（失败也不打断），并对每种结局给一句人话
+    await cancelQrSession(code, { fetchImpl });
     log("");
-    log("❌ 登录已超时，请重新运行 login");
-    log("   （可重试：mslxdff -provider raccoon login）");
+    if (out.status === "canceled") log("❌ 已在手机端取消登录（未写入任何凭据）");
+    else if (out.status === "expired") log("❌ 二维码已过期（上游作废了本次会话）");
+    else log("❌ 登录已超时");
+    log(RELOGIN_HINT);
     exit(1);
     return true;
   }

package/src/logs.js

@@ -52,7 +52,17 @@ function keepTailByBytes(text, maxBytes) {
     if (bytes + b > limit) break;
     bytes += b;
   }
-  return lines.slice(i + 1).join("\n");
+  // 至少保留最后一条：单行本身超过 limit 时（超大 detail/堆栈）上面的循环会一路退到第一条内容行之前，
+  // 返回空串 = 整个日志被清空，比截断更糟（一次丢掉全部历史，且看起来像"日志坏了"）。
+  // 判据是「保留结果为空」而不是 `i === lines.length-1`：文件以换行结尾时 split 出来的最后一个元素是
+  // 空串，`lines.length-1` 指向它，与真正的内容行不同（这一处曾写错，实测保底从未生效）。
+  // 宁可让这一条略微超出预算，也要留住"最新发生了什么"。
+  const kept = lines.slice(i + 1).join("\n");
+  if (!kept && lines.length) {
+    const last = lines.filter((l) => l !== "");
+    if (last.length) return last[last.length - 1];
+  }
+  return kept;
 }
 
 function trimIfOversized(file, maxBytes = MAX_BYTES) {

package/src/model-trace.js

@@ -160,7 +160,14 @@ function keepTailByBytes(text, maxBytes) {
     if (bytes + b > limit) break;
     bytes += b;
   }
-  return lines.slice(i + 1).join("\n");
+  // 至少保留最后一条：单行超 limit 时否则返回空串 = 清空整个 trace。
+  // 判据是「结果为空」——文件尾有换行时 split 的最后一个元素是空串，`i === lines.length-1` 判不到内容行。
+  const kept = lines.slice(i + 1).join("\n");
+  if (!kept) {
+    const nonEmpty = lines.filter((l) => l !== "");
+    if (nonEmpty.length) return nonEmpty[nonEmpty.length - 1];
+  }
+  return kept;
 }
 
 export function appendModelTrace(model, entry, { file = modelLogFile(model) } = {}) {

package/src/providers/raccoon/const.js

@@ -10,10 +10,18 @@ export const RACCOON_LLM_PREFIX = "/api/web/llm/v2";
 export const RACCOON_AUTH_PREFIX = "/api/web/auth/v1";
 export const RACCOON_POINTS_PREFIX = "/api/web/points/v1";
 export const RACCOON_DESKTOP_PREFIX = "/api/web/desktop/v1";
+/**
+ * 新一代身份通道前缀（2026-10 上游改版实测）。
+ * 扫码登录已从 `/api/web/auth/v1/login_with_qrcode_code` 迁到这里，契约完全变了：
+ * code 由**服务端签发**（`qr-<uuid>`），并下发 scan_path / expires_in / poll_interval。
+ * 旧的「客户端自造 code」在新通道里没有服务端会话 —— 微信扫码后查不到该码，
+ * 正好表现为「二维码已过期或已被使用」，故整条扫码链路必须走新端点。
+ * ⚠ 信封也不同：这套用 `code: "OK"` 而不是 `code: 0` —— 判成功一律用 isRaccoonOk()。
+ */
+export const RACCOON_IAM_PREFIX = "/api/iam/v1";
 
 export const raccoonModelCatalogUrl = () => `${RACCOON_ORIGIN}${RACCOON_LLM_PREFIX}/model_catalog`;
 export const raccoonChatUrl = () => `${RACCOON_ORIGIN}${RACCOON_LLM_PREFIX}/chat/completions`;
-export const raccoonQrLoginUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/login_with_qrcode_code`;
 export const raccoonRefreshUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/refresh`;
 export const raccoonUserInfoUrl = () => `${RACCOON_ORIGIN}${RACCOON_AUTH_PREFIX}/user_info`;
 export const raccoonBalanceUrl = () => `${RACCOON_ORIGIN}${RACCOON_POINTS_PREFIX}/balance`;
@@ -21,13 +29,26 @@ export const raccoonBillsUrl = (limit = 50) =>
   `${RACCOON_ORIGIN}${RACCOON_POINTS_PREFIX}/bills?paging.limit=${Number(limit) || 50}&paging.offset=0`;
 export const raccoonLoginGrantUrl = () => `${RACCOON_ORIGIN}${RACCOON_DESKTOP_PREFIX}/login/points/grant`;
 
+/** 服务端签发二维码（POST，body 可带 `{ product_codes: [] }`）。 */
+export const raccoonQrCreateUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/auth/mp/qrcode`;
+/** 轮询扫码状态（POST，body `{ qrcode_code }`）。 */
+export const raccoonQrPollUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/auth/mp/qrcode/login`;
+/** 取消二维码（PUT，body `{ qrcode_code, status: "canceled" }`）——过期/离开页面时礼貌回收。 */
+export const raccoonQrCancelUrl = () => `${RACCOON_ORIGIN}${RACCOON_IAM_PREFIX}/auth/mp/qrcode`;
+
 /**
- * 扫码登录深链接：终端编成二维码，**必须用微信「扫一扫」**打开确认（浏览器直接打开会 404）。
- * 形如 `https://xiaohuanxiong.com/login/mp?code=<hex>&appname=商汤小浣熊官网`。
- * 实测：服务器对任意路径都回同一份 SPA 外壳（HTTP 200），但 SPA 路由表里没有 `login/mp`（只有 `login` + 兜底 `*`）→ 浏览器必 404，属正常而非链接失效。
+ * 扫码登录深链接：终端编成二维码，**必须用微信「扫一扫」**打开确认。
+ * code 与 scan_path 都由 `POST /auth/mp/qrcode` 下发（scan_path 实测为 `/login/mp`），
+ * 形如 `https://xiaohuanxiong.com/login/mp?code=qr-xxxx&appname=商汤小浣熊官网&source=platform`。
+ * `source=platform` 来自网站登录页实测（chunk c3.js）：新版网关按它区分扫码来源，缺了会被判非法码。
+ * ⚠ scan_path 是**服务端数据**，拼进 URL 前必须校验（只允许站内单斜杠开头的相对路径），
+ *   否则一个被篡改的响应就能把用户导向任意外站。
  */
-export const raccoonQrPageUrl = (code) =>
-  `${RACCOON_ORIGIN}/login/mp?code=${encodeURIComponent(String(code || ""))}&appname=${encodeURIComponent("商汤小浣熊官网")}`;
+export const raccoonQrPageUrl = (code, scanPath = "/login/mp") => {
+  const path = typeof scanPath === "string" && /^\/[^\s\\#]*$/.test(scanPath) && !scanPath.startsWith("//") ? scanPath : "/login/mp";
+  return `${RACCOON_ORIGIN}${path}?code=${encodeURIComponent(String(code || ""))}`
+    + `&appname=${encodeURIComponent("商汤小浣熊官网")}&source=platform`;
+};
 
 export const RACCOON_DEFAULT_CLIENT_VERSION = "v1.0.35";
 export const RACCOON_CLIENT_PLATFORM = "desktop-windows";

package/src/providers/raccoon/envelope.js

@@ -1,15 +1,23 @@
 // raccoon 上游统一信封：`{ code, message, details, data }`（与 pack.js 的 parseEnvelope 同形）。
-// 约定：code === 0 为成功；HTTP 状态码仅在 code 缺失时兜底（上游错误也可能带 200）。
+// ⚠ 两代通道的成功码不同（2026-10 上游改版）：旧 /api/web/* 用数字 `0`，新 /api/iam/v1/* 用字符串 `"OK"`。
+//   故 `code` 原样保留（数字或字符串），判成功一律走 isRaccoonOk()——**不能**再用 `code === 0`：
+//   字符串码一律不等于 0（把 "OK" 判成失败），而把它兜底成 0 又会把 `AUTH_QRCODE_EXPIRED` 判成成功。
 // 登录态类业务码：200001 未带 token、200003 登录态过期 —— 见 const.js 的 RACCOON_ERROR_KINDS。
 export function parseRaccoonEnvelope(payload, status = 200) {
   const record = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload : {};
-  const code = typeof record.code === "number" ? record.code : status >= 400 ? status : 0;
+  const raw = record.code;
+  const code = typeof raw === "number" || typeof raw === "string" ? raw : status >= 400 ? status : 0;
   const message = typeof record.message === "string" ? record.message : "";
   const details = typeof record.details === "string" ? record.details : "";
   const data = typeof record.data === "object" && record.data !== null && !Array.isArray(record.data) ? record.data : undefined;
   return { code, message, details, data, status };
 }
 
+/** 业务成功判据（两代通道通用）：数字 0，或新 IAM 通道的字符串 "OK"。 */
+export function isRaccoonOk(envelope) {
+  return envelope?.code === 0 || envelope?.code === "OK";
+}
+
 /** 人话错误文本：`message: details`，都没有时用调用方给的兜底句。 */
 export function raccoonEnvelopeText(envelope, fallback = "请求失败") {
   const parts = [envelope?.message, envelope?.details].filter((s) => typeof s === "string" && s.length > 0);

package/src/providers/raccoon/login.js

@@ -1,21 +1,25 @@
 // raccoon 扫码登录状态机与会话续期。
-// 实测依据：`POST /api/web/auth/v1/login_with_qrcode_code` **匿名可达**（HTTP 200 {"code":0,"data":{"status":"pending"}}），
-// 故整条登录链路不需要验证码、不需要浏览器组件（短信登录才要阿里云滑块，本期不做）。
-import { randomBytes } from "node:crypto";
+// ⚠ 2026-10 上游改版（本机实测）：扫码登录**不再是**「客户端自造 code + 旧 web 端点」。
+//   新链路 `/api/iam/v1/auth/mp/qrcode` 里 code 由**服务端签发**（`qr-<uuid>`）并下发
+//   scan_path / expires_in / poll_interval。旧写法（`randomBytes(16)` 当 code）在新通道下
+//   没有服务端会话 —— 微信扫码后查不到该码，症状正是「二维码已过期或已被使用」。
+//   新通道同样匿名可达、不需要验证码，故整条链路仍不需要浏览器组件（短信登录才要滑块，本期不做）。
 import {
   RACCOON_LOGIN_POLL_INTERVAL_MS,
   RACCOON_LOGIN_TIMEOUT_MS,
   RACCOON_REQUEST_TIMEOUT_MS,
-  raccoonQrLoginUrl,
+  raccoonQrCancelUrl,
+  raccoonQrCreateUrl,
   raccoonQrPageUrl,
+  raccoonQrPollUrl,
   raccoonRefreshUrl,
   raccoonUserInfoUrl,
 } from "./const.js";
 import { raccoonAnonymousHeaders, raccoonAuthHeaders } from "./headers.js";
 import { decodeJwtExpMs } from "./auth.js";
-import { parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
+import { isRaccoonOk, parseRaccoonEnvelope, raccoonEnvelopeText } from "./envelope.js";
 
-/** 上游 `data.status` 四态（pack.js RACCOON_QR_STATUS 同形）。 */
+/** 上游 `data.status` 四态（与网站登录页 chunk 实测一致）。 */
 export const RACCOON_QR_STATUS = Object.freeze({
   pending: "pending",
   logging: "logging",
@@ -23,24 +27,17 @@ export const RACCOON_QR_STATUS = Object.freeze({
   success: "success",
 });
 
-/** 一次性登录码：16 字节 hex（32 字符），既是二维码内容参数也是轮询凭据。 */
-export function createQrCode() {
-  return randomBytes(16).toString("hex");
-}
-
-/** 二维码/链接内容：用户用手机扫码或直接打开它完成确认。 */
-export function buildQrUrl(code) {
-  return raccoonQrPageUrl(code);
-}
+/** 码在服务端不存在/已作废时 IAM 通道回的业务码。 */
+export const RACCOON_QR_EXPIRED_CODE = "AUTH_QRCODE_EXPIRED";
 
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
-async function postJson(url, body, { fetchImpl = fetch, env = process.env, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS } = {}) {
+async function postJson(url, body, { fetchImpl = fetch, env = process.env, timeoutMs = RACCOON_REQUEST_TIMEOUT_MS, method = "POST" } = {}) {
   let res;
   try {
     res = await fetchImpl(url, {
-      method: "POST",
-      headers: raccoonAnonymousHeaders({ env }),
+      method,
+      headers: { ...raccoonAnonymousHeaders({ env }), "Accept-Language": "zh-CN" },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(timeoutMs),
     });
@@ -56,6 +53,46 @@ async function postJson(url, body, { fetchImpl = fetch, env = process.env, timeo
   return parseRaccoonEnvelope(parsed, res.status);
 }
 
+/**
+ * 请服务端签发一个二维码会话。
+ *
+ * 返回 `{ qrcodeCode, scanPath, expiresIn, pollInterval, qrUrl }`。
+ * 任何字段不合契约都**抛错**而不是产出降级码 —— 自造 code 正是这次故障的根因，
+ * 再"兜底"一个扫不出来的码等于把同一类故障换个说法。
+ */
+export async function createQrSession(opts = {}) {
+  const envelope = await postJson(raccoonQrCreateUrl(), { product_codes: [] }, opts);
+  if (!isRaccoonOk(envelope)) throw new Error(`raccoon: 二维码签发失败：${raccoonEnvelopeText(envelope)}`);
+  const code = typeof envelope.data?.qrcode_code === "string" ? envelope.data.qrcode_code.trim() : "";
+  if (!code) throw new Error("raccoon: 二维码签发响应缺少 qrcode_code");
+  const scanPath = typeof envelope.data.scan_path === "string" ? envelope.data.scan_path : "/login/mp";
+  const expiresIn = Number(envelope.data.expires_in);
+  const pollInterval = Number(envelope.data.poll_interval);
+  return {
+    qrcodeCode: code,
+    scanPath,
+    expiresInMs: Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1000 : RACCOON_LOGIN_TIMEOUT_MS,
+    pollIntervalMs: Number.isFinite(pollInterval) && pollInterval > 0
+      ? Math.max(1000, Math.min(60_000, pollInterval * 1000))
+      : RACCOON_LOGIN_POLL_INTERVAL_MS,
+    qrUrl: raccoonQrPageUrl(code, scanPath),
+  };
+}
+
+/** 递归渲染用的二维码内容；scanPath 由签发响应给出。 */
+export function buildQrUrl(code, scanPath) {
+  return raccoonQrPageUrl(code, scanPath);
+}
+
+/** 回收服务端会话（过期/退出时调用，失败不影响用户）。 */
+export async function cancelQrSession(code, opts = {}) {
+  try {
+    await postJson(raccoonQrCancelUrl(), { qrcode_code: String(code || ""), status: "canceled" }, { ...opts, method: "PUT" });
+  } catch {
+    // 取消是礼貌动作，不是流程一部分：网络不通时静默即可（码自己会到期）
+  }
+}
+
 /** 从登录成功信封里取凭据；缺 access_token 视为失败（不写半截凭据）。 */
 export function raccoonCredentialFromEnvelope(envelope) {
   const data = envelope?.data ?? {};
@@ -74,32 +111,44 @@ export function raccoonCredentialFromEnvelope(envelope) {
 
 /**
  * 轮询一轮。网络抖动一律折成 `pending`（用户还在扫码，不该因为一次超时把整轮打断）；
- * `canceled` / `success` 是终态。
+ * `canceled` / `expired` / `success` 是终态。
  */
 export async function pollQrLoginOnce(code, opts = {}) {
   let envelope;
   try {
-    envelope = await postJson(raccoonQrLoginUrl(), { qrcode_code: String(code || "") }, opts);
+    envelope = await postJson(raccoonQrPollUrl(), { qrcode_code: String(code || "") }, opts);
   } catch {
     return { status: RACCOON_QR_STATUS.pending };
   }
-  if (envelope.code !== 0 || envelope.data === undefined) return { status: RACCOON_QR_STATUS.pending };
+  if (!isRaccoonOk(envelope)) {
+    // 码在服务端不存在/已作废 —— 必须区分出来：继续轮询只会一直失败，用户却以为还在等扫描
+    if (String(envelope.code) === RACCOON_QR_EXPIRED_CODE) return { status: "expired" };
+    return { status: RACCOON_QR_STATUS.pending };
+  }
+  if (envelope.data === undefined) return { status: RACCOON_QR_STATUS.pending };
   const status = typeof envelope.data.status === "string" ? envelope.data.status : "";
   const expiredAt = typeof envelope.data.expired_at === "string" ? envelope.data.expired_at : undefined;
+  const pollIntervalMs = Number.isFinite(Number(envelope.data.poll_interval)) && Number(envelope.data.poll_interval) > 0
+    ? Number(envelope.data.poll_interval) * 1000
+    : undefined;
+  const jitter = pollIntervalMs === undefined ? {} : { pollIntervalMs };
   if (status === RACCOON_QR_STATUS.canceled) return { status: RACCOON_QR_STATUS.canceled };
-  if (status === RACCOON_QR_STATUS.logging) return { status: RACCOON_QR_STATUS.logging, ...(expiredAt ? { expiredAt } : {}) };
+  if (status === RACCOON_QR_STATUS.logging) return { status: RACCOON_QR_STATUS.logging, ...jitter, ...(expiredAt ? { expiredAt } : {}) };
   if (status === RACCOON_QR_STATUS.success) {
     try {
-      return { status: RACCOON_QR_STATUS.success, credential: raccoonCredentialFromEnvelope(envelope) };
+      return { status: RACCOON_QR_STATUS.success, ...jitter, credential: raccoonCredentialFromEnvelope(envelope) };
     } catch {
-      return { status: RACCOON_QR_STATUS.pending };
+      return { status: RACCOON_QR_STATUS.pending, ...jitter };
     }
   }
-  return { status: RACCOON_QR_STATUS.pending };
+  return { status: RACCOON_QR_STATUS.pending, ...jitter };
 }
 
 /**
- * 轮询直到终态。返回 `{ status, credential? }`；
+ * 轮询直到终态。返回 `{ status, credential? }`。
+ *
+ * `deadlineMs` 用**服务端下发的有效期**（不是本地常量）：码的生死由上游决定，
+ * 本地猜一个更长的窗口只会在码已作废后继续空转，把「已过期」拖成「超时」。
  * 超时返回 `{ status: "timeout" }`（调用方据此输出人话并非零退出）。
  */
 export async function pollQrLogin(code, {
@@ -113,6 +162,7 @@ export async function pollQrLogin(code, {
 } = {}) {
   const deadline = now() + timeoutMs;
   let ticks = 0;
+  let interval = intervalMs;
   for (;;) {
     const result = await pollQrLoginOnce(code, { fetchImpl, env });
     ticks += 1;
@@ -121,8 +171,11 @@ export async function pollQrLogin(code, {
     }
     if (result.status === RACCOON_QR_STATUS.success) return result;
     if (result.status === RACCOON_QR_STATUS.canceled) return { status: RACCOON_QR_STATUS.canceled };
+    if (result.status === "expired") return { status: "expired" };
+    // 服务端可以调快/调慢节奏，以它下发的为准（夹在 1s–60s，防被一个坏值卡住）
+    if (Number.isFinite(result.pollIntervalMs)) interval = Math.max(1000, Math.min(60_000, result.pollIntervalMs));
     if (now() >= deadline) return { status: "timeout" };
-    await sleepFn(intervalMs);
+    await sleepFn(interval);
   }
 }
 
@@ -150,12 +203,13 @@ export async function refreshRaccoonCredential(credential, opts = {}) {
     throw new Error(`raccoon: 续期响应不是 JSON（HTTP ${res.status}）`);
   }
   const envelope = parseRaccoonEnvelope(parsed, res.status);
-  if (res.status === 401 || envelope.code === 200003) {
+  // 登录态失效判据两代都收：旧通道数字 200003，IAM 通道字符串 AUTH_ACCESS_TOKEN_EXPIRED
+  if (res.status === 401 || envelope.code === 200003 || String(envelope.code) === "AUTH_ACCESS_TOKEN_EXPIRED") {
     const err = new Error("raccoon: 登录态已过期，请重新登录");
     err.authExpired = true;
     throw err;
   }
-  if (envelope.code !== 0) throw new Error(`raccoon: 续期失败：${raccoonEnvelopeText(envelope)}`);
+  if (!isRaccoonOk(envelope)) throw new Error(`raccoon: 续期失败：${raccoonEnvelopeText(envelope)}`);
   const accessToken = typeof envelope.data?.access_token === "string" ? envelope.data.access_token : "";
   if (!accessToken) throw new Error("raccoon: 续期响应缺少 access_token");
   const nextRefresh = typeof envelope.data.refresh_token === "string" && envelope.data.refresh_token.length > 0
@@ -181,7 +235,7 @@ export async function fetchRaccoonUserInfo(credential, opts = {}) {
     });
     if (!res.ok) return {};
     const envelope = parseRaccoonEnvelope(await res.json(), res.status);
-    if (envelope.code !== 0 || envelope.data === undefined) return {};
+    if (!isRaccoonOk(envelope) || envelope.data === undefined) return {};
     const pick = (k) => (typeof envelope.data[k] === "string" ? envelope.data[k] : "");
     return {
       userId: pick("id"),

package/src/providers/workbuddy/rotation-log.js

@@ -18,6 +18,33 @@ function defaultDirs() {
   return [...dirs];
 }
 
+// 裁剪保留比例（按字节）。阈值 `st.size` 是**字节**，原先的回退 `content.slice(-512*1024)` 是**字符** ——
+// 量纲不匹配：中文（3 字节/字符）下保留后字节数浮动，且 slice 按字符切会**切在半行**上
+// （实测开头得到 `"el=workbuddy/deepseek totalMs="`，下一行接上去就把日志结构毁了）。
+// 与 logs.js / model-trace.js 同口径：按字节留 3/4，且不截半行。
+const KEEP_RATIO = 3 / 4;
+
+function keepTailByBytes(text, maxBytes) {
+  const limit = Math.max(1, Math.floor(maxBytes * KEEP_RATIO));
+  if (Buffer.byteLength(text) <= limit) return text;
+  const lines = text.split("\n");
+  let bytes = 0;
+  let i = lines.length - 1;
+  for (; i >= 0; i--) {
+    const b = Buffer.byteLength(lines[i]) + 1;
+    if (bytes + b > limit) break;
+    bytes += b;
+  }
+  // 至少保留最后一条：单行超 limit 时否则返回空串 = 清空整个轮转日志。
+  // 判据是「结果为空」——文件尾有换行时 split 的最后一个元素是空串，`i === lines.length-1` 判不到内容行。
+  const kept = lines.slice(i + 1).join("\n");
+  if (!kept) {
+    const nonEmpty = lines.filter((l) => l !== "");
+    if (nonEmpty.length) return nonEmpty[nonEmpty.length - 1];
+  }
+  return kept;
+}
+
 export function appendRotationLog({ uid, model, totalMs, balanceHit, error, clock = Date.now, fs: fsOverride, dirs: dirsOverride, maxBytes = 1024 * 1024 } = {}) {
   // 兼容旧调用：appendRotationLog({uid,model,totalMs,balanceHit,error}) 形式，clock/fs 可选
   const useFs = fsOverride || { appendFileSync, mkdirSync, readFileSync, writeFileSync, statSync, join };
@@ -32,8 +59,9 @@ export function appendRotationLog({ uid, model, totalMs, balanceHit, error, cloc
         try {
           const st = useFs.statSync(file);
           if (st.size > maxBytes) {
-            const content = useFs.readFileSync(file, "utf8");
-            useFs.writeFileSync(file, content.slice(-512 * 1024));
+            // 按字节回退（不截半行），与 logs.js / model-trace.js 同口径。
+            const kept = keepTailByBytes(useFs.readFileSync(file, "utf8"), maxBytes);
+            useFs.writeFileSync(file, kept.endsWith("\n") || !kept ? kept : `${kept}\n`);
           }
         } catch {}
       } catch {}

package/src/responses/translate.js

@@ -89,7 +89,11 @@ export function responsesToChatBody(req = {}) {
       messages.push({ role: "tool", tool_call_id: it.call_id || "", content: typeof it.output === "string" ? it.output : JSON.stringify(it.output ?? "") });
     }
   }
-  if (!messages.length) messages.push({ role: "user", content: "hi" });
+  // 空会话直接抛错，**绝不伪造一句 "hi" 打上游**：那会把假提问写进用户上下文并白烧一发额度。
+  // 口径与 anthropic/request-body.js:83-84 一致（同一仓库同一类场景不该有两套策略）。
+  // 触发面比"空 input"更广：input 里全是未知 item 类型（如 `{type:"unknown_item"}`）时也走这里
+  // —— 静默发一句 hi 会让客户端拿到一个与它请求毫无关系的回答。
+  if (!messages.length) throw new Error("responses: 缺少用户消息");
   const body = { model, messages, stream: Boolean(req.stream) };
   if (Array.isArray(req.tools) && req.tools.length) {
     body.tools = req.tools.map((t) => (t?.type === "function"

package/src/routes/hedge.js

@@ -49,12 +49,19 @@ function makeBufferedBody(chunk, handle, kind) {
   })();
 }
 
+// 逐个调用并各自吞异常：**不能**写成 `await x.cancel().catch(()=>{})` —— 自定义/AI SDK 流
+// 的 cancel() 可能返回 undefined（非 Promise），那种写法会抛 TypeError 并被外层 catch 吞掉，
+// 于是后面的 handle.cancel() 根本不会执行 ⇒ 上游流没被真正取消（实测：bodyCancelled=true、
+// handleCancelled=false）。与 stream-body.js 的 cancelBody 同口径，逐个 `Promise.resolve(...)`。
+// 逐个调用并各自吞异常：**不能**写成 `await x.cancel().catch(()=>{})` —— 自定义/AI SDK 流
+// 的 cancel() 可能返回 undefined（非 Promise），那种写法会抛 TypeError 并被外层 catch 吞掉，
+// 于是后面的 handle.cancel() 根本不会执行 ⇒ 上游流没被真正取消（实测：bodyCancelled=true、
+// handleCancelled=false）。与 stream-body.js 的 cancelBody 同口径，逐个 `Promise.resolve(...)`。
 async function cancelBody(body, handle, kind) {
-  try {
-    if (body && typeof body.cancel === "function") await body.cancel().catch(() => {});
-    if (kind === "web" && handle && typeof handle.cancel === "function") await handle.cancel().catch(() => {});
-    else if (handle && typeof handle.return === "function") await handle.return().catch(() => {});
-  } catch {}
+  const settle = async (fn) => { try { await Promise.resolve(fn()); } catch { /* ignore */ } };
+  if (body && typeof body.cancel === "function") await settle(() => body.cancel());
+  if (kind === "web" && handle && typeof handle.cancel === "function") await settle(() => handle.cancel());
+  else if (handle && typeof handle.return === "function") await settle(() => handle.return());
 }
 
 function getFirstChunkPromise(body) {

package/src/routes/stream-hold.js

@@ -9,6 +9,7 @@
 // 都必须先把 [DONE] 暂扣住**（tail 槽），否则错误永不可见、还会留下两个终止符。
 // 拆出原因：这些策略与 relay 本体同处一文件会破仓库 20KB 硬门，且语义本就独立（不碰上游读取与闸门计时）。
 import { json } from "./helpers.js";
+import { isTrivialFrame } from "./stream-scan.js";
 
 // 暂扣上限：正常空轮的前缀就是几帧空 delta + 一个 [DONE]；超过即说明不是这个形状，别为它囤内存。
 export const HOLD_MAX_FRAMES = 64;
@@ -137,27 +138,77 @@ export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES
     try { res.write(t.buf); } catch { /* 下游已断开 */ }
     return true; // 告诉收场方：[DONE] 已经由这一帧发出去了，别再补第二个
   };
+  /**
+   * 暂扣一帧。终止帧进 tail 槽（无论是否已提交）；否则进 pending（未提交时可整段撤销）。
+   * 返回 false = pending 超上限放不下，调用方必须改为提交，别默默丢字节。
+   *
+   * **必须自己拼 carry**：上一块的半截终止行扣在 carry 里，本块就是它的续块。若让调用方分别处理，
+   * 两块会走各自的路径（carry 被收场 `flushCarry` 补一个换行 → 终止帧被拆成两行、客户端认不出终止符），
+   * 更糟的是**本块会因「不含 data:」被判成非空帧而被迫提交**，直接摧毁空轮留口（BUG-40 实测：
+   * 空轮 + `[DONE]` 被 TCP 切两块时 heldOpen 由 true 变 false、wrotePayload 由 false 变 true，
+   * 救援静默失效）。拼接是字节流的本分：carry 之后紧跟的必然是该行的续字节。
+   */
+  function holdFrame(buf, size) {
+    let b = buf;
+    if (carry) {
+      // 只有「本块恰好补完那个终止行」才该拼；否则 carry 里是上一块**残缺的一行**，
+      // 必须按序先放出去（writeNow 会补换行），硬拼会把它与本帧粘成 `data: [DOdata: {...` ——
+      // 非法行，客户端认不出终止符（实测终止符数=0）。已提交时更是如此：此时本帧要直写。
+      const joined = Buffer.concat([toBuf(carry.buf) ?? Buffer.alloc(0), toBuf(buf) ?? Buffer.alloc(0)]);
+      if (committed && !splitTrailingDone(joined) && doneLinePrefix(joined) === 0) {
+        writeNow(buf, size); // writeNow 内部先 flushCarry（带换行），帧序与行完整性都保住
+        return true;
+      }
+      b = joined;
+      carry = null;
+      size = b.length;
+    }
+    // 本块夹带终止帧：头段照常走本函数，终止帧扣进 tail（行锚定，正文里的字面量不算）
+    const sp = splitTrailingDone(b);
+    if (sp) {
+      if (sp.head.length && !holdFrame(sp.head, sp.head.length)) return false;
+      if (tail) flushTail();
+      tail = { buf: sp.rest, size: sp.rest.length };
+      return true;
+    }
+    // 尾部是终止行前缀（终止帧被 TCP 切开）：扣住等下一块拼上再判
+    const pl = doneLinePrefix(b);
+    if (pl > 0) {
+      const head = b.subarray(0, b.length - pl);
+      if (head.length && !holdFrame(head, head.length)) return false;
+      const keep = pl < b.length ? b.subarray(b.length - pl) : b;
+      carry = { buf: keep, size: keep.length };
+      return true;
+    }
+    if (committed) { writeNow(b, size); return true; }
+    if (pending.length >= maxFrames || pendingBytes + size > maxBytes) return false;
+    pending.push({ buf: b, size });
+    pendingBytes += size;
+    return true;
+  }
   return {
     get committed() { return committed; },
     get heldFrames() { return pending.length + (tail ? 1 : 0); },
+    hold: holdFrame,
     /**
-     * 暂扣一帧。isDone=true 的帧进 tail 槽（无论是否已提交）；否则进 pending（未提交时可整段撤销）。
-     * 返回 false = pending 超上限放不下，调用方必须改为提交，别默默丢字节。
+     * 本块是否仍属「可撤销前缀」——必须连同 carry 一起判，且**半截终止行本身也算**。
+     * 只看本块会漏两种：① 续块（`NE]\n\n`）自身不含 `data:`，`isTrivialFrame` 必判 false；
+     * ② 首块（`data: [DO`）自身是半个终止帧，JSON 解析失败也判 false。两者都会让调用方走 submit
+     * 提交、留口失效（BUG-40）。凡尾部是终止行前缀的一律按可暂扣处理：它会进 carry 等下一块。
      */
-    hold(buf, size, isDone = false) {
-      if (isDone) {
-        // 半截终止行若还扣着（上一块尾部像终止行前缀、本块却是独立完整终止帧），必须先放出去：
-        // 直接塞进 tail 会让它和 [DONE] 粘成 `data: [DOdata: [DONE]` —— 非法行，客户端认不出终止符（实测数=0）。
-        if (carry) flushCarry();
-        if (tail) flushTail();
-        tail = { buf, size };
-        return true;
+    isTrivial(txt) {
+      const t = Buffer.from(String(txt ?? ""), "utf8");
+      // 尾部是终止行前缀（`data: [DO`）：它是**残缺的一行**，会被扣进 carry 等续块，本身不含模型产出。
+      // 不认它就会走 submit 提交、留口失效（BUG-40）。这一判必须在有无 carry 时都跑——首块通常无 carry。
+      if (doneLinePrefix(t) > 0) return true;
+      if (carry) {
+        const joined = Buffer.concat([toBuf(carry.buf) ?? Buffer.alloc(0), t]);
+        // carry 是**上一块残缺的一行**，只有本块恰好补完它（成为完整终止帧，或仍是其前缀）才算续块。
+        // 否则本块与 carry 无关（如半截行后跟一个独立空帧）：按序先放 carry、本块单独判，
+        // 硬拼会把两个无关的帧粘成非法行。
+        if (doneLinePrefix(joined) > 0 || splitTrailingDone(joined)) return true;
       }
-      if (committed) { writeNow(buf, size); return true; }
-      if (pending.length >= maxFrames || pendingBytes + size > maxBytes) return false;
-      pending.push({ buf, size });
-      pendingBytes += size;
-      return true;
+      return isTrivialFrame(t.toString("utf8"));
     },
     /**
      * 提交：按序补写 pending（不含 tail），再写本帧，此后一律直写。

package/src/routes/stream-scan.js

@@ -80,10 +80,7 @@ function talkConsumeLine(talk, raw, glued = false) {
 // 多一个属性就是日志噪音），也不随 detail 的展开/复制丢失统计口径。
 const tcIndexes = new WeakMap();
 
-/**
- * 工具调用去重计数：同一 `index` 的多个分片只算一次。
- * 分片缺 `index` 字段时退回 0（OpenAI 规范不要求每个 arguments 分片都重复 index）。
- */
+/** 工具调用去重计数：同一 `index` 的多个分片只算一次；分片缺 `index` 时退回 0。 */
 function countToolCalls(detail, txt) {
   if (!detail || typeof detail !== "object") return;
   let seen = tcIndexes.get(detail);
@@ -136,9 +133,32 @@ export function captureTalkFallback(talk, text) {
   talkPush(talk, "content", String(text));
 }
 
+// 判据必须跑在**完整行**上：TCP 会把一帧切两块，`"finish_reason"`/`"content"` 被切在中间时正则永不命中
+// ⇒ sawFinishReason 恒 null（正常结束的流被 endTruncatedStream 误判成截断，向客户端写假 STREAM_TRUNCATED）、
+// chars 归零（chatShaped 为真时正好命中空轮判据）。与 BUG-24/25 同型：那次是终止标记被切块，这次是观测层缺行缓冲。
+const scanRemain = new WeakMap();
+const SCAN_REMAIN_MAX = 1_000_000; // 半行上限：超限按完整行处理，宁可错判也不无界吃内存
+
+/** 流收场回收：末尾无换行的残行按同一口径扫一次，否则末帧的 finish_reason 永远读不到。幂等。 */
+export function flushScanRemainder(detail) {
+  if (!detail || typeof detail !== "object") return;
+  const rest = scanRemain.get(detail);
+  if (!rest) return;
+  scanRemain.delete(detail);
+  scanCompleteText(detail, rest);
+}
+
 // 逐 SSE chunk 扫描：done/finish_reason/chat 形状/工具调用/usage/正文字符
 export function scanSseChunk(detail, txt) {
   if (detail.talk) { try { captureTalkSse(detail.talk, txt); } catch {} } // 纯旁路红线：捕获异常绝不外溢成转发失败（review P2-7：旧调用点裸奔在 try 外只是口头契约）
+  let buf = (scanRemain.get(detail) || "") + String(txt ?? "");
+  const rest = buf.slice(buf.lastIndexOf("\n") + 1);
+  if (rest.length > SCAN_REMAIN_MAX) { scanRemain.set(detail, ""); }
+  else { buf = buf.slice(0, buf.length - rest.length); scanRemain.set(detail, rest); }
+  if (buf) scanCompleteText(detail, buf);
+}
+
+function scanCompleteText(detail, txt) {
   try {
     if (txt.includes("[DONE]")) detail.sawDone = true;
     const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);

package/src/routes/stream.js

@@ -1,7 +1,7 @@
 import { performance } from "node:perf_hooks";
 import { applyFallbackHeaders } from "./fallback.js";
 import { json } from "./helpers.js";
-import { scanSseChunk, preflightMs, createTalkBucketIfEnabled, captureTalkFallback, isEmptyTurnDetail, holdableChunk, isTrivialFrame } from "./stream-scan.js"; // 逐帧观测累加器 + 锚点偏移 + 对话正文 + 空轮判据 + 错误包络暂扣 + 可撤销前缀判据（纯函数与建桶判据全在 stream-scan）
+import { scanSseChunk, flushScanRemainder, preflightMs, createTalkBucketIfEnabled, captureTalkFallback, isEmptyTurnDetail, holdableChunk } from "./stream-scan.js"; // 逐帧观测累加器 + 锚点偏移 + 对话正文 + 空轮判据 + 错误包络暂扣（纯函数与建桶判据全在 stream-scan；可撤销判据走 prefix.isTrivial）
 import { holdEndEnabled, createRevocablePrefix, endEmptyTurnStream, endTruncatedStream, flushPrefixTail } from "./stream-hold.js"; // 空轮可撤销前缀 / 延后封口 / 终局收场（拆出去是为了不破 stream.js 20KB 硬门）
 import { chunkText, cancelBody, hasPayload, bodyChunks, enrichFirstReply, scanNonStreamReply } from "./stream-body.js"; // 读取层工具（字节→文本 / 取消上游 / 注释帧判定 / 自持 reader 迭代 / 首块富化 / 非流式先判后写），为让本文件退回 20KB 以内而拆出
 
@@ -233,15 +233,16 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
               // 注释帧等非数据帧：与改前一致直写（客户端视作噪声，不影响可撤销性）
               wroteAny = true;
               prefix.writeNow(outChunk, size);
-            } else if (gained || !revocableHold || !isTrivialFrame(txt)) {
-              // 有模型产出（正文/工具/思考）、留口已关、或看不懂的异形帧：按序补写暂扣前缀 + 本帧，
-              // 这条流就此提交不可撤销（透传契约要求解析失败的帧必须原样走，绝不为救空轮扣下）
+            } else if (gained || !revocableHold || !prefix.isTrivial(txt)) {
+              // 有模型产出、留口已关、或看不懂的异形帧：按序补写暂扣前缀 + 本帧，此流就此提交不可撤销
+              //（透传契约：解析失败的帧必须原样走，绝不为救空轮扣下）。
+              // 可撤销判定走 prefix.isTrivial 而非裸 isTrivialFrame：半截终止行扣在 prefix 的 carry 里，
+              // 只看本块会把它的续块判成非空，留口静默失效（BUG-40）。
               wroteAny = true;
               wrotePayload = true; detail.wrotePayload = true;
               prefix.submit(outChunk, size);
-            } else if (!prefix.hold(outChunk, size, txt.includes("[DONE]"))) {
-              // 可撤销前缀：空 delta 暂扣（判为空轮时整段撤销，留给重拉的正文）；
-              // [DONE] 无论是否已提交都进 tail 槽 —— 错误帧必须能排在它前面，否则客户端一见 [DONE] 就收尾
+            } else if (!prefix.hold(outChunk, size)) {
+              // 可撤销前缀按序暂扣（[DONE] 进 tail 槽让位给错误帧；终止帧识别收进 prefix，见 holdFrame）
               wroteAny = true;
               wrotePayload = true; detail.wrotePayload = true;
               prefix.submit(outChunk, size); // 暂扣超上限（异常形状）→ 被迫提交，退回旧行为
@@ -260,6 +261,9 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
         if (maxTimer) clearTimeout(maxTimer);
         if (stallTimer) clearTimeout(stallTimer);
         if (pingTimer) clearInterval(pingTimer);
+        // 末帧常无收尾换行：不回收残行，切块/缺换行的 finish_reason 就永远读不到，
+        // 下面所有依赖它的判定（截断收场、空轮判据）全都会被带偏。
+        try { flushScanRemainder(detail); } catch { /* 观测旁路：绝不外溢成转发失败 */ }
       }
       // 任一闸门到点且未写出真实数据 → 可安全 failover（注释帧对客户端无意义，不算已响应）
       if ((timedOut || stalled || tooLong) && !wrotePayload) {

package/src/upstream-engine/sdk/sse.js

@@ -38,6 +38,8 @@ export function createSseSerializer(captured = null) {
   let nextIndex = 0;
   const toolIndex = new Map();
   const toolDeltaIds = new Set();
+  // 「当前正在流式输入的工具」的 index：无 id 的 tool-input-delta 靠它归位（见该 case 的注释）
+  let lastToolIdx = null;
   // 加密思考往返：reasoning-start 的 providerMetadata 带 itemId + 加密态，随首帧透出
   let reasoningMeta = null;
   let reasoningFrameSent = false;
@@ -104,18 +106,30 @@ export function createSseSerializer(captured = null) {
         const idx = nextIndex++;
         toolIndex.set(part.id, idx);
         toolDeltaIds.add(part.id);
+        lastToolIdx = idx;   // 后续无 id 的 delta 归到这个工具
         return ensureRole() + frame({
           tool_calls: [{ index: idx, id: part.id, type: "function", function: { name: part.toolName || "", arguments: "" } }],
         });
       }
       case "tool-input-delta": {
-        const idx = toolIndex.has(part.id) ? toolIndex.get(part.id) : 0;
+        // 未知 id **绝不能回退到 index 0**：那会把这段参数写进另一个工具（实测：callA 占 index 0 时，
+        // 一个 id 丢失的 delta 让 funcA 的参数变成 `{"hijack":true}`），客户端会拿着被污染的参数去调用
+        // 错误的函数。改为按 `tool-call` 分支的口径分配新 index —— 宁可多一个空工具槽，也不污染已有工具。
+        // 无 id 的 delta 属于「当前正在流式输入的那个工具」：复用上一次用过的 index。
+        // 每个都分配新 index 会把一段参数拆成多个工具（实测：无 id 的 `{"a":` 与 `1}` 分别落到
+        // index 1 和 2，两个都是非法 JSON）—— 比旧代码的「都落 index 0」更糟。
+        let idx;
+        if (part.id && toolIndex.has(part.id)) idx = toolIndex.get(part.id);
+        else if (!part.id && lastToolIdx != null) idx = lastToolIdx;   // 无 id：沿用当前工具
+        else { idx = nextIndex++; if (part.id) toolIndex.set(part.id, idx); }
+        lastToolIdx = idx;
         return frame({ tool_calls: [{ index: idx, function: { arguments: String(part.delta ?? "") } }] });
       }
       case "tool-call": {
         const id = part.toolCallId;
         const idx = toolIndex.has(id) ? toolIndex.get(id) : nextIndex++;
         toolIndex.set(id, idx);
+        lastToolIdx = idx;   // 同 tool-input-start：后续无 id 的 delta 归到这个工具
         if (toolDeltaIds.has(id)) return null;
         const args = typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {});
         return ensureRole() + frame({ tool_calls: [{ index: idx, id, type: "function", function: { name: part.toolName || "", arguments: args } }] });