mslxdff 0.1.160 → 0.1.161

package/src/providers/workbuddy/reshape.js

@@ -1,152 +1,152 @@
-// workbuddy 流式 reasoning_content 整形：上游思考模型（如 glm-5.3-flash）把思考过程一词一 chunk
-// 地放进 delta.reasoning_content，客户端会把每个增量渲染成独立 "- Thought" 条目。
-// 旧版：连续 reasoning 增量缓冲到首个 content/finish 才一次性 flush → 思考期 10~30s 界面完全无变化（用户看到 workbuddy 后台流量走但 opencode 界面卡住）
-// 新版：增量聚合 + 阈值分片：缓冲 reasoning，达到 REASONING_CHUNK_SIZE（默认 100 字符）即分片 flush，
-// 期间仅首个 role 帧透传保持 TTFB，其余纯 reasoning 空帧吞掉（之前会透传 800+ 空 role 帧）；
-// 尾段不足阈值的在 content/finish/流结束时兜底 flush。恒空 reasoning（deepseek-v4-flash）零改写。
-// 仅包 workbuddy 出口的 SSE 响应，不影响其他供应商与全局聚合器。
-
-const REASONING_CHUNK_SIZE = 150;
-
-export function reshapeWorkbuddySse(res) {
-  try {
-    const ct = res.headers?.get?.("content-type") || "";
-    if (res.status !== 200 || !ct.includes("text/event-stream") || !res.body) return res;
-  } catch { return res; }
-
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buf = "";
-  let reasoningBuf = "";
-  let lastMeta = null;
-  let closed = false;
-  let hasSentRole = false;
-  let lastFlushAt = Date.now();
-
-  function flushReasoningInto(out) {
-    if (!reasoningBuf) return;
-    const meta = lastMeta || {};
-    out.push(`data: ${JSON.stringify({
-      id: meta.id || "chatcmpl-workbuddy-reshape",
-      object: meta.object || "chat.completion.chunk",
-      created: meta.created || Math.floor(Date.now() / 1000),
-      model: meta.model || "",
-      choices: [{ index: 0, delta: { reasoning_content: reasoningBuf }, finish_reason: null }],
-    })}\n\n`);
-    reasoningBuf = "";
-    lastFlushAt = Date.now();
-  }
-
-  let blankStreak = false;
-  // 处理一段完整行文本（以 \n 结尾），产出的行/帧推进 out（连续空行合并为单个事件分隔）
-  function processInto(text, out) {
-    for (const line of text.split("\n")) {
-      if (!line) { if (!blankStreak) out.push("\n"); blankStreak = true; continue; }
-      blankStreak = false;
-      if (!line.startsWith("data:")) { out.push(line + "\n"); continue; }
-      const payload = line.slice(5).trim();
-      if (!payload || payload === "[DONE]") { out.push(line + "\n"); continue; }
-      let obj;
-      try { obj = JSON.parse(payload); } catch { out.push(line + "\n"); continue; }
-      const ch = obj.choices?.[0];
-      if (ch && typeof ch === "object") {
-        if (obj.id) lastMeta = { id: obj.id, model: obj.model, object: obj.object, created: obj.created };
-        const d = ch.delta && typeof ch.delta === "object" ? ch.delta : null;
-        const rc = d ? d.reasoning_content : undefined;
-        if (typeof rc === "string" && rc) {
-          reasoningBuf += rc;
-          d.reasoning_content = "";
-          const isBoundary = (typeof d.content === "string" && d.content) || !!ch.finish_reason;
-          // 首个 reasoning 帧的 role 透传一次，保 TTFB；后续纯 reasoning 的 role 重复帧直接吞掉
-          if (!hasSentRole && d.role !== undefined) {
-            hasSentRole = true;
-            const rm = lastMeta || obj;
-            out.push(`data: ${JSON.stringify({
-              id: rm.id || obj.id || "chatcmpl-workbuddy-reshape",
-              object: rm.object || obj.object || "chat.completion.chunk",
-              created: rm.created || obj.created || Math.floor(Date.now() / 1000),
-              model: rm.model || obj.model || "",
-              choices: [{ index: 0, delta: { role: d.role }, finish_reason: null }],
-            })}\n\n`);
-          } else if (d.role !== undefined) {
-            // 后续重复 role 帧不再透传，避免 800+ 空帧洪泛
-            // 标记已发送过，避免后续非 reasoning 帧再误判为首次
-            hasSentRole = true;
-          }
-          // 阈值分片：攒够 100 字符即向前吐一块，期间界面可见增量而非全程静默
-          // 时间阈值：若距上次 flush 已超 700ms 且已攒 20+ 字符，也吐一块（避免小尾巴长时间不更新）
-          const now = Date.now();
-          const shouldChunk = reasoningBuf.length >= REASONING_CHUNK_SIZE
-            || (reasoningBuf.length >= 50 && now - lastFlushAt > 1500);
-          if (shouldChunk) flushReasoningInto(out);
-          if (isBoundary) {
-            // 兜底：content/finish 前把剩余思考一次性吐出，再透传本帧
-            flushReasoningInto(out);
-            const hasPassthrough = isBoundary || (Array.isArray(d.tool_calls) && d.tool_calls.length);
-            if (hasPassthrough) out.push(`data: ${JSON.stringify(obj)}\n\n`);
-            continue;
-          }
-          // 纯 reasoning 碎片帧已缓冲/或已分片吐出，原空帧吞掉
-          continue;
-        }
-        // 非 reasoning 帧：若有 content/finish 先兜底 flush
-        if ((typeof d?.content === "string" && d.content) || ch.finish_reason) flushReasoningInto(out);
-        if (!hasSentRole && d?.role !== undefined) {
-          hasSentRole = true;
-        } else if (hasSentRole && d?.role !== undefined) {
-          // 去重：首个 role 后续重复 role 去掉，避免下游每帧都带 role
-          try { const clone = JSON.parse(payload); delete clone.choices[0].delta.role; out.push(`data: ${JSON.stringify(clone)}\n\n`); continue; } catch { /* fallback透传 */ }
-        }
-      }
-      out.push(line + "\n");
-    }
-  }
-
-  const body = new ReadableStream({
-    async pull(controller) {
-      if (closed) { try { controller.close(); } catch {} return; }
-      try {
-        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
-        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
-        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
-        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
-        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
-        for (;;) {
-          const { done, value } = await reader.read();
-          if (done) {
-            closed = true;
-            const out = [];
-            if (buf) { processInto(buf + "\n", out); buf = ""; }
-            flushReasoningInto(out);
-            if (out.length) controller.enqueue(encoder.encode(out.join("")));
-            controller.close();
-            return;
-          }
-          buf += decoder.decode(value, { stream: true });
-          const idx = buf.lastIndexOf("\n");
-          if (idx < 0) continue;
-          const complete = buf.slice(0, idx + 1);
-          buf = buf.slice(idx + 1);
-          const out = [];
-          processInto(complete, out);
-          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
-        }
-      } catch {
-        closed = true;
-        try { controller.close(); } catch {}
-      }
-    },
-    cancel() {
-      closed = true;
-      try {
-        const p = reader.cancel();
-        if (p && typeof p.catch === "function") p.catch(() => {});
-      } catch {}
-    },
-  });
-
-  const out = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
-  try { out._t = res._t; } catch {}
-  return out;
-}
+// workbuddy 流式 reasoning_content 整形：上游思考模型（如 glm-5.3-flash）把思考过程一词一 chunk
+// 地放进 delta.reasoning_content，客户端会把每个增量渲染成独立 "- Thought" 条目。
+// 旧版：连续 reasoning 增量缓冲到首个 content/finish 才一次性 flush → 思考期 10~30s 界面完全无变化（用户看到 workbuddy 后台流量走但 opencode 界面卡住）
+// 新版：增量聚合 + 阈值分片：缓冲 reasoning，达到 REASONING_CHUNK_SIZE（默认 100 字符）即分片 flush，
+// 期间仅首个 role 帧透传保持 TTFB，其余纯 reasoning 空帧吞掉（之前会透传 800+ 空 role 帧）；
+// 尾段不足阈值的在 content/finish/流结束时兜底 flush。恒空 reasoning（deepseek-v4-flash）零改写。
+// 仅包 workbuddy 出口的 SSE 响应，不影响其他供应商与全局聚合器。
+
+const REASONING_CHUNK_SIZE = 150;
+
+export function reshapeWorkbuddySse(res) {
+  try {
+    const ct = res.headers?.get?.("content-type") || "";
+    if (res.status !== 200 || !ct.includes("text/event-stream") || !res.body) return res;
+  } catch { return res; }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buf = "";
+  let reasoningBuf = "";
+  let lastMeta = null;
+  let closed = false;
+  let hasSentRole = false;
+  let lastFlushAt = Date.now();
+
+  function flushReasoningInto(out) {
+    if (!reasoningBuf) return;
+    const meta = lastMeta || {};
+    out.push(`data: ${JSON.stringify({
+      id: meta.id || "chatcmpl-workbuddy-reshape",
+      object: meta.object || "chat.completion.chunk",
+      created: meta.created || Math.floor(Date.now() / 1000),
+      model: meta.model || "",
+      choices: [{ index: 0, delta: { reasoning_content: reasoningBuf }, finish_reason: null }],
+    })}\n\n`);
+    reasoningBuf = "";
+    lastFlushAt = Date.now();
+  }
+
+  let blankStreak = false;
+  // 处理一段完整行文本（以 \n 结尾），产出的行/帧推进 out（连续空行合并为单个事件分隔）
+  function processInto(text, out) {
+    for (const line of text.split("\n")) {
+      if (!line) { if (!blankStreak) out.push("\n"); blankStreak = true; continue; }
+      blankStreak = false;
+      if (!line.startsWith("data:")) { out.push(line + "\n"); continue; }
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") { out.push(line + "\n"); continue; }
+      let obj;
+      try { obj = JSON.parse(payload); } catch { out.push(line + "\n"); continue; }
+      const ch = obj.choices?.[0];
+      if (ch && typeof ch === "object") {
+        if (obj.id) lastMeta = { id: obj.id, model: obj.model, object: obj.object, created: obj.created };
+        const d = ch.delta && typeof ch.delta === "object" ? ch.delta : null;
+        const rc = d ? d.reasoning_content : undefined;
+        if (typeof rc === "string" && rc) {
+          reasoningBuf += rc;
+          d.reasoning_content = "";
+          const isBoundary = (typeof d.content === "string" && d.content) || !!ch.finish_reason;
+          // 首个 reasoning 帧的 role 透传一次，保 TTFB；后续纯 reasoning 的 role 重复帧直接吞掉
+          if (!hasSentRole && d.role !== undefined) {
+            hasSentRole = true;
+            const rm = lastMeta || obj;
+            out.push(`data: ${JSON.stringify({
+              id: rm.id || obj.id || "chatcmpl-workbuddy-reshape",
+              object: rm.object || obj.object || "chat.completion.chunk",
+              created: rm.created || obj.created || Math.floor(Date.now() / 1000),
+              model: rm.model || obj.model || "",
+              choices: [{ index: 0, delta: { role: d.role }, finish_reason: null }],
+            })}\n\n`);
+          } else if (d.role !== undefined) {
+            // 后续重复 role 帧不再透传，避免 800+ 空帧洪泛
+            // 标记已发送过，避免后续非 reasoning 帧再误判为首次
+            hasSentRole = true;
+          }
+          // 阈值分片：攒够 100 字符即向前吐一块，期间界面可见增量而非全程静默
+          // 时间阈值：若距上次 flush 已超 700ms 且已攒 20+ 字符，也吐一块（避免小尾巴长时间不更新）
+          const now = Date.now();
+          const shouldChunk = reasoningBuf.length >= REASONING_CHUNK_SIZE
+            || (reasoningBuf.length >= 50 && now - lastFlushAt > 1500);
+          if (shouldChunk) flushReasoningInto(out);
+          if (isBoundary) {
+            // 兜底：content/finish 前把剩余思考一次性吐出，再透传本帧
+            flushReasoningInto(out);
+            const hasPassthrough = isBoundary || (Array.isArray(d.tool_calls) && d.tool_calls.length);
+            if (hasPassthrough) out.push(`data: ${JSON.stringify(obj)}\n\n`);
+            continue;
+          }
+          // 纯 reasoning 碎片帧已缓冲/或已分片吐出，原空帧吞掉
+          continue;
+        }
+        // 非 reasoning 帧：若有 content/finish 先兜底 flush
+        if ((typeof d?.content === "string" && d.content) || ch.finish_reason) flushReasoningInto(out);
+        if (!hasSentRole && d?.role !== undefined) {
+          hasSentRole = true;
+        } else if (hasSentRole && d?.role !== undefined) {
+          // 去重：首个 role 后续重复 role 去掉，避免下游每帧都带 role
+          try { const clone = JSON.parse(payload); delete clone.choices[0].delta.role; out.push(`data: ${JSON.stringify(clone)}\n\n`); continue; } catch { /* fallback透传 */ }
+        }
+      }
+      out.push(line + "\n");
+    }
+  }
+
+  const body = new ReadableStream({
+    async pull(controller) {
+      if (closed) { try { controller.close(); } catch {} return; }
+      try {
+        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
+        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
+        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
+        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
+        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            closed = true;
+            const out = [];
+            if (buf) { processInto(buf + "\n", out); buf = ""; }
+            flushReasoningInto(out);
+            if (out.length) controller.enqueue(encoder.encode(out.join("")));
+            controller.close();
+            return;
+          }
+          buf += decoder.decode(value, { stream: true });
+          const idx = buf.lastIndexOf("\n");
+          if (idx < 0) continue;
+          const complete = buf.slice(0, idx + 1);
+          buf = buf.slice(idx + 1);
+          const out = [];
+          processInto(complete, out);
+          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
+        }
+      } catch {
+        closed = true;
+        try { controller.close(); } catch {}
+      }
+    },
+    cancel() {
+      closed = true;
+      try {
+        const p = reader.cancel();
+        if (p && typeof p.catch === "function") p.catch(() => {});
+      } catch {}
+    },
+  });
+
+  const out = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  try { out._t = res._t; } catch {}
+  return out;
+}

package/src/providers/workbuddy.js

@@ -1,2 +1,2 @@
-// Shim — 保持历史导入路径兼容，真实实现下沉至 ./workbuddy/ 深模块
-export * from "./workbuddy/index.js";
+// Shim — 保持历史导入路径兼容，真实实现下沉至 ./workbuddy/ 深模块
+export * from "./workbuddy/index.js";

package/src/providers/zcode/sse.js

@@ -1,5 +1,7 @@
 // Anthropic SSE → OpenAI 形状转换（流式 / 聚合两种出口）。
-// 承诺字段：文本增量、tool_use 增量（tool_calls）、usage、finish_reason；thinking 块丢弃（不入历史）。
+// 承诺字段：文本增量、thinking 增量（reasoning_content）、tool_use 增量（tool_calls）、usage、finish_reason。
+// thinking 跨轮回填：首个 thinking block 的 signature 随 reasoning_content 挂在 assistant 历史消息上（必须，
+// 上游要求 signature 与 thinking 原文一起回传；与 reasoning_content_signature 拼写不同的上游见下兼容）。
 const ENCODER = new TextEncoder();
 const DECODER = new TextDecoder();
 const STOP_REASONS = { end_turn: "stop", max_tokens: "length", tool_use: "tool_calls", stop_sequence: "stop", pause_turn: "stop" };
@@ -26,6 +28,9 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
   let inputTokens = null;
   let outputTokens = null;
   let text = "";
+  // thinking 全量文本（聚合出口回填 reasoning_content）与首个 signature（跨轮必需，见文件头）
+  let thinkingText = "";
+  let thinkingSig = null;
   let toolCount = 0;
   const toolIndexByBlock = new Map();
   const toolCalls = [];
@@ -55,7 +60,12 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
       }
     } else if (evt.type === "content_block_start") {
       const block = evt.content_block || {};
-      if (block.type === "tool_use") {
+      if (block.type === "thinking") {
+        // 首个 thinking 块的 signature 留给聚合出口的跨轮回填（后续 thinking 块没有也必须回传空串占位——
+        // codearts 的 DeepSeek 同款要求，见 src/providers/codearts/chat.js）
+        if (thinkingSig === null && typeof block.signature === "string") thinkingSig = block.signature;
+        if (typeof block.thinking === "string" && block.thinking) thinkingText += block.thinking;
+      } else if (block.type === "tool_use") {
         const idx = toolCount++;
         toolIndexByBlock.set(Number(evt.index), idx);
         toolCalls.push({ id: String(block.id || `toolu_${idx}`), name: String(block.name || ""), args: "" });
@@ -66,6 +76,10 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
       if (d.type === "text_delta" && typeof d.text === "string") {
         text += d.text;
         out.push(chunkLine({ content: d.text }));
+      } else if (d.type === "thinking_delta" && typeof d.thinking === "string") {
+        thinkingText += d.thinking;
+        if (typeof d.signature === "string" && d.signature && thinkingSig === null) thinkingSig = d.signature;
+        out.push(chunkLine({ reasoning_content: d.thinking }));
       } else if (d.type === "input_json_delta" && typeof d.partial_json === "string") {
         const idx = toolIndexByBlock.has(Number(evt.index)) ? toolIndexByBlock.get(Number(evt.index)) : Math.max(0, toolCount - 1);
         if (toolCalls[idx]) toolCalls[idx].args += d.partial_json;
@@ -113,6 +127,9 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
 
   function result() {
     const message = { role: "assistant", content: text || null };
+    // thinking 聚合回填：跨轮必需的 signature 与原文一起带回（见文件头；codearts DeepSeek 同款）
+    if (thinkingText) message.reasoning_content = thinkingText;
+    if (thinkingSig !== null) message.reasoning_content_signature = thinkingSig;
     if (toolCalls.length) {
       message.tool_calls = toolCalls.map((t) => ({ id: t.id, type: "function", function: { name: t.name, arguments: t.args || "{}" } }));
       if (!text) message.content = null;

package/src/reasoning.js

@@ -1,33 +1,33 @@
-const PLACEHOLDER = " ";
-
-const MODEL_RULES = [
-  { match: (m) => /^kimi-/i.test(m || ""), scope: "toolCalls" },
-  { match: (m) => /deepseek/i.test(m || ""), scope: "all" },
-];
-
-export function normalizeModel(model) {
-  return model.startsWith("oc/") ? model.slice(3) : model;
-}
-
-function shouldInject(message, scope) {
-  if (message?.role !== "assistant") return false;
-  const rc = message.reasoning_content;
-  if (typeof rc === "string" && rc.length > 0) return false;
-  if (scope === "toolCalls") {
-    return Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
-  }
-  return true;
-}
-
-function applyRule(body, rule) {
-  if (!rule || !body?.messages) return body;
-  const messages = body.messages.map((m) =>
-    shouldInject(m, rule.scope) ? { ...m, reasoning_content: PLACEHOLDER } : m
-  );
-  return { ...body, messages };
-}
-
-export function injectReasoningContent(model, body) {
-  const rule = MODEL_RULES.find((r) => r.match(model));
-  return applyRule(body, rule);
+const PLACEHOLDER = " ";
+
+const MODEL_RULES = [
+  { match: (m) => /^kimi-/i.test(m || ""), scope: "toolCalls" },
+  { match: (m) => /deepseek/i.test(m || ""), scope: "all" },
+];
+
+export function normalizeModel(model) {
+  return model.startsWith("oc/") ? model.slice(3) : model;
+}
+
+function shouldInject(message, scope) {
+  if (message?.role !== "assistant") return false;
+  const rc = message.reasoning_content;
+  if (typeof rc === "string" && rc.length > 0) return false;
+  if (scope === "toolCalls") {
+    return Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+  }
+  return true;
+}
+
+function applyRule(body, rule) {
+  if (!rule || !body?.messages) return body;
+  const messages = body.messages.map((m) =>
+    shouldInject(m, rule.scope) ? { ...m, reasoning_content: PLACEHOLDER } : m
+  );
+  return { ...body, messages };
+}
+
+export function injectReasoningContent(model, body) {
+  const rule = MODEL_RULES.find((r) => r.match(model));
+  return applyRule(body, rule);
 }

package/src/routes/AGENTS.md

@@ -0,0 +1,37 @@
+# src/routes — 转发链契约（改 relay / 流式 / 用量前必读）
+
+> 从 `AGENTS.md` 下沉（2026-09-29 分层，就近生效）。改完跑：`node --test --test-concurrency=1 test/stream-*.test.js test/relay-*.test.js test/usage-*.test.js` + `npm run docs:check`。
+
+## 时间量测的两条口径（ADR-0039，最易被改错）
+
+- **保护闸门的零点 = `relay()` 入口的 `t0`**（首帧超时 / stall / MAX_STREAM / keepalive 四类）。**禁止**把上报锚点接进闸门判定，否则上游排队时间会吃掉超时预算、误杀正在出字的慢模型。
+- **上报时长（usage 行）的零点 = 本次上游尝试起点**（`serial-trial` 的 `tUp`，经 `attemptStartMs` 交进 relay）；relay 入口算 `preflightMs = t0 − 锚点` 并随**全部 4 个 return 点**带出，`relay-pipeline` 落行时相加。锚点缺失/负值一律 0。
+- 报表口径与 state 口径**彻底分离**：`recordModelStats`（→ `-status`/`-model stats` 的 EMA）仍吃转发入口相对值，勿"顺手统一"。
+- 首字与总耗时同加一个常数 → `总 − 首字` 恒等 → 速度读数不变（已锁为单测）。
+- usage 行**只增字段**演进（`src/usage/record.js` 拥有行形状）；旧行缺字段 = 未知，不得当 0。
+- 模型日志里 `relay-first-chunk ttfMs=` 是**转发入口相对值**（故意与报表不同源），排查时别混。
+
+## relay 的行为契约（既有测试锁死）
+
+- **超时是显式字段 `timedOut`**，`status` 数值只是 HTTP 语义展示，不得再拿 status 当"是否可 failover"的信号。
+- **注释帧（`: keepalive`）不算首块**：不解除闸门、不触发超时救回，但照常透传；能否安全 failover 看 `detail.wrotePayload`（=是否已**提交**模型产出，见下条留口）。
+- 闸门到点后上游仍吐出真实数据 → **撤销超时判定照常转发**（cancel 是异步的，竞态窗口内已到达的数据是纯收益），记 `detail.recoveries`。
+- 任一闸门到点且未写真实数据 → 回退候选；唯一/末位候选无 failover 去向 → 闸门放宽到 `MSLXDFF_LAST_CANDIDATE_TIMEOUT_MS`（默认 120s，0=不限），防误杀慢模型。
+- **空转 200 判据单一真相** = `stream-scan.js:isEmptyTurnDetail`（`chatShaped===true` 且 `chars===0 && toolCalls===0` 且 `finish_reason ∉ {tool_calls, function_call}`）；relay 侧「要不要封口」与 pipeline 5a0「要不要重拉」都必须用它，两处各写一份必然错拍。判空 → 转 failover，不记 auto 冷却（空转≠模型坏）。错误包络暂扣 `holdableChunk` 与非 chat 形状放行同在 `stream-scan.js`（**不在 stream.js**）。
+- **空轮留口（ADR-0043）**：模型产出（正文/工具/**思考**）出现前，空 delta 帧与 `[DONE]` 一律暂扣不写（`stream-hold.js:createRevocablePrefix`）；流结束仍零产出且未断下游 → **不 `res.end()`**，返回 `heldOpen:true` 交回重拉/换候选，正文续写同一条连接。三条铁律：① 异形/解析失败帧必须立即透传（`isTrivialFrame` 白名单式），透传契约不得为救空轮让路；② `[DONE]` 是终点，错误帧要排在它之前（tail 槽）且全程只允许一个；③ 重入同一条连接时 headers 可能已 flush → `statusCode`/`setHeader` 一律门控，收场经 `endHeldFailure`/`endEmptyTurnStream`/`helpers.json` 的 `writableEnded`+`headersSent` 守卫保证**恰好一次**，禁止把 JSON 体混进 `text/event-stream`。
+- 断下游即掐上游：relay 自持 `reader`（`for-await` 会锁 ReadableStream 使 `body.cancel()` 必 reject），`reader.cancel()` 才真掐得断。
+
+## 组/组员与宽带中继（`src/routes/groups*.js`、`peers.js`、`relay-queue.js`）
+
+- 慢模型不掐当前流：首块 25s 内到即视为可用、后续无限等；stall 15s 仅作质量分，耗时 >20s 降权；`MSLXDFF_HEDGE_DELAY_MS=1000` 时 1s 并发组员赛跑，赢家 `x-mslxdff-via`；指定模型 429 时按延迟 EMA 择优切最快模型。
+- `SLOW_TOTAL_MS=20s` 标 slow 进 5 分钟冷却（普通 60s）；上游重试 `1次×100ms`；`MSLXDFF_STREAM_TIMEOUT_MS=25s`（**仅首块未到且未写出任何字节时**才 failover；`0`=显式关闭首块超时，给重思考模型用）；`MAX_STREAM_MS=120s`。
+- 宽带 `relay://` 成员走 `GET /v1/groups/relay/stream` SSE 单长连 25s ping 直推（`pushToStream`），`MSLXDFF_BROADBAND_STREAM=0` 回退 1s poll，`MSLXDFF_BROADBAND_PING_MS=25000`/`_STALE_MS=90000` 可配（空闲 -96%）；用户明确反对 1s 轮询的空轮询。
+- 组命令语义：`-group list` 序号按 state 成员顺序（过滤 leader）固定渲染，`-group remove <seq>` 用同一顺序踢人（仅组长）；组长 `-leavegroup` 提示改用 `-delgroup`，`-delgroup` 在组员节点报错并提示该组由谁领导。
+- 模型可观测面：事件用**黑名单** `TRACE_DENY`（默认全可见，只排噪声与敏感面）；决定类事件只渲染 `DECISION_FIELDS` 登记过的标量，**"加日志"≠"倒数据"**，payload/正文一律不落；回显取头单一入口 `upstreamEcho(res)`。
+
+## Responses 端点（`routes/responses-route.js` + `responses/translate.js`，ADR-0012）
+
+- 复用 ChatPipeline 全链路，只做形状翻译；stateless（`previous_response_id` 不支持，thinking reasoning 暂不透传）。
+- Codex Rust 严格解码三特例（缺一整轮作废）：① 对 codex 调用者（UA/originator `codex_*` 或 `?client_version=`）`GET /v1/models` 追加顶层 `models: []`（**必须空**，填真目录会覆盖其内置 agent prompt）；② completed 的 usage 转 Responses 口径（`input_tokens/output_tokens` + details）；③ done 事件 `text` 带累积全文。
+- `-setto chatgpt`（`src/sync-codex.js`）写三端共用 `~/.codex/config.toml`（`wire_api="responses"` 显式、鉴权绝对路径 `node + -showtoken`，换模型需重跑 setto / `codex exec -m` / 手改 `model=`，单键覆盖无需剪枝）；排障 `MSLXDFF_RESPONSES_DEBUG=1` 看 `daemon.log [responses]` 四段 + Codex 侧 `~/.codex/logs_2.sqlite`（`Request completed ... status=`）与 `thread_history_1.sqlite`（正文）。
+- `@ai-sdk/openai` 只是客户端包，替代不了服务端翻译层；Qwen 上游走 `/v1/messages`（Anthropic 协议），接 Codex 要多一跳（未做）。

package/src/routes/chat/exhausted-handler.js

@@ -1,7 +1,16 @@
 // Note: 失败收尾四分支在 result 后补 client-response，与成功路径对账口径一致（result 条数 == client-response 条数）— 见 .agents/notes/implemented/bug-fix/2026-09-25-sdk-headers-timeout-and-failure-client-response.md
 import { relay } from "../stream.js";
+import { endHeldFailure } from "../stream-hold.js"; // 终局收场出口（502 JSON 或 SSE 错误帧 + [DONE]）
 import { json } from "../helpers.js";
 import { performance } from "node:perf_hooks";
+import { recordRelayTalk } from "../../talk-log.js"; // 环形对话日志：exhausted 收尾直连 relay，落盘点必须自己补一份
+
+// 最后一站的收场：relay 的「不写响应」路径（超时 / 空轮延后封口）都汇到这里，没有上层 failover 了，
+// 必须把响应「恰好一次」地关掉。形状由 endHeldFailure 按 headers 是否已 flush 决定
+// （未 flush → 502 JSON；已 flush 的 SSE → 错误帧 + [DONE]），这里不再自己 json() 打已 flush 的流。
+function terminal(res, message) {
+  endHeldFailure(res, message || "all auto models failed");
+}
 
 export async function handleExhaustedLocal({ res, body, lastErr, order, handlerCtx, evt, logCall, mark, perf0, stages, done, requested, useAuto, deps = {} }) {
   const { relay: relayImpl = relay } = deps;
@@ -15,18 +24,22 @@ export async function handleExhaustedLocal({ res, body, lastErr, order, handlerC
       onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: lastErr.model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
     });
     evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
+    // 绕过 relay-pipeline 的最后一站：对话日志照常落盘（正文只进 talk/*.log，不进 events.log）
+    try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", body, out }); } catch {}
     evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
     evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
-    // 最后一站：relay 超时路径不写响应（设计留给上层 failover），这里没有上层，必须自己收尾
-    if (out.timedOut) {
-      json(res, 502, { error: out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms` });
+    // 最后一站：relay 超时/空轮留口路径都不写响应，这里没有上层，必须自己收尾
+    if (out.timedOut || out.heldOpen) {
+      terminal(res, out.detail?.exitReason === "empty-turn-hold"
+        ? "EMPTY_MODEL_RESPONSE: 空轮重拉与换候选全部用尽，仍无正文"
+        : out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms`);
     }
     return true;
   }
   evt("result", { reqId: handlerCtx.reqId, model, status: lastErr?.status ?? 502, via: "none", timing: null });
   evt("client-response", { requested, actual: model, via: "none", fallback: false, status: lastErr?.status ?? 502, reqId: handlerCtx.reqId });
   done({ via: "none", status: lastErr?.status ?? 502, error: lastErr?.message || "all auto models failed" });
-  json(res, 502, { error: lastErr?.message || "all auto models failed" });
+  terminal(res, lastErr?.message);
   return true;
 }
 
@@ -41,16 +54,18 @@ export async function handleExhaustedAll({ res, body, lastErr, order, requested,
       onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: lastErr.model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
     });
     evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
+    // 同上：全链耗尽的最终转发也要留下问答原文
+    try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", body, out }); } catch {}
     evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
     evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
-    // 最后一站：relay 超时路径不写响应，这里没有上层 failover，必须自己收尾
-    if (out.timedOut) {
-      json(res, 502, { error: out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms` });
+    // 最后一站：relay 超时/空轮留口路径不写响应，这里没有上层 failover，必须自己收尾
+    if (out.timedOut || out.heldOpen) {
+      terminal(res, out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms`);
     }
     return true;
   }
   evt("result", { reqId: handlerCtx.reqId, model: lastErr?.model ?? requested, status: lastErr?.status ?? 502, via: "none", timing: null });
   evt("client-response", { requested, actual: lastErr?.model ?? requested, via: "none", fallback: false, status: lastErr?.status ?? 502, reqId: handlerCtx.reqId });
-  json(res, 502, { error: lastErr?.message || "all auto models failed" });
+  terminal(res, lastErr?.message);
   return true;
 }

package/src/routes/chat/gateway.js

@@ -1,47 +1,47 @@
-import { clientIp, json, readBody, parseHops } from "../helpers.js";
-import { runHook } from "../../plugins.js";
-import { createChatPipeline } from "../../chat-pipeline/index.js";
-
-/**
- * ChatGateway 薄适配层：仅负责 HTTP I/O（readBody + request:received hook）→ 委托 ChatPipeline.execute
- * Policy/Order/AutoRace/hedge/peer/broadband 全部在 chat-pipeline 深模块内。
- */
-export function createChatGateway(deps = {}) {
-  const pipeline = createChatPipeline(deps);
-
-  async function handle({ req, res }) {
-    let body;
-    try {
-      body = await readBody(req);
-    } catch {
-      return json(res, 400, { error: "Invalid JSON body" });
-    }
-    if (deps.plugins?.length) {
-      const rc = await runHook(deps.plugins, "request:received", {
-        ip: clientIp(req),
-        hops: parseHops(req.headers["x-mslxdff-hops"]),
-        headers: { "content-type": req.headers["content-type"] },
-        body,
-      });
-      for (const e of rc.errors) deps.logs?.appendEvent?.({ ts: Date.now(), type: "plugin-hook-error", hook: "request:received", plugin: e.plugin, error: e.error });
-      const respond = rc.value?.respond;
-      if (respond && typeof respond === "object") return json(res, respond.status || 200, respond.body ?? {});
-    }
-    req.body = body;
-    try {
-      await pipeline.execute({ req, res });
-    } catch (err) {
-      const msg = err?.message || String(err);
-      if (!res.headersSent) return json(res, 502, { error: msg });
-      try { res.end(); } catch {}
-    }
-  }
-
-  return { handle };
-}
-
-// 薄适配：保持原 chatHandler 签名兼容
-export async function chatHandler(ctx) {
-  const gw = createChatGateway(ctx);
-  return gw.handle(ctx);
+import { clientIp, json, readBody, parseHops } from "../helpers.js";
+import { runHook } from "../../plugins.js";
+import { createChatPipeline } from "../../chat-pipeline/index.js";
+
+/**
+ * ChatGateway 薄适配层：仅负责 HTTP I/O（readBody + request:received hook）→ 委托 ChatPipeline.execute
+ * Policy/Order/AutoRace/hedge/peer/broadband 全部在 chat-pipeline 深模块内。
+ */
+export function createChatGateway(deps = {}) {
+  const pipeline = createChatPipeline(deps);
+
+  async function handle({ req, res }) {
+    let body;
+    try {
+      body = await readBody(req);
+    } catch {
+      return json(res, 400, { error: "Invalid JSON body" });
+    }
+    if (deps.plugins?.length) {
+      const rc = await runHook(deps.plugins, "request:received", {
+        ip: clientIp(req),
+        hops: parseHops(req.headers["x-mslxdff-hops"]),
+        headers: { "content-type": req.headers["content-type"] },
+        body,
+      });
+      for (const e of rc.errors) deps.logs?.appendEvent?.({ ts: Date.now(), type: "plugin-hook-error", hook: "request:received", plugin: e.plugin, error: e.error });
+      const respond = rc.value?.respond;
+      if (respond && typeof respond === "object") return json(res, respond.status || 200, respond.body ?? {});
+    }
+    req.body = body;
+    try {
+      await pipeline.execute({ req, res });
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (!res.headersSent) return json(res, 502, { error: msg });
+      try { res.end(); } catch {}
+    }
+  }
+
+  return { handle };
+}
+
+// 薄适配：保持原 chatHandler 签名兼容
+export async function chatHandler(ctx) {
+  const gw = createChatGateway(ctx);
+  return gw.handle(ctx);
 }