mslxdff 0.1.186 → 0.1.188

package/src/routes/responses-route.js

@@ -50,6 +50,34 @@ export function createCollector() {
   return { res, get: () => ({ status, text }) };
 }
 
+/**
+ * 纯错误帧直通判定（垫片 write 的前置拦截）：整段只含 `data:` 行、且每帧都是
+ * `{error:{…}}` 形状（无 `choices`）时，返回原样 SSE 帧数组；否则返回 null（交翻译器）。
+ * 为什么必须拦：翻译器只认 chat 帧（choices.delta），错误帧会被它静默 `continue` 掉。
+ */
+function passthroughErrorFrames(text) {
+  const src = String(text ?? "");
+  if (!src.includes("data:")) return null;
+  const out = [];
+  let sawError = false;
+  for (const rawLine of src.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith(":")) { out.push(`${line}\n\n`); continue; } // 注释帧照原样（翻译器也是跳过）
+    if (!line.startsWith("data:")) return null;
+    const payload = line.slice(5).trim();
+    if (!payload) continue;
+    if (payload === "[DONE]") { out.push("data: [DONE]\n\n"); continue; }
+    let j;
+    try { j = JSON.parse(payload); } catch { return null; } // 解析失败 = 不是我们的错误帧，交翻译器（它自会记 jsonFails）
+    if (!j || typeof j !== "object" || Array.isArray(j) || j.choices) return null; // 有 choices = chat 帧，绝不拦
+    if (!j.error) return null; // 无 choices 又无 error：形状未知，交翻译器
+    sawError = true;
+    out.push(`data: ${JSON.stringify(j)}\n\n`);
+  }
+  return sawError ? out : null;
+}
+
 // 流式：逐 write 实时翻译并转发（head 延迟到首块，避免错误状态码已发送）
 export function createLiveForwarder(realRes, translator) {
   let status = 200;
@@ -61,16 +89,30 @@ export function createLiveForwarder(realRes, translator) {
     realRes.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
     for (const e of translator.begin()) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
   };
+  // headersSent 必须是**计算值**：垫片的 write() 会调 sendHead() 真发头，若 headersSent 仍是普通属性
+  // （只在 end() 里置真），则「头已发但流未结束」这段窗口里它为假 ⇒ helpers.json() 会走 `!headersSent`
+  // 分支去 setHeader+end（而本垫片 setHeader 是 no-op、且真头已发）⇒ 错误体静默丢失、只剩裸关流。
+  // messages-route 的 createAnthropicForwarder 早已用 getter 实现并点名了同一个坑；本处是同契约的遗漏。
+  // 口径与 messages-route 的 createAnthropicForwarder 逐字对齐（哪里算「头已发」只此一处判）。
+  const sent = () => headSent || realRes.headersSent === true;
   const res = {
     ...createEmitter(),
     set statusCode(v) { status = v; },
     get statusCode() { return status; },
-    headersSent: false,
+    get headersSent() { return sent(); },
+    set headersSent(_v) { /* 兼容旧赋值点：真实状态由 headSent/ended 推导，不接受外部覆写 */ },
+    getHeader(k) { return String(k).toLowerCase() === "content-type" && sent() ? "text/event-stream" : undefined; },
     setHeader() {},
     write(c) {
       if (ended) return true;
       sendHead();
-      for (const e of translator.push(chunkToString(c))) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
+      const text = chunkToString(c);
+      // 纯错误帧直写：helpers.json() 的 in-band 收场写的是 OpenAI 形状 `{error:{…}}`（无 choices），
+      // 若交给 chat→responses 翻译器，会被当作「非 chat 帧」静默忽略（translate.js 只认 choices.delta）——
+      // 错误在翻译层被吞掉，客户端只看到流被关。错误帧与 chat 帧形状互斥，故这里拦下直通。
+      const errOut = passthroughErrorFrames(text);
+      if (errOut != null) { for (const chunk of errOut) realRes.write(chunk); return true; }
+      for (const e of translator.push(text)) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
       return true;
     },
     end(c) {

package/src/routes/stream-body.js

@@ -0,0 +1,84 @@
+// relay 的读取层工具（从 stream.js 拆出：HEAD 版已 19.8KB / 20KB 硬门，先拆后写）。
+// 全部是「不碰闸门、不碰 res、不碰计时」的纯 IO 适配：字节→文本、取消上游、注释帧判定、读取迭代。
+// 语义与拆出前逐字一致 —— 这里只搬家，不改行为。
+import { enrichSseChunkText, enrichNonStreamJson as enrichNonStreamJsonFn } from "./fallback.js";
+import { extractUsageFromSseText as extractUsageFn } from "../metrics.js";
+import { scanNonStreamBody as scanNonStreamBodyFn } from "./stream-scan.js";
+
+// SDK 通道（TextEncoder）产出 Uint8Array，legacy 通道为 Buffer；
+// 统一转文本，避免 [DONE]/finish_reason/usage/chars 统计在 SDK 路径下静默失效。
+export function chunkText(chunk) {
+  if (typeof chunk === "string") return chunk;
+  if (Buffer.isBuffer(chunk)) return chunk.toString("utf8");
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString("utf8");
+  return "";
+}
+
+// body.cancel() 可能返回非 Promise（自定义/AI SDK 流）——同步异常与 rejection 双路径都要吞掉
+export function cancelBody(body) {
+  try {
+    const p = typeof body?.cancel === "function" ? body.cancel() : null;
+    if (p && typeof p.catch === "function") p.catch(() => {});
+  } catch { /* ignore */ }
+}
+
+// 注释帧（": keepalive" 等）不是模型输出：不算首块、不解除闸门、不触发超时救回，但照常透传
+export function hasPayload(text) {
+  for (const line of String(text).split("\n")) {
+    const t = line.trim();
+    if (!t || t.startsWith(":")) continue;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * 非流式的「先判后写」：在 headers 还没 flush 之前解析上游体，决定能不能富化 / 是不是空轮。
+ * 返回 { enriched, emptyTurn }：enriched=null 表示上游给的不是可解析 JSON（调用方走原文透传）；
+ * emptyTurn=true 表示这一发是空轮、且留口是开的（调用方沿用留口语义，不写任何响应）。
+ * 纯搬家：行为与拆出前逐字一致。
+ */
+export function scanNonStreamReply(detail, text, { fallback, holdEnd, isEmptyTurn, captureFallback }) {
+  let enriched = null;
+  try {
+    const parsed = JSON.parse(text);
+    scanNonStreamBodyFn(detail, parsed);
+    enriched = enrichNonStreamJsonFn(parsed, fallback);
+  } catch { /* 上游给的不是可解析 JSON：调用方走原文透传 */ }
+  if (enriched === null) {
+    // 纯文本时按长度估 chars；若文本其实是 SSE（client 未要流但上游给流）仍尝试提 usage
+    try { detail.chars = text.length; } catch {}
+    try { const u = extractUsageFn(text); if (u) detail.usage = u; } catch {}
+    try { if (detail.talk) captureFallback(detail.talk, text); } catch {}
+    return { enriched: null, emptyTurn: false };
+  }
+  const emptyTurn = Boolean(holdEnd() && !detail.downstreamClosed && isEmptyTurn(detail));
+  return { enriched, emptyTurn };
+}
+
+// 上游回的是普通 reply（无流式 delta）时，客户端仍要看到增量：把整块按 fallback 富化成 SSE 帧。
+// 只在首块前、且本轮尚未写出 payload 时调用一次；解析不出就原样返回（绝不改字节）。
+export function enrichFirstReply(chunk, fallback) {
+  if (!fallback?.fallback) return chunk;
+  try {
+    const txt = chunkText(chunk);
+    if (!txt.includes("data:")) return chunk;
+    const enriched = enrichSseChunkText(txt, fallback);
+    return enriched !== txt ? Buffer.from(enriched, "utf8") : chunk;
+  } catch {
+    return chunk;
+  }
+}
+
+// 自持 reader 优先：for-await 会锁定 ReadableStream，使 body.cancel() 必 reject（真流上等于空操作），
+// 超时/断下游要真能掐上游必须走 reader.cancel()
+export async function* bodyChunks(body, reader) {
+  if (reader) {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  }
+  for await (const c of body) yield c;
+}

package/src/routes/stream-hold.js

@@ -14,6 +14,63 @@ import { json } from "./helpers.js";
 export const HOLD_MAX_FRAMES = 64;
 export const HOLD_MAX_BYTES = 32 * 1024;
 
+/**
+ * 把一个 chunk 里夹带的 `[DONE]` 终止帧切下来：返回 { head, rest }，head = 该帧之前的全部字节，
+ * rest = 从 `data: [DONE]` 那一行的行首到 chunk 末尾。
+ *
+ * 为什么必须在 submit 之前切：网络 chunk 边界与 SSE 帧边界**无关**（TCP 分段事实），上游常把末个
+ * 内容帧与 `data: [DONE]` 一次 flush 送进同一个 chunk。这种帧若整体直写，`[DONE]` 就抢在错误帧
+ * 之前到达客户端 —— 客户端一见 `[DONE]` 即收尾，截断错误帧永远看不见（BUG-17 的修复在这类形态下
+ * 完全失效），且收场还会因为 tail 槽空着而补出第二个 `[DONE]`。故 `[DONE]` 必须扣进 tail 槽，
+ * 由 flushTail 决定它的最终时机（错误帧之后）。
+ *
+ * 必须**行锚定**：正文里出现字面量 `[DONE]`（本仓域内很常见——讨论 SSE 的对话）绝不能误判成终止帧，
+ * 故只认「整行 trims 后等于 `data: [DONE]`」。扫描走 latin1（1 字节↔1 字符），索引与字节一一对应，
+ * 不受多字节字符切分影响。
+ */
+function toBuf(buf) {
+  if (typeof buf === "string") return Buffer.from(buf, "utf8");
+  if (Buffer.isBuffer(buf)) return buf;
+  if (buf instanceof Uint8Array) return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+  return null;
+}
+const DONE_LINE_RE = /(^|\n)[ \t]*data:[ \t]*\[DONE\][ \t]*\r?(?=\n|$)/g;
+function splitTrailingDone(buf) {
+  const b = toBuf(buf);
+  if (!b) return null;
+  const s = b.toString("latin1");
+  DONE_LINE_RE.lastIndex = 0;
+  let last = null;
+  for (let m; (m = DONE_LINE_RE.exec(s)); ) last = m; // 取最后一个终止帧行
+  if (!last) return null;
+  const head = last.index + (last[1] === "\n" ? 1 : 0);
+  return { head: b.subarray(0, head), rest: b.subarray(head) };
+}
+
+/**
+ * 这个 chunk 的**最后一个未结束行**像不像 `data: [DONE]` 的半截？
+ *
+ * 上面的行锚定只解决「完整终止帧与正文同 chunk」，解决不了**终止帧自己被 TCP 切开**
+ * （`…data: [DO` | `NE]\n\n` 两个 chunk）。这种形态下行锚定永远匹配不到 ⇒ 终止符照样
+ * 抢先于错误帧、收场照样补出第二个 `[DONE]`（实测复现）。故凡尾部是终止行前缀的，
+ * 先扣住等下一块拼上再判；下一块到齐后发现不是终止帧，立刻原样放行。
+ *
+ * 只认「去掉行首空白后是 `data: [DONE]` 的字面前缀」，且长度有上限（半个帧不会很长），
+ * 避免把普通正文尾巴扣住。
+ */
+const MAX_DONE_LINE_LEN = 32;
+function doneLinePrefix(buf) {
+  const s = buf.toString("latin1");
+  const nl = s.lastIndexOf("\n");
+  const tail = s.slice(nl + 1); // 最后一个 \n 之后 = 本 chunk 未结束的那一行
+  if (!tail || tail.length > MAX_DONE_LINE_LEN) return 0;
+  const t = tail.replace(/^[ \t]+/, "").toLowerCase().replace(/[ \t]+/g, " ");
+  if (!t) return 0;
+  // `data: [DONE]` 与 `data:[DONE]` 两种空白写法都可能是上游形式
+  if ("data: [done]".startsWith(t) || "data:[done]".startsWith(t)) return Buffer.byteLength(tail, "latin1");
+  return 0;
+}
+
 // 空轮「延后封口 + 前缀暂扣」总开关（默认开）。0/off/false = 关：连缓冲都不做，流一结束立即 end()，
 // 逐字节复现改前行为（代价：之后的空轮重拉/换候选写的是一次已终结的响应，只省额度、救不回正文）。
 export function holdEndEnabled() {
@@ -32,14 +89,35 @@ export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES
   let pending = [];
   let pendingBytes = 0;
   let tail = null;      // [DONE] 槽：必须最后写，且要让位给错误帧
+  let carry = null;     // 半截 `data: [DONE]` 行：等下一块拼上再判（见 doneLinePrefix）
   let committed = false;
   let draining = false;
+  let inCarryFlush = false;
   const writeNow = (buf, size) => {
+    // carry 是**先到**的字节：任何直写都必须等它先出，否则下游看到乱序帧。
+    // 之前只有 submit() 自己消化 carry，hold() 的两个分支与注释帧直写都绕过了它（实测确认）。
+    if (!inCarryFlush && carry) flushCarry();
     if (!draining && tail) flushTail(); // 保持帧序：先补已暂扣的 [DONE]，再写新到的
     detail.wroteChunks += 1;
     detail.wroteBytes += size;
     try { res.write(buf); } catch { /* 下游已断开：onClose 已掐上游 */ }
   };
+  /**
+   * 放行扣着的半截行。它若没以换行结尾**必须补一个** —— 否则随后的错误帧 / `[DONE]` 会粘在同一行上
+   * （`data: [DOdata: [DONE]`）：既不是合法 SSE 行、客户端也认不出终止符（实测终止符数=0，比多一个更糟）。
+   */
+  const flushCarry = () => {
+    if (!carry) return false;
+    const c = carry;
+    carry = null;
+    const endsWithNl = c.size > 0 && c.buf[c.size - 1] === 0x0a;
+    const b = endsWithNl
+      ? (toBuf(c.buf) ?? Buffer.alloc(0))
+      : Buffer.concat([toBuf(c.buf) ?? Buffer.alloc(0), Buffer.from("\n", "utf8")]);
+    inCarryFlush = true;
+    try { writeNow(b, b.length); } finally { inCarryFlush = false; }
+    return true;
+  };
   const drainPending = () => {
     draining = true;
     try {
@@ -68,6 +146,9 @@ export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES
      */
     hold(buf, size, isDone = false) {
       if (isDone) {
+        // 半截终止行若还扣着（上一块尾部像终止行前缀、本块却是独立完整终止帧），必须先放出去：
+        // 直接塞进 tail 会让它和 [DONE] 粘成 `data: [DOdata: [DONE]` —— 非法行，客户端认不出终止符（实测数=0）。
+        if (carry) flushCarry();
         if (tail) flushTail();
         tail = { buf, size };
         return true;
@@ -78,12 +159,45 @@ export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES
       pendingBytes += size;
       return true;
     },
-    /** 提交：按序补写 pending（不含 tail），再写本帧，此后一律直写。 */
+    /**
+     * 提交：按序补写 pending（不含 tail），再写本帧，此后一律直写。
+     * 夹带的 `[DONE]` 先切进 tail 槽：chunk 边界≠帧边界，末个内容帧常与 `[DONE]` 同 chunk 到达，
+     * 整体直写会让终止符抢先于截断错误帧（见 splitTrailingDone）。
+     */
     submit(buf, size) {
       committed = true;
       drainPending();
-      writeNow(buf, size);
+      // 上一块末尾扣着半个终止帧行：先拼上，整帧判过再决定去留
+      let b = buf;
+      if (carry) {
+        const joined = Buffer.concat([carry.buf, toBuf(buf) ?? Buffer.alloc(0)]);
+        b = joined;
+        carry = null;
+      }
+      const sp = splitTrailingDone(b);
+      if (sp) {
+        if (sp.head.length) writeNow(sp.head, sp.head.length);
+        if (tail) flushTail(); // 极端：本帧前已有暂扣的 [DONE]，保序先补
+        tail = { buf: sp.rest, size: sp.rest.length };
+        return;
+      }
+      // 尾部是终止行前缀（终止帧被 TCP 切开）：扣住等下一块，别让它抢先入下游
+      const pl = doneLinePrefix(b);
+      if (pl > 0 && pl < b.length) {
+        const keep = b.subarray(b.length - pl);
+        const head = b.subarray(0, b.length - pl);
+        if (head.length) writeNow(head, head.length);
+        carry = { buf: keep, size: keep.length };
+        return;
+      }
+      if (pl > 0) { carry = { buf: b, size: b.length }; return; } // 整块就是半截行
+      writeNow(b, b.length);
     },
+    /**
+     * 收场兜底：扣着的半截行（若上游就此断了，它就是最后一帧）必须原样放出去，不能吞字节。
+     * 补换行的理由见模块内 flushCarry。
+     */
+    flushCarry,
     /** 收尾前补写 pending；tail 留给 flushTail 决定时机（错误帧要先站上去）。 */
     commit() {
       committed = true;
@@ -94,6 +208,16 @@ export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES
   };
 }
 
+/**
+ * 收场时按到达顺序放行暂扣内容：先放半截终止行（carry），再放 `[DONE]`（tail）。
+ * 两段都在 prefix 里，故调用方只需要一个函数——顺序不能反：carry 是先到的字节。
+ * @returns {boolean} true = `[DONE]` 确实由这次调用写出去（收场方别再补第二个）
+ */
+export function flushPrefixTail(prefix) {
+  try { prefix.flushCarry(); } catch { /* ignore */ }
+  try { return !!prefix.flushTail(); } catch { return false; }
+}
+
 /**
  * 终局收场：把响应「恰好一次」关掉，形状必须与已经发出去的东西相容。
  * - headers 未 flush → 502 JSON（干净的 OpenAI 形错误）；
@@ -122,13 +246,37 @@ export function endEmptyTurnStream(res, message, flushTail) {
   return closeSseWithError(res, String(message || "EMPTY_MODEL_RESPONSE: empty turn"), flushTail);
 }
 
+/**
+ * 截断收场（判据 + 收场一起，供 relay 的断流分支一行调用）。
+ *
+ * 触发形态：流已写出真实内容、却**从未收到上游的终止标记**（`sawFinishReason=null`）就被中断
+ * —— 超时腰斩、上游连接断、`upstream-error` 都走这里。旧行为只补一个 `[DONE]` 再按 200 成功返回，
+ * 于是客户端既无错误帧也无 finish_reason，**分不出「答完了」与「被砍断」**，会把半截回答当完整结果
+ * 继续用（比直接报错更危险）；calls.log 也把这次事故记成一次成功的慢请求。
+ * 现网取证：300s 腰斩 2012 块 / 416KB 输出，errors.log 零记录、calls.log 记 200。
+ *
+ * 收场形状与空轮一致（错误帧 → 原 [DONE] → end），type 另标以便客户端区分两种失败。
+ * @returns {boolean} true = 已按「截断」收场；false = 流本来就有终止标记，调用方照旧补 [DONE]
+ */
+export function endTruncatedStream(res, detail, flushTail) {
+  if (!res || res.writableEnded) return false;
+  if (detail?.sawFinishReason) return false; // 上游交代过结局，不算截断
+  const d = detail || {};
+  const why = d.upstreamError || d.exitReason || "stream ended";
+  const msg = `STREAM_TRUNCATED: 上游在收到 ${d.receivedChunks || 0} 块 / ${d.receivedBytes || 0} 字节后中断，`
+    + `未发出 finish_reason（${why}）— 回答可能在半途被截断`;
+  if (detail) { detail.truncated = true; detail.exitReason = "truncated"; detail.upstreamErrorText = d.upstreamErrorText || msg; }
+  closeSseWithError(res, msg, flushTail, "mslxdff_truncated");
+  return true;
+}
+
 /**
  * SSE 收场：错误帧 → 上游原 [DONE]（若被暂扣过）→ end。
  * 铁律：终止符只能有一个，且必须排在错误帧之后 —— 否则客户端在错误帧到达前就已收尾。
  */
-function closeSseWithError(res, msg, flushTail) {
+function closeSseWithError(res, msg, flushTail, type = "mslxdff_empty_turn") {
   try {
-    res.write(`data: ${JSON.stringify({ error: { message: msg, type: "mslxdff_empty_turn" } })}\n\n`);
+    res.write(`data: ${JSON.stringify({ error: { message: msg, type } })}\n\n`);
   } catch { /* 下游已断：收不到是它的权利 */ }
   let emittedDone = false;
   try { emittedDone = typeof flushTail === "function" ? !!flushTail() : false; } catch { /* ignore */ }

package/src/routes/stream-scan.js

@@ -76,6 +76,29 @@ function talkConsumeLine(talk, raw, glued = false) {
   }
 }
 
+// 已见工具调用 index：按 detail 对象存进 WeakMap，既不污染 detail（它会被序列化进 events/模型日志，
+// 多一个属性就是日志噪音），也不随 detail 的展开/复制丢失统计口径。
+const tcIndexes = new WeakMap();
+
+/**
+ * 工具调用去重计数：同一 `index` 的多个分片只算一次。
+ * 分片缺 `index` 字段时退回 0（OpenAI 规范不要求每个 arguments 分片都重复 index）。
+ */
+function countToolCalls(detail, txt) {
+  if (!detail || typeof detail !== "object") return;
+  let seen = tcIndexes.get(detail);
+  if (!seen) { seen = new Set(); tcIndexes.set(detail, seen); }
+  const re = /"tool_calls"\s*:\s*\[\s*\{/g;
+  let m;
+  while ((m = re.exec(txt))) {
+    // 从 tool_calls 数组起点往后取第一个 index（choices[].index 在此位置之前，不会误取）
+    const after = txt.slice(m.index + m[0].length - 1);
+    const im = after.match(/"index"\s*:\s*(\d+)/);
+    seen.add(im ? Number(im[1]) : 0);
+  }
+  if (seen.size) detail.toolCalls = seen.size;
+}
+
 /** 逐 chunk 累积一轮对话的思考/正文/工具调用。talk 为空 = 未开启，直接返回。跨 chunk 行缓冲见文件头。 */
 export function captureTalkSse(talk, txt) {
   if (!talk) return;
@@ -124,8 +147,10 @@ export function scanSseChunk(detail, txt) {
     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;
+    // 口径按 `index` 去重：流式 tool_calls 的 arguments 是**分片**到达的，每个分片都含
+    // `"tool_calls":[{"index":N,...` ⇒ 按命中次数累加会把一次调用计成 N 次（实测 4894/5999 帧命中，
+    // 虚高数千倍，且与 scanNonStreamBody 的 `.length` 口径不一致）。去重后与非流式同义。
+    countToolCalls(detail, txt);
     // 尝试提取 usage（流式末帧）：口径收口到 metrics.js，与未流式分支共用
     if (txt.includes("\"usage\"") || txt.includes("\"prompt_tokens\"")) {
       try {