mslxdff 0.1.159 → 0.1.161

package/src/routes/helpers.js

@@ -18,10 +18,26 @@ export function authorized(req, token) {
 }
 
 export function json(res, status, body) {
-  res.statusCode = status;
-  // 已发 headers（如 failover 时前一个候选写过 SSE 注释帧）不可再设，否则抛 ERR_HTTP_HEADERS_SENT
-  try { if (!res.headersSent) res.setHeader("Content-Type", "application/json"); } catch { /* ignore */ }
-  res.end(JSON.stringify(body));
+  // 幂等守卫：已收场的响应必须 no-op（空轮 hold 后多处共用收场出口，二次 end 会抛）
+  if (!res || res.writableEnded) return;
+  if (!res.headersSent) {
+    res.statusCode = status;
+    try { res.setHeader("Content-Type", "application/json"); } catch { /* ignore */ }
+    try { res.end(JSON.stringify(body)); } catch { /* ignore */ }
+    return;
+  }
+  // headers 已 flush（failover 前候选写过 SSE 注释帧、或空轮 hold 期间发过 keepalive）：
+  // 设 statusCode 会抛 ERR_HTTP_HEADERS_SENT，写 JSON 体更会把 application/json 混进 text/event-stream
+  // （客户端只会当噪声丢掉，等于悄悄吞掉错误）。SSE 一律改用 in-band 错误帧 + [DONE] 收场。
+  const ct = typeof res.getHeader === "function" ? String(res.getHeader("content-type") || "") : "";
+  if (ct.includes("text/event-stream")) {
+    try {
+      const msg = body && typeof body === "object" ? String(body.error ?? body.message ?? JSON.stringify(body)) : String(body ?? "error");
+      res.write(`data: ${JSON.stringify({ error: { message: msg, type: "mslxdff_error" } })}\n\n`);
+      res.write("data: [DONE]\n\n");
+    } catch { /* 下游已断 */ }
+  }
+  try { res.end(); } catch { /* ignore */ }
 }
 
 export function notFound(res) {

package/src/routes/stream-hold.js

@@ -0,0 +1,138 @@
+// 空轮的可挽救性策略（relay 的三个问题在这里回答，stream.js 只负责转发循环）：
+//   ① 哪些帧还能撤销？—— 一次尝试在「出现任何模型产出」之前写下去的只有空 delta 帧与 [DONE]，
+//      这些字节一旦入下游就撤不回（重拉的正文会接在一个已完成的流后面），所以一律暂扣；
+//      攒爆上限（异常形状）才被迫提交，行为退回改前。
+//   ② 撤销窗口留不留？—— 流结束仍零产出且下游还活着 → 不 res.end()，把这次尝试交回同模型重拉 /
+//      换候选，让后面那发的正文还能顺着同一条连接送出去。
+//   ③ 全部救不回来怎么收场？—— 恰好一次、形状与已发出的字节相容（见 endHeldFailure / endEmptyTurnStream）。
+// 另有一条次序铁律：`[DONE]` 是流的终点，客户端解析器一见它就收尾 —— 所以**任何要补在它前面的错误帧
+// 都必须先把 [DONE] 暂扣住**（tail 槽），否则错误永不可见、还会留下两个终止符。
+// 拆出原因：这些策略与 relay 本体同处一文件会破仓库 20KB 硬门，且语义本就独立（不碰上游读取与闸门计时）。
+import { json } from "./helpers.js";
+
+// 暂扣上限：正常空轮的前缀就是几帧空 delta + 一个 [DONE]；超过即说明不是这个形状，别为它囤内存。
+export const HOLD_MAX_FRAMES = 64;
+export const HOLD_MAX_BYTES = 32 * 1024;
+
+// 空轮「延后封口 + 前缀暂扣」总开关（默认开）。0/off/false = 关：连缓冲都不做，流一结束立即 end()，
+// 逐字节复现改前行为（代价：之后的空轮重拉/换候选写的是一次已终结的响应，只省额度、救不回正文）。
+export function holdEndEnabled() {
+  const s = String(process.env.MSLXDFF_EMPTY_TURN_HOLD_END ?? "").trim().toLowerCase();
+  return !(s === "0" || s === "off" || s === "false");
+}
+
+/**
+ * 可撤销前缀缓冲。帧分三类：
+ *  - 注释帧（非数据帧）：直写，不影响可撤销性（客户端视作噪声）；
+ *  - 可撤销前缀（空 delta / finish-only 帧）：暂扣，出现模型产出时按序补写；
+ *  - `[DONE]`：即使已提交也暂扣在 tail 槽，直到确认没有错误帧要补在它前面。
+ * 记账（detail.wroteChunks/wroteBytes）由本模块负责，调用方不必自己数字节。
+ */
+export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES, maxBytes = HOLD_MAX_BYTES } = {}) {
+  let pending = [];
+  let pendingBytes = 0;
+  let tail = null;      // [DONE] 槽：必须最后写，且要让位给错误帧
+  let committed = false;
+  let draining = false;
+  const writeNow = (buf, size) => {
+    if (!draining && tail) flushTail(); // 保持帧序：先补已暂扣的 [DONE]，再写新到的
+    detail.wroteChunks += 1;
+    detail.wroteBytes += size;
+    try { res.write(buf); } catch { /* 下游已断开：onClose 已掐上游 */ }
+  };
+  const drainPending = () => {
+    draining = true;
+    try {
+      for (const p of pending) writeNow(p.buf, p.size);
+    } finally {
+      draining = false;
+    }
+    pending = [];
+    pendingBytes = 0;
+  };
+  const flushTail = () => {
+    if (!tail) return false;
+    const t = tail;
+    tail = null;
+    detail.wroteChunks += 1;
+    detail.wroteBytes += t.size;
+    try { res.write(t.buf); } catch { /* 下游已断开 */ }
+    return true; // 告诉收场方：[DONE] 已经由这一帧发出去了，别再补第二个
+  };
+  return {
+    get committed() { return committed; },
+    get heldFrames() { return pending.length + (tail ? 1 : 0); },
+    /**
+     * 暂扣一帧。isDone=true 的帧进 tail 槽（无论是否已提交）；否则进 pending（未提交时可整段撤销）。
+     * 返回 false = pending 超上限放不下，调用方必须改为提交，别默默丢字节。
+     */
+    hold(buf, size, isDone = false) {
+      if (isDone) {
+        if (tail) flushTail();
+        tail = { buf, size };
+        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;
+    },
+    /** 提交：按序补写 pending（不含 tail），再写本帧，此后一律直写。 */
+    submit(buf, size) {
+      committed = true;
+      drainPending();
+      writeNow(buf, size);
+    },
+    /** 收尾前补写 pending；tail 留给 flushTail 决定时机（错误帧要先站上去）。 */
+    commit() {
+      committed = true;
+      drainPending();
+    },
+    flushTail,
+    writeNow,
+  };
+}
+
+/**
+ * 终局收场：把响应「恰好一次」关掉，形状必须与已经发出去的东西相容。
+ * - headers 未 flush → 502 JSON（干净的 OpenAI 形错误）；
+ * - headers 已 flush（hold 期间发过 keepalive 注释帧，状态码锁死 200 text/event-stream）
+ *   → SSE 错误帧 + [DONE]：绝不把 JSON 体混进 event-stream，也绝不抛 ERR_HTTP_HEADERS_SENT。
+ * 错误文案带 EMPTY_MODEL_RESPONSE 前缀（与 errors.log / isEmptyTurnError 判据同源，可 grep 对账）。
+ */
+export function endHeldFailure(res, message, flushTail) {
+  if (!res || res.writableEnded) return false;
+  const msg = String(message || "EMPTY_MODEL_RESPONSE: empty turn, no recovery");
+  if (!res.headersSent) {
+    // headers 都没发出去 ⇒ 这一发的暂扣帧全部作废（它们属于失败的那一发，客户端从没收到）
+    json(res, 502, { error: msg });
+    return true;
+  }
+  return closeSseWithError(res, msg, flushTail);
+}
+
+/**
+ * 已经提交过内容、但正文为零的流（现网主流：思考刷满 max_tokens）：错误帧必须排在
+ * 上游的 `[DONE]` **之前**，否则客户端一见 [DONE] 就收尾，原因永不可见。
+ * flushTail = 把暂扣的 [DONE] 补写出去（由调用方在错误帧之后、end() 之前触发）。
+ */
+export function endEmptyTurnStream(res, message, flushTail) {
+  if (!res || res.writableEnded) return false;
+  return closeSseWithError(res, String(message || "EMPTY_MODEL_RESPONSE: empty turn"), flushTail);
+}
+
+/**
+ * SSE 收场：错误帧 → 上游原 [DONE]（若被暂扣过）→ end。
+ * 铁律：终止符只能有一个，且必须排在错误帧之后 —— 否则客户端在错误帧到达前就已收尾。
+ */
+function closeSseWithError(res, msg, flushTail) {
+  try {
+    res.write(`data: ${JSON.stringify({ error: { message: msg, type: "mslxdff_empty_turn" } })}\n\n`);
+  } catch { /* 下游已断：收不到是它的权利 */ }
+  let emittedDone = false;
+  try { emittedDone = typeof flushTail === "function" ? !!flushTail() : false; } catch { /* ignore */ }
+  if (!emittedDone) { try { res.write("data: [DONE]\n\n"); } catch { /* ignore */ } }
+  try { res.end(); } catch { /* ignore */ }
+  return true;
+}

package/src/routes/stream-scan.js

@@ -0,0 +1,278 @@
+// relay 的观测累加器：把流式 SSE chunk / 非流式 JSON 体读成 detail 上的计数事实。
+// 抽自 src/routes/stream.js（单文件 20KB 硬门，见 AGENTS.md「先拆后写」），行为与抽出前逐字一致。
+// 纯函数契约：只读写传入的 detail，不碰 res / 定时器 / 闸门 / 网络，因此可离线单测。
+// 语义钉子：detail.chars 只算正文，思考内容另计（reasoningChars）——两者相加会重复计数。
+import { extractUsageFromJson } from "../metrics.js";
+
+// 环形对话日志（talk log）的正文捕获：只有 relay 建了 detail.talk 才累积，未开启时零开销。
+// 口径与 chars/reasoningChars 同源（读 delta，不读聚合帧），区别是这里存原文而不是只计数。
+// 同样的边界：SSE 帧被 chunk 切断时该帧内容丢失（JSON.parse 失败即跳过）—— 研究用途可接受。
+const TALK_CAP_CHARS = 400_000;
+
+function talkPush(talk, dst, v) {
+  if (typeof v !== "string" || !v) return;
+  if (talk.n >= TALK_CAP_CHARS) { talk.capped = true; return; }
+  talk.n += v.length;
+  talk[dst].push(v);
+}
+
+// 流式 tool_calls 是分片到达的（index 定位、arguments 逐段拼），按 index 合回完整调用才看得懂。
+function talkMergeToolCalls(talk, tcs) {
+  for (const tc of tcs) {
+    const i = Number.isInteger(tc?.index) ? tc.index : talk.tools.length;
+    let slot = talk.tools[i];
+    if (!slot) { slot = { id: "", type: "function", function: { name: "", arguments: "" } }; talk.tools[i] = slot; }
+    if (tc.id) slot.id = tc.id;
+    const nm = tc.function?.name;
+    const ar = tc.function?.arguments;
+    if (typeof nm === "string" && nm && !slot.function.name.includes(nm)) slot.function.name += nm;
+    if (typeof ar === "string" && ar) slot.function.arguments += ar;
+  }
+}
+
+/** 新建累积桶（n/capped 防超长生成把内存吃穿）。 */
+export function createTalkBucket() { return { reasoning: [], content: [], tools: [], n: 0, capped: false }; }
+
+/** 逐 chunk 累积一轮对话的思考/正文/工具调用。talk 为空 = 未开启，直接返回。 */
+export function captureTalkSse(talk, txt) {
+  if (!talk) return;
+  for (const raw of String(txt ?? "").split("\n")) {
+    const t = raw.trim();
+    if (!t.startsWith("data:")) continue;
+    const d = t.slice(5).trim();
+    if (!d || d === "[DONE]") continue;
+    let j = null;
+    try { j = JSON.parse(d); } catch { continue; }
+    const c0 = Array.isArray(j?.choices) ? j.choices[0] : null;
+    if (!c0) continue;
+    for (const src of [c0.delta, c0.message]) {
+      if (!src) continue;
+      talkPush(talk, "reasoning", src.reasoning_content ?? src.reasoning);
+      talkPush(talk, "content", src.content);
+      if (Array.isArray(src.tool_calls)) talkMergeToolCalls(talk, src.tool_calls);
+    }
+  }
+}
+
+/** 非流式：整块 message 直接入桶（tool_calls 参数本来就是完整的）。 */
+export function captureTalkMessage(talk, msg) {
+  if (!talk || !msg) return;
+  talkPush(talk, "reasoning", msg.reasoning_content ?? msg.reasoning);
+  talkPush(talk, "content", msg.content);
+  if (Array.isArray(msg.tool_calls)) talkMergeToolCalls(talk, msg.tool_calls);
+}
+
+/** 透传兜底：无 chat 帧可解析（纯文本/未知形状）时把原文当正文收下，别让对话日志留空洞。 */
+export function captureTalkFallback(talk, text) {
+  if (!talk || !text) return;
+  if (talk.reasoning.length || talk.content.length || talk.tools.length) return;
+  if (String(text).includes('"choices"')) return;
+  talkPush(talk, "content", String(text));
+}
+
+// 逐 SSE chunk 扫描：done/finish_reason/chat 形状/工具调用/usage/正文字符
+export function scanSseChunk(detail, txt) {
+  if (detail.talk) captureTalkSse(detail.talk, txt);
+  try {
+    if (txt.includes("[DONE]")) detail.sawDone = true;
+    const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);
+    if (m) detail.sawFinishReason = m[1];
+    // chat 形状证据：只有看得出是 chat 轮才配判空（非 chat SSE/JSON 透传是正式契约，不得误伤）
+    if (!detail.chatShaped && (txt.includes('"choices"') || txt.includes('"delta"') || txt.includes('"finish_reason"') || txt.includes('"usage"') || txt.includes('"prompt_tokens"') || txt.includes("[DONE]"))) detail.chatShaped = true;
+    // 工具调用计数（空数组不算）：tool_calls 无正文是合法 agent 轮，
+    // 空转闸门必须豁免它，否则所有工具轮都会被误判为空轮——见 relay-pipeline 4b。
+    const tc = txt.match(/"tool_calls"\s*:\s*\[\s*\{/g);
+    if (tc) detail.toolCalls = (detail.toolCalls || 0) + tc.length;
+    // 尝试提取 usage（流式末帧）：口径收口到 metrics.js，与未流式分支共用
+    if (txt.includes("\"usage\"") || txt.includes("\"prompt_tokens\"")) {
+      try {
+        const lines = txt.split("\n");
+        for (const line of lines) {
+          const t = line.trim();
+          if (!t.startsWith("data:")) continue;
+          const d = t.slice(5).trim();
+          if (d === "[DONE]" || !d) continue;
+          // 行级隔离：单行坏 JSON 不拖累同 chunk 其余行
+          try {
+            const j = JSON.parse(d);
+            if (!j || typeof j !== "object") continue;
+            const u = extractUsageFromJson(j);
+            if (u) detail.usage = u;
+            // 兜底 chars：从 choices 文本长度累加
+            const delta = j.choices?.[0]?.delta?.content || j.choices?.[0]?.message?.content || "";
+            if (delta) detail.chars += String(delta).length;
+            const rc = j.choices?.[0]?.delta?.reasoning_content || j.choices?.[0]?.delta?.reasoning
+              || j.choices?.[0]?.message?.reasoning_content || j.choices?.[0]?.message?.reasoning || "";
+            if (rc) detail.reasoningChars = (detail.reasoningChars || 0) + String(rc).length;
+          } catch { /* 单行坏帧忽略 */ }
+        }
+      } catch {}
+    } else {
+      // 非 usage 的普通 delta 也累 chars
+      try {
+        const ms = txt.match(/"content"\s*:\s*"([^"]*)"/g);
+        if (ms) for (const mm of ms) {
+          const c = JSON.parse(`{${mm}}`);
+          if (c.content) detail.chars += String(c.content).length;
+        }
+        // 同一 chunk 里的思考增量：键名两种上游都见过（reasoning_content / reasoning）
+        const rs = txt.match(/"reasoning(?:_content)?"\s*:\s*"([^"]*)"/g);
+        if (rs) for (const mm of rs) {
+          const c = JSON.parse(`{${mm}}`);
+          const v = c.reasoning_content ?? c.reasoning;
+          if (v) detail.reasoningChars = (detail.reasoningChars || 0) + String(v).length;
+        }
+      } catch {}
+    }
+  } catch { /* ignore */ }
+}
+
+// 非流式聚合 JSON 体：同源口径提 usage/chars/chat 形状/工具调用
+export function scanNonStreamBody(detail, parsed) {
+  const u = extractUsageFromJson(parsed);
+  if (u) detail.usage = u;
+  if (parsed.choices?.[0]?.message?.content) detail.chars = String(parsed.choices[0].message.content).length;
+  else if (parsed.choices?.[0]?.text) detail.chars = String(parsed.choices[0].text).length;
+  // 思考内容另记（qoder 的 stream:false 出口把思考放在 message.reasoning_content）
+  const rc = parsed.choices?.[0]?.message?.reasoning_content || parsed.choices?.[0]?.message?.reasoning || "";
+  if (rc) detail.reasoningChars = (detail.reasoningChars || 0) + String(rc).length;
+  // 非流式同样只判 chat 形状：无 choices 的任意 JSON 是透传契约（chat-route 单测锁死），不得判空
+  if (Array.isArray(parsed?.choices)) detail.chatShaped = true;
+  const _tcList = parsed.choices?.[0]?.message?.tool_calls;
+  if (Array.isArray(_tcList) && _tcList.length) detail.toolCalls = _tcList.length;
+  if (detail.talk) captureTalkMessage(detail.talk, parsed.choices?.[0]?.message || (parsed.choices?.[0]?.text ? { content: parsed.choices[0].text } : null));
+}
+
+// 上报锚点偏移：转发入口时刻 − 本次上游尝试起点（performance.now 同源）。
+// 只服务上报时长（usage 行），四类保护闸门仍用 relay 自己的 t0，绝不引用它。
+export function preflightMs(t0, attemptStartMs) {
+  // 锚点必须是与 t0 同源（performance.now）的有限 number；其余一律按「无锚点」降级为 0，
+  // 宁可退回修复前口径，也不能产出 NaN 或假高值
+  if (typeof attemptStartMs !== "number" || !Number.isFinite(attemptStartMs)) return 0;
+  const delta = Math.round(t0 - attemptStartMs);
+  return delta > 0 ? delta : 0;
+}
+
+/**
+ * 空轮判据（纯函数，唯一真相）：看得 chat 形状 + 零正文 + 零工具调用 + 收尾不是工具轮。
+ * stream.js 用它决定「这次要不要封口」，relay-pipeline 用它决定「交不交回重试」——两处不得各写一份。
+ * chatShaped 是前置证据：非 chat SSE / 无 choices 的透传是正式契约，一律放行不判空。
+ */
+export function isEmptyTurnDetail(d) {
+  if (!d || d.chatShaped !== true) return false;
+  if ((Number(d.chars) || 0) > 0 || (Number(d.toolCalls) || 0) > 0) return false;
+  if (["tool_calls", "function_call"].includes(d.sawFinishReason)) return false;
+  return true;
+}
+
+// ===== 从 stream.js 迁入（体积门：stream.js 承载 relay 本体，纯判定函数一律住这里）=====
+
+// 错误包络 chunk 判定（纯函数）：data 行 JSON 含顶层 .error 对象、或只有 finish_reason=error
+// 的空帧，且整 chunk 无任何 content/tool_calls/reasoning 输出 → 返回错误摘要（建议暂扣），
+// 否则返回 null（透传）。解析失败一律透传（默认保安全）。
+// 背景：网关把上游失败包成 HTTP 200 SSE；暂扣后下游流式 UI 不再展示瞬时错误
+//（如 Vertex 503 + google fallback 400），本轮走空转重试，客户端只看到最终结果。
+// Note: 流内错误包络捕获与 retryAfterSeconds 错误直出 — 见 .agents/notes/implemented/bug-fix/2026-09-28-retry-after-surfacing-error.md
+export function extractRetryAfterSec(obj) {
+  if (!obj) return null;
+  if (typeof obj === "number") return obj;
+  if (typeof obj === "string") {
+    const m = obj.match(/"retryAfterSeconds"\s*:\s*(\d+)/i) || obj.match(/\bretryAfterSeconds\s*[:=]\s*(\d+)/i);
+    if (m) return Number(m[1]);
+    try {
+      const parsed = JSON.parse(obj);
+      return extractRetryAfterSec(parsed);
+    } catch {}
+  }
+  if (typeof obj === "object") {
+    if (Number.isFinite(obj.retryAfterSeconds)) return Number(obj.retryAfterSeconds);
+    if (obj.message) {
+      const r = extractRetryAfterSec(obj.message);
+      if (r != null) return r;
+    }
+  }
+  return null;
+}
+
+export function holdableChunk(txt) {
+  if (typeof txt !== "string" || !txt.includes("data:")) return null;
+  let sawData = false;
+  let sawEventError = false;
+  let retrySec = null;
+  const errs = [];
+  for (const rawLine of txt.split("\n")) {
+    const t = rawLine.trim();
+    if (t.startsWith("event:") && t.slice(6).trim() === "error") {
+      sawEventError = true;
+      continue;
+    }
+    if (!t.startsWith("data:")) continue;
+    const d = t.slice(5).trim();
+    if (!d || d === "[DONE]") continue;
+    let j = null;
+    try { j = JSON.parse(d); } catch { return null; }
+    if (!j || typeof j !== "object") return null;
+    sawData = true;
+    const c0 = (Array.isArray(j.choices) && j.choices[0]) || {};
+    const delta = c0.delta || {};
+    const msg = c0.message || {};
+    const out = delta.content || msg.content || delta.tool_calls || msg.tool_calls || delta.reasoning || msg.reasoning;
+    if (out && !(Array.isArray(out) && out.length === 0)) return null;
+
+    const r = extractRetryAfterSec(j);
+    if (r != null) {
+      retrySec = r;
+      continue;
+    }
+    if (j.error && typeof j.error === "object") {
+      const m = j.error.message || j.error.code || "";
+      if (m) errs.push(String(m).slice(0, 300));
+    } else if (sawEventError && j.message) {
+      errs.push(String(j.message).slice(0, 300));
+    } else if (c0.finish_reason === "error") {
+      errs.push("finish_reason=error 空帧");
+    }
+  }
+  if (!sawData) return null;
+  if (retrySec != null) return `上游供应商触发 retryAfterSeconds: ${retrySec} ，请等候重试`;
+  if (errs.length) return errs.join(" | ");
+  if (sawEventError) return "event: error 空帧";
+  return null;
+}
+
+/**
+ * 「可撤销前缀」判据（纯函数）：这个 chunk 里除空 delta 帧与 [DONE] 外不含任何信息吗？
+ * 只有答案为是才允许暂扣不写——透传是正式契约：解析失败的帧、看不懂的形状一律立即透传（与
+ * holdableChunk 同一口径：默认保安全，绝不因为想救空轮而扣掉本该原样转给客户端的字节）。
+ */
+export function isTrivialFrame(txt) {
+  if (typeof txt !== "string" || !txt.includes("data:")) return false;
+  let sawData = false;
+  for (const rawLine of txt.split("\n")) {
+    const t = rawLine.trim();
+    if (!t.startsWith("data:")) continue;
+    const d = t.slice(5).trim();
+    if (!d) continue;
+    if (d === "[DONE]") { sawData = true; continue; } // 结束符不含模型输出，可撤销
+    let j = null;
+    try { j = JSON.parse(d); } catch { return false; } // 解析失败 → 透传，绝不撤销
+    if (!j || typeof j !== "object" || Array.isArray(j)) return false;
+    // 白名单式可撤销：只认「choices 数组、且其中没有任何文本载荷」的 chat 帧。
+    // 其余形状（choices[].text、delta.text、顶层 usage、无 choices 的自定义帧……）一律算有信息 → 透传。
+    if (!Array.isArray(j.choices)) return false;
+    sawData = true;
+    if (j.choices.some((c) => c && typeof c === "object" && (c.text || c.message?.text))) return false;
+    for (const c of j.choices) {
+      if (!c || typeof c !== "object") return false;
+      for (const src of [c.delta, c.message]) {
+        if (!src || typeof src !== "object") continue;
+        for (const [k, v] of Object.entries(src)) {
+          if (k === "role" || k === "index" || k === "function_call_name") continue; // 无信息骨架字段
+          if (v == null || v === "") continue;
+          if (Array.isArray(v) ? v.length > 0 : true) return false; // 任何非空载荷都算产出
+        }
+      }
+    }
+  }
+  return sawData;
+}