mslxdff 0.1.170 → 0.1.172

package/src/routes/peers.js

@@ -1,273 +1,273 @@
-import { performance } from "node:perf_hooks";
-import { isAutoModel } from "../auto.js";
-import { errMsg } from "./helpers.js";
-import { runHook } from "../plugins.js";
-import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
-import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
-
-const PEER_TIMEOUT_MS = 30_000;
-const PEER_STATUS_TIMEOUT_MS = 2_000;
-const DEFAULT_PEER_CONNECT_TIMEOUT_MS = 3_000;
-// SSE 响应体数据间隔超时（undici bodyTimeout）。慢模型首块后可静默思考远超 30s，
-// 沿用 30s 会把组内转发的中继活流掐成 "terminated"（实测首块后 ~31s 必断，本地直连
-// 无此限制——组内因此比直连"不流畅"）。与应用层 MAX_STREAM_MS(120s) 对齐：
-// undici 层只做最后兜底，掐流交给应用层的首块/总时长策略。
-import { summarizeRequest } from "../model-trace.js";
-const PEER_BODY_TIMEOUT_MS = 120_000;
-export { PEER_BODY_TIMEOUT_MS };
-
-function peerConnectTimeoutMs() {
-  const n = Number(process.env.MSLXDFF_PEER_CONNECT_TIMEOUT_MS);
-  return Number.isInteger(n) && n > 0 ? n : DEFAULT_PEER_CONNECT_TIMEOUT_MS;
-}
-
-// 连接级超时（DNS + TCP/TLS 握手）：黑洞节点（端口挂起）必须快速失败，
-// 不能占用 30s 的响应超时（曾把一次请求拖到 92s）。仅 undici 可用时生效。
-let peerDispatcher = null;
-function getPeerDispatcher() {
-  if (peerDispatcher) return peerDispatcher;
-  const { Agent } = getUndici();
-  if (!Agent) return null;
-  try {
-    peerDispatcher = new Agent({
-      connect: { timeout: peerConnectTimeoutMs() },
-      headersTimeout: PEER_TIMEOUT_MS,
-      bodyTimeout: PEER_BODY_TIMEOUT_MS,
-      keepAliveTimeout: 30_000,
-      keepAliveMaxTimeout: 60_000,
-    });
-  } catch { peerDispatcher = null; }
-  return peerDispatcher;
-}
-
-// 跨 caller 中继必须剥离 reasoning 加密态：encrypted_content 由上游按 caller（出口）签发，
-// 换个节点转发会被拒（400 "reasoning encrypted_content was not issued to this caller"）。
-// 明文 reasoning_content 保留（不绑定 caller，thinking 模式需要）。
-export function stripCallerBoundReasoning(body) {
-  const messages = body?.messages;
-  if (!Array.isArray(messages)) return body;
-  let changed = false;
-  const out = messages.map((m) => {
-    if (!m || m.role !== "assistant") return m;
-    if (!Array.isArray(m.reasoning_items) || !m.reasoning_items.length) return m;
-    changed = true;
-    const copy = { ...m };
-    delete copy.reasoning_items;
-    return copy;
-  });
-  return changed ? { ...body, messages: out } : body;
-}
-
-function peerHealthTtlMs() {
-  const n = Number(process.env.MSLXDFF_PEER_HEALTH_TTL_MS);
-  return Number.isInteger(n) && n >= 0 ? n : 30_000;
-}
-
-const healthCache = new Map(); // url -> { at, data }
-const healthInflight = new Map(); // url -> Promise
-
-export function clearPeerHealthCache() {
-  healthCache.clear();
-  healthInflight.clear();
-}
-
-export async function peerHealthyModels(peer, { timeoutMs = PEER_STATUS_TIMEOUT_MS, fetchImpl = compatFetch } = {}) {
-  const key = peer?.url || "";
-  const ttl = peerHealthTtlMs();
-  if (ttl > 0) {
-    const hit = healthCache.get(key);
-    if (hit && Date.now() - hit.at < ttl) return hit.data;
-    const inflight = healthInflight.get(key);
-    if (inflight) return inflight;
-  }
-  const p = (async () => {
-    try {
-      const res = await fetchImpl(`${peer.url}/v1/models/status`, {
-        headers: {
-          "Authorization": `Bearer ${peer.token || ""}`,
-          "Accept": "application/json",
-        },
-        signal: timeoutSignal(timeoutMs),
-      });
-      if (!res.ok) return [];
-      const j = await res.json().catch(() => ({}));
-      return (j.data || [])
-        .filter((m) => m && typeof m.id === "string" && m.status === "normal")
-        .map((m) => m.id);
-    } catch {
-      return [];
-    }
-  })();
-  if (ttl > 0) {
-    healthInflight.set(key, p);
-    try {
-      const data = await p;
-      healthCache.set(key, { at: Date.now(), data });
-      return data;
-    } finally {
-      healthInflight.delete(key);
-    }
-  }
-  return p;
-}
-
-// controller 由调用方持有：赛跑 winner 确定后可主动 abort 其余 in-flight，
-// 避免迟到流挂满 bodyTimeout（并给对方省下无用负载）。30s timer 仅覆盖"等响应头"。
-async function forwardToPeer(peer, body, model, hops, controller = new AbortController()) {
-  const timer = setTimeout(() => controller.abort(), PEER_TIMEOUT_MS);
-  try {
-    const headers = {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${peer.token}`,
-      "x-mslxdff-hops": String(hops + 1),
-      "x-mslxdff-model-lock": model,
-      "Accept": "text/event-stream",
-    };
-    // ADR-0019：命中供应商的 key 随转发自动借出（组内互信，无开关；opencode/workbuddy/cline 硬排除）
-    const shareHeader = buildShareKeysHeader(model);
-    if (shareHeader) headers[SHARE_KEYS_HEADER] = shareHeader;
-    const dispatcher = getPeerDispatcher();
-    return await compatFetch(`${peer.url}/v1/chat/completions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ ...stripCallerBoundReasoning(body), model }),
-      signal: controller.signal,
-      ...(dispatcher ? { dispatcher } : {}),
-    });
-  } catch (err) {
-    return err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function resolvePeerTarget(ctx, peer) {
-  const prevModel = ctx.peers.stat(peer.url)?.model;
-  const hot = ctx.peers.isHot(peer.url) && prevModel === ctx.model;
-  if (hot) return { peer, target: prevModel };
-  const isExplicit = !!ctx.model && !isAutoModel(ctx.model);
-  if (isExplicit) {
-    const healthy = await peerHealthyModels(peer);
-    if (!healthy.length) {
-      ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0, strict: true });
-      return { peer, target: ctx.model };
-    }
-    ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length, strict: true });
-    return { peer, target: ctx.model };
-  }
-  const healthy = await peerHealthyModels(peer);
-  if (!healthy.length) {
-    await ctx.peers.recordError(peer.url);
-    ctx.logError(ctx.model, 0, `peer ${peer.url} has no healthy models`);
-    ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0 });
-    return null;
-  }
-  ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length });
-  return { peer, target: healthy.includes(ctx.model) ? ctx.model : healthy[0] };
-}
-
-export const PEER_RACE_LIMIT = Number(process.env.MSLXDFF_PEER_RACE_LIMIT) > 0
-  ? Number(process.env.MSLXDFF_PEER_RACE_LIMIT)
-  : 3;
-
-// 串行记账队列：失败/迟到成功的记录不阻塞赢家返回，同时避免并发写盘互相覆盖。
-let peerRecordChain = Promise.resolve();
-function recordLater(fn) {
-  peerRecordChain = peerRecordChain.then(fn).catch(() => {});
-}
-
-export async function racePeerCandidates(candidates, ctx) {
-  const tried = (ctx.triedUrls ??= new Set());
-  const fresh = candidates.filter((p) => !tried.has(p.url));
-  for (let i = 0; i < fresh.length; i += PEER_RACE_LIMIT) {
-    const batch = fresh.slice(i, i + PEER_RACE_LIMIT);
-    const prepared = (await Promise.all(batch.map((peer) => resolvePeerTarget(ctx, peer)))).filter(Boolean);
-    if (!prepared.length) continue;
-    const completed = await new Promise((resolve) => {
-      const order = [];
-      const total = prepared.length;
-      const ctrls = new Map(); // url -> controller（winner 后统一取消其余）
-      let settled = false;
-      const finish = (winner) => {
-        if (settled) return;
-        settled = true;
-        if (winner) {
-          for (const c of ctrls.values()) {
-            if (c === winner.ctrl) continue;
-            c.killedByUs = true;
-            c.abort();
-          }
-        }
-        resolve({ list: order, winner });
-      };
-      for (const { peer, target } of prepared) {
-        tried.add(peer.url);
-        const ctrl = new AbortController();
-        ctrls.set(peer.url, ctrl);
-        ctx.evt("peer-request", { peer: peer.url, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body) });
-        // 插件 hook：peer:beforeForward — 转发给组员前观察
-        if (ctx.plugins?.length) {
-          runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});
-        }
-        const t0 = performance.now();
-        forwardToPeer(peer, ctx.body, target, ctx.hops, ctrl).then((res) => {
-          const latencyMs = Math.round(performance.now() - t0);
-          const failed = res instanceof Error || res.status >= 400;
-          // winner 已定后被我们主动取消：静默，不记账不报错（否则污染健康统计与错误日志）
-          if (res instanceof Error && ctrl.killedByUs) {
-            order.push({ ok: false, peer, target, res, status: 0, killed: true });
-            if (order.length === total) finish(null);
-            return;
-          }
-          ctx.evt("peer-forward", { peer: peer.url, model: target, hops: ctx.hops + 1, latencyMs, ok: !failed });
-          // 插件 hook：peer:result — 组员响应后观察
-          if (ctx.plugins?.length) {
-            runHook(ctx.plugins, "peer:result", { reqId: ctx.reqId, peer: peer.url, model: target, ok: !failed, status: failed ? (res instanceof Error ? 502 : res.status) : res.status, latencyMs }).catch(() => {});
-          }
-          if (failed) {
-            const status = res instanceof Error ? 502 : res.status;
-            const failRec = { peer: peer.url, status, message: res instanceof Error ? errMsg(res) : null };
-            if (Array.isArray(ctx.peerErrors)) ctx.peerErrors.push(failRec);
-            ctx.logError(ctx.model, status, res instanceof Error ? `peer ${peer.url} ${errMsg(res)}` : `peer ${peer.url} ${status}`);
-            ctx.evt("peer-error", { peer: peer.url, model: target, status, message: res instanceof Error ? errMsg(res) : null });
-            order.push({ ok: false, peer, target, res, status });
-            recordLater(() => ctx.peers.recordError(peer.url, { status }));
-            recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
-            if (order.length === total) finish(null);
-          } else {
-            const entry = { ok: true, peer, target, res, latencyMs, ctrl };
-            order.push(entry);
-            if (!settled) {
-              // 第一个成功立即返回：不等慢/黑洞候选（迟到者的记账由各分支自理）
-              finish(entry);
-            } else {
-              recordLater(() => ctx.peers.recordResult(peer.url, { ok: true, latencyMs, model: target }));
-            }
-          }
-        });
-      }
-    });
-    const winner = completed.winner;
-    if (winner) {
-      return { peer: winner.peer, target: winner.target, res: winner.res, latencyMs: winner.latencyMs };
-    }
-    // 全失败：补读失败响应体（诊断 + 调用者详情）。仅在"本轮无 winner"时执行，
-    // 不拖慢成功路径；并行读、每 peer 上限 600ms，body 里才有 400/429 的真实原因。
-    await Promise.all(completed.list.map(async (o) => {
-      if (o.ok || !o.res || typeof o.res !== "object" || o.res instanceof Error) return;
-      try {
-        const snip = String(await Promise.race([
-          o.res.clone().text(),
-          new Promise((r) => { const t = setTimeout(() => r(""), 600); t.unref?.(); }),
-        ])).replace(/\s+/g, " ").slice(0, 300);
-        if (!snip) return;
-        if (Array.isArray(ctx.peerErrors)) {
-          const rec = ctx.peerErrors.find((x) => x.peer === o.peer.url && x.status === o.status && !x.message);
-          if (rec) rec.message = snip;
-        }
-        ctx.logError(ctx.model, o.status, `peer ${o.peer.url} ${o.status} body=${snip}`);
-      } catch {}
-    }));
-  }
-  return null;
-}
+import { performance } from "node:perf_hooks";
+import { isAutoModel } from "../auto.js";
+import { errMsg } from "./helpers.js";
+import { runHook } from "../plugins.js";
+import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
+import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
+
+const PEER_TIMEOUT_MS = 30_000;
+const PEER_STATUS_TIMEOUT_MS = 2_000;
+const DEFAULT_PEER_CONNECT_TIMEOUT_MS = 3_000;
+// SSE 响应体数据间隔超时（undici bodyTimeout）。慢模型首块后可静默思考远超 30s，
+// 沿用 30s 会把组内转发的中继活流掐成 "terminated"（实测首块后 ~31s 必断，本地直连
+// 无此限制——组内因此比直连"不流畅"）。与应用层 MAX_STREAM_MS(120s) 对齐：
+// undici 层只做最后兜底，掐流交给应用层的首块/总时长策略。
+import { summarizeRequest } from "../model-trace.js";
+const PEER_BODY_TIMEOUT_MS = 120_000;
+export { PEER_BODY_TIMEOUT_MS };
+
+function peerConnectTimeoutMs() {
+  const n = Number(process.env.MSLXDFF_PEER_CONNECT_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : DEFAULT_PEER_CONNECT_TIMEOUT_MS;
+}
+
+// 连接级超时（DNS + TCP/TLS 握手）：黑洞节点（端口挂起）必须快速失败，
+// 不能占用 30s 的响应超时（曾把一次请求拖到 92s）。仅 undici 可用时生效。
+let peerDispatcher = null;
+function getPeerDispatcher() {
+  if (peerDispatcher) return peerDispatcher;
+  const { Agent } = getUndici();
+  if (!Agent) return null;
+  try {
+    peerDispatcher = new Agent({
+      connect: { timeout: peerConnectTimeoutMs() },
+      headersTimeout: PEER_TIMEOUT_MS,
+      bodyTimeout: PEER_BODY_TIMEOUT_MS,
+      keepAliveTimeout: 30_000,
+      keepAliveMaxTimeout: 60_000,
+    });
+  } catch { peerDispatcher = null; }
+  return peerDispatcher;
+}
+
+// 跨 caller 中继必须剥离 reasoning 加密态：encrypted_content 由上游按 caller（出口）签发，
+// 换个节点转发会被拒（400 "reasoning encrypted_content was not issued to this caller"）。
+// 明文 reasoning_content 保留（不绑定 caller，thinking 模式需要）。
+export function stripCallerBoundReasoning(body) {
+  const messages = body?.messages;
+  if (!Array.isArray(messages)) return body;
+  let changed = false;
+  const out = messages.map((m) => {
+    if (!m || m.role !== "assistant") return m;
+    if (!Array.isArray(m.reasoning_items) || !m.reasoning_items.length) return m;
+    changed = true;
+    const copy = { ...m };
+    delete copy.reasoning_items;
+    return copy;
+  });
+  return changed ? { ...body, messages: out } : body;
+}
+
+function peerHealthTtlMs() {
+  const n = Number(process.env.MSLXDFF_PEER_HEALTH_TTL_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 30_000;
+}
+
+const healthCache = new Map(); // url -> { at, data }
+const healthInflight = new Map(); // url -> Promise
+
+export function clearPeerHealthCache() {
+  healthCache.clear();
+  healthInflight.clear();
+}
+
+export async function peerHealthyModels(peer, { timeoutMs = PEER_STATUS_TIMEOUT_MS, fetchImpl = compatFetch } = {}) {
+  const key = peer?.url || "";
+  const ttl = peerHealthTtlMs();
+  if (ttl > 0) {
+    const hit = healthCache.get(key);
+    if (hit && Date.now() - hit.at < ttl) return hit.data;
+    const inflight = healthInflight.get(key);
+    if (inflight) return inflight;
+  }
+  const p = (async () => {
+    try {
+      const res = await fetchImpl(`${peer.url}/v1/models/status`, {
+        headers: {
+          "Authorization": `Bearer ${peer.token || ""}`,
+          "Accept": "application/json",
+        },
+        signal: timeoutSignal(timeoutMs),
+      });
+      if (!res.ok) return [];
+      const j = await res.json().catch(() => ({}));
+      return (j.data || [])
+        .filter((m) => m && typeof m.id === "string" && m.status === "normal")
+        .map((m) => m.id);
+    } catch {
+      return [];
+    }
+  })();
+  if (ttl > 0) {
+    healthInflight.set(key, p);
+    try {
+      const data = await p;
+      healthCache.set(key, { at: Date.now(), data });
+      return data;
+    } finally {
+      healthInflight.delete(key);
+    }
+  }
+  return p;
+}
+
+// controller 由调用方持有：赛跑 winner 确定后可主动 abort 其余 in-flight，
+// 避免迟到流挂满 bodyTimeout（并给对方省下无用负载）。30s timer 仅覆盖"等响应头"。
+async function forwardToPeer(peer, body, model, hops, controller = new AbortController()) {
+  const timer = setTimeout(() => controller.abort(), PEER_TIMEOUT_MS);
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${peer.token}`,
+      "x-mslxdff-hops": String(hops + 1),
+      "x-mslxdff-model-lock": model,
+      "Accept": "text/event-stream",
+    };
+    // ADR-0019：命中供应商的 key 随转发自动借出（组内互信，无开关；opencode/workbuddy/cline 硬排除）
+    const shareHeader = buildShareKeysHeader(model);
+    if (shareHeader) headers[SHARE_KEYS_HEADER] = shareHeader;
+    const dispatcher = getPeerDispatcher();
+    return await compatFetch(`${peer.url}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ...stripCallerBoundReasoning(body), model }),
+      signal: controller.signal,
+      ...(dispatcher ? { dispatcher } : {}),
+    });
+  } catch (err) {
+    return err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function resolvePeerTarget(ctx, peer) {
+  const prevModel = ctx.peers.stat(peer.url)?.model;
+  const hot = ctx.peers.isHot(peer.url) && prevModel === ctx.model;
+  if (hot) return { peer, target: prevModel };
+  const isExplicit = !!ctx.model && !isAutoModel(ctx.model);
+  if (isExplicit) {
+    const healthy = await peerHealthyModels(peer);
+    if (!healthy.length) {
+      ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0, strict: true });
+      return { peer, target: ctx.model };
+    }
+    ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length, strict: true });
+    return { peer, target: ctx.model };
+  }
+  const healthy = await peerHealthyModels(peer);
+  if (!healthy.length) {
+    await ctx.peers.recordError(peer.url);
+    ctx.logError(ctx.model, 0, `peer ${peer.url} has no healthy models`);
+    ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0 });
+    return null;
+  }
+  ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length });
+  return { peer, target: healthy.includes(ctx.model) ? ctx.model : healthy[0] };
+}
+
+export const PEER_RACE_LIMIT = Number(process.env.MSLXDFF_PEER_RACE_LIMIT) > 0
+  ? Number(process.env.MSLXDFF_PEER_RACE_LIMIT)
+  : 3;
+
+// 串行记账队列：失败/迟到成功的记录不阻塞赢家返回，同时避免并发写盘互相覆盖。
+let peerRecordChain = Promise.resolve();
+function recordLater(fn) {
+  peerRecordChain = peerRecordChain.then(fn).catch(() => {});
+}
+
+export async function racePeerCandidates(candidates, ctx) {
+  const tried = (ctx.triedUrls ??= new Set());
+  const fresh = candidates.filter((p) => !tried.has(p.url));
+  for (let i = 0; i < fresh.length; i += PEER_RACE_LIMIT) {
+    const batch = fresh.slice(i, i + PEER_RACE_LIMIT);
+    const prepared = (await Promise.all(batch.map((peer) => resolvePeerTarget(ctx, peer)))).filter(Boolean);
+    if (!prepared.length) continue;
+    const completed = await new Promise((resolve) => {
+      const order = [];
+      const total = prepared.length;
+      const ctrls = new Map(); // url -> controller（winner 后统一取消其余）
+      let settled = false;
+      const finish = (winner) => {
+        if (settled) return;
+        settled = true;
+        if (winner) {
+          for (const c of ctrls.values()) {
+            if (c === winner.ctrl) continue;
+            c.killedByUs = true;
+            c.abort();
+          }
+        }
+        resolve({ list: order, winner });
+      };
+      for (const { peer, target } of prepared) {
+        tried.add(peer.url);
+        const ctrl = new AbortController();
+        ctrls.set(peer.url, ctrl);
+        ctx.evt("peer-request", { peer: peer.url, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body) });
+        // 插件 hook：peer:beforeForward — 转发给组员前观察
+        if (ctx.plugins?.length) {
+          runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});
+        }
+        const t0 = performance.now();
+        forwardToPeer(peer, ctx.body, target, ctx.hops, ctrl).then((res) => {
+          const latencyMs = Math.round(performance.now() - t0);
+          const failed = res instanceof Error || res.status >= 400;
+          // winner 已定后被我们主动取消：静默，不记账不报错（否则污染健康统计与错误日志）
+          if (res instanceof Error && ctrl.killedByUs) {
+            order.push({ ok: false, peer, target, res, status: 0, killed: true });
+            if (order.length === total) finish(null);
+            return;
+          }
+          ctx.evt("peer-forward", { peer: peer.url, model: target, hops: ctx.hops + 1, latencyMs, ok: !failed });
+          // 插件 hook：peer:result — 组员响应后观察
+          if (ctx.plugins?.length) {
+            runHook(ctx.plugins, "peer:result", { reqId: ctx.reqId, peer: peer.url, model: target, ok: !failed, status: failed ? (res instanceof Error ? 502 : res.status) : res.status, latencyMs }).catch(() => {});
+          }
+          if (failed) {
+            const status = res instanceof Error ? 502 : res.status;
+            const failRec = { peer: peer.url, status, message: res instanceof Error ? errMsg(res) : null };
+            if (Array.isArray(ctx.peerErrors)) ctx.peerErrors.push(failRec);
+            ctx.logError(ctx.model, status, res instanceof Error ? `peer ${peer.url} ${errMsg(res)}` : `peer ${peer.url} ${status}`);
+            ctx.evt("peer-error", { peer: peer.url, model: target, status, message: res instanceof Error ? errMsg(res) : null });
+            order.push({ ok: false, peer, target, res, status });
+            recordLater(() => ctx.peers.recordError(peer.url, { status }));
+            recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
+            if (order.length === total) finish(null);
+          } else {
+            const entry = { ok: true, peer, target, res, latencyMs, ctrl };
+            order.push(entry);
+            if (!settled) {
+              // 第一个成功立即返回：不等慢/黑洞候选（迟到者的记账由各分支自理）
+              finish(entry);
+            } else {
+              recordLater(() => ctx.peers.recordResult(peer.url, { ok: true, latencyMs, model: target }));
+            }
+          }
+        });
+      }
+    });
+    const winner = completed.winner;
+    if (winner) {
+      return { peer: winner.peer, target: winner.target, res: winner.res, latencyMs: winner.latencyMs };
+    }
+    // 全失败：补读失败响应体（诊断 + 调用者详情）。仅在"本轮无 winner"时执行，
+    // 不拖慢成功路径；并行读、每 peer 上限 600ms，body 里才有 400/429 的真实原因。
+    await Promise.all(completed.list.map(async (o) => {
+      if (o.ok || !o.res || typeof o.res !== "object" || o.res instanceof Error) return;
+      try {
+        const snip = String(await Promise.race([
+          o.res.clone().text(),
+          new Promise((r) => { const t = setTimeout(() => r(""), 600); t.unref?.(); }),
+        ])).replace(/\s+/g, " ").slice(0, 300);
+        if (!snip) return;
+        if (Array.isArray(ctx.peerErrors)) {
+          const rec = ctx.peerErrors.find((x) => x.peer === o.peer.url && x.status === o.status && !x.message);
+          if (rec) rec.message = snip;
+        }
+        ctx.logError(ctx.model, o.status, `peer ${o.peer.url} ${o.status} body=${snip}`);
+      } catch {}
+    }));
+  }
+  return null;
+}

package/src/routes/stream-scan.js

@@ -8,7 +8,13 @@ import { agentLoopEnabled, talkCapChars } from "../talk-full.js"; // 上限单
 
 // 响应正文捕获桶（talk log + agent 回路共用一只）：只有 relay 建了 detail.talk 才累积，未开启时零开销。
 // 口径与 chars/reasoningChars 同源（读 delta，不读聚合帧），区别是这里存原文而不是只计数。
-// 同样的边界：SSE 帧被 chunk 切断时该帧内容丢失（JSON.parse 失败即跳过）—— 研究用途可接受。
+// 分帧口径（openspec fix-talk-capture-frame-loss）：**按行不按 chunk** —— 未以 `\n` 收尾的尾行留在
+// talk.remain 里等下个工作拼回，凑齐的完整 `data:` 行才 parse；流收场由消费方调 captureTalkFlush
+// 回收缺尾换行的末行。历史口径「帧被 chunk 切断即弃（研究用途可接受）」已废——它让 talk/talkfull
+// 的 tool arguments 随机少 1~10 字符（现网取证 43% 路径落空），误导模型侧归因。
+// 不可逆丢弃（切点落在多字节字符内部的拼回行、超限半行）不静默：桶上 dropped 计数显式可见，
+// 语料 meta.droppedFrames / talk 头行 dropped= 透出——「看起来完整其实吃字」比缺失更危险（review P1-1）。
+const TALK_REMAIN_MAX = 2_000_000; // 半行缓冲上限（UTF-16 字符数，≈4MB）：远大于任何流式 delta 单行；超限弃半行并显式记 dropped（review P2-5）
 // 上限真相是 talkCapChars()（MSLXDFF_TALK_CAP_CHARS ＞ full 开 200 万 ＞ full 关 40 万）；
 // 下面的常数只是 createTalkBucket 未传 cap 时的历史缺省，必须与「full 关」档逐字相同（有测试锁死）。
 const TALK_CAP_DEFAULT = 400_000;
@@ -34,11 +40,12 @@ function talkMergeToolCalls(talk, tcs) {
   }
 }
 
-/** 新建累积桶（n/capped 防超长生成把内存吃穿）。cap = 字符上限，未传/非法 → 400_000（现状逐字不变）。 */
+/** 新建累积桶（n/capped 防超长生成把内存吃穿）。cap = 字符上限，未传/非法 → 400_000（现状逐字不变）。
+ *  remain = 跨 chunk 半行缓冲（openspec fix-talk-capture-frame-loss 行缓冲分帧）；dropped = 不可逆丢弃帧计数（P1-1 显式读数）。 */
 export function createTalkBucket(cap) {
   const c = Math.floor(Number(cap));
   const use = Number.isFinite(c) && c > 0 ? c : TALK_CAP_DEFAULT;
-  return { reasoning: [], content: [], tools: [], n: 0, capped: false, cap: use };
+  return { reasoning: [], content: [], tools: [], n: 0, capped: false, cap: use, remain: "", dropped: 0 };
 }
 
 /**
@@ -50,25 +57,44 @@ export function createTalkBucketIfEnabled() {
   return talkLogEnabled() || agentLoopEnabled() ? createTalkBucket(talkCapChars()) : null;
 }
 
-/** 逐 chunk 累积一轮对话的思考/正文/工具调用。talk 为空 = 未开启，直接返回。 */
+/** 完整单行消费（talk 桶的唯一落点，从原 captureTalkSse 循环体抽出，口径逐字不变）。glued=该行由跨 chunk 拼回。 */
+function talkConsumeLine(talk, raw, glued = false) {
+  if (glued && raw.includes("\uFFFD")) { talk.dropped = (Number(talk.dropped) || 0) + 1; return; } // 字节级切点：解码损伤不可逆，整行弃但必须留数（根因在 stream.js chunkText 逐 chunk 无状态解码，真修另起 change）
+  const t = raw.trim();
+  if (!t.startsWith("data:")) return;
+  const d = t.slice(5).trim();
+  if (!d || d === "[DONE]") return;
+  let j = null;
+  try { j = JSON.parse(d); } catch { return; }
+  const c0 = Array.isArray(j?.choices) ? j.choices[0] : null;
+  if (!c0) return;
+  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);
+  }
+}
+
+/** 逐 chunk 累积一轮对话的思考/正文/工具调用。talk 为空 = 未开启，直接返回。跨 chunk 行缓冲见文件头。 */
 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);
-    }
-  }
+  if (talk.remain && talk.remain.length > TALK_REMAIN_MAX) { talk.remain = ""; talk.dropped = (Number(talk.dropped) || 0) + 1; } // 拼接前丢弃超限半行：内存不尖峰（review P2-5）且显式记数；本轮正常数据照常消费
+  const hadRemain = Boolean(talk.remain);
+  const buf = (hadRemain ? talk.remain : "") + String(txt ?? "");
+  talk.remain = "";
+  if (!buf) return;
+  const lines = buf.split("\n");
+  if (!buf.endsWith("\n")) talk.remain = lines.pop() ?? "";
+  for (let i = 0; i < lines.length; i++) talkConsumeLine(talk, lines[i], hadRemain && i === 0);
+}
+
+/** 流收场回收：把缓冲里缺尾换行的末行按同一单行口径入桶（截断流不静默吞末帧）。幂等；无桶/空缓冲零副作用。 */
+export function captureTalkFlush(talk) {
+  if (!talk || !talk.remain) return;
+  const raw = talk.remain;
+  talk.remain = "";
+  talkConsumeLine(talk, raw, true);
 }
 
 /** 非流式：整块 message 直接入桶（tool_calls 参数本来就是完整的）。 */
@@ -89,7 +115,7 @@ export function captureTalkFallback(talk, text) {
 
 // 逐 SSE chunk 扫描：done/finish_reason/chat 形状/工具调用/usage/正文字符
 export function scanSseChunk(detail, txt) {
-  if (detail.talk) captureTalkSse(detail.talk, txt);
+  if (detail.talk) { try { captureTalkSse(detail.talk, txt); } catch {} } // 纯旁路红线：捕获异常绝不外溢成转发失败（review P2-7：旧调用点裸奔在 try 外只是口头契约）
   try {
     if (txt.includes("[DONE]")) detail.sawDone = true;
     const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);