mslxdff 0.1.236 → 0.1.237

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/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/chat/broadband-handler.js

@@ -1,80 +1,80 @@
-import { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS } from "../stream.js";
-import { buildFallbackInfo } from "../fallback.js";
-import { createRelayPipeline } from "./relay-pipeline.js";
-import { tryBroadbandRelay } from "../relay-queue.js";
-import { overForwardLimit, contextGuardMessage } from "../../chat-pipeline/context-guard.js";
-
-/** 薄适配：broadband 两种形态合一经由 pipeline */
-export async function handleBroadbandRelay({
-  model,
-  body,
-  hops,
-  lastErr,
-  requested,
-  useAuto,
-  lockModel,
-  auto,
-  groups,
-  token,
-  bus,
-  logs,
-  handlerCtx,
-  evt,
-  mark,
-  perf0,
-  attemptStartMs,
-  stages,
-  res,
-  startedAt,
-  plugins,
-  deps = {},
-}) {
-  const { createPipeline = createRelayPipeline, tryBroadbandRelay: tryRelay = tryBroadbandRelay } = deps;
-  // 转发前上下文预检：宽带成员是完全不同的另一台机器，上下文撑爆的代价（白烧它的额度）最实在。
-  const guard = overForwardLimit(body);
-  if (guard) {
-    const msg = contextGuardMessage(guard);
-    evt("context-guard", { reqId: handlerCtx.reqId, model, via: "broadband", estimated: guard.estimated, limit: guard.limit, over: guard.over });
-    return { handled: false, lastErr: { model, upstream: null, status: 400, message: msg, contextGuard: true } };
-  }
-  const bb = await tryRelay({ groups, token, model, body, hops, bus, logs, reqId: handlerCtx.reqId, evt, res, mark, perf0, stages });
-  if (!bb) {
-    evt("relay-miss", { reqId: handlerCtx.reqId, model });
-    return { handled: false };
-  }
-  const pipeline = createPipeline({
-    relay,
-    buildFallbackInfo,
-    auto,
-    plugins,
-    evt,
-    mark,
-    logCall: () => {},
-    logError: () => {},
-    constants: { STREAM_TIMEOUT_MS, SLOW_TOTAL_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS },
-    startedAt,
-    stages,
-  });
-  const isResponse = bb.result && typeof bb.result.status === "number" && typeof bb.result.headers?.get === "function";
-  if (isResponse) {
-    const r = await pipeline.execute({ res, upRes: bb.result, body, requested, actual: model, lastErr, via: "broadband", lockModel, useAuto, handlerCtx, mark, perf0, attemptStartMs, stages, startedAt });
-    if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
-    return { handled: true };
-  }
-  if (bb.result && typeof bb.result.status === "number") {
-    const b = bb.result.body || "";
-    const str = typeof b === "string" ? b : JSON.stringify(b);
-    const isSSE = bb.result.headers?.["Content-Type"]?.includes("text/event-stream");
-    const fakeRes = {
-      status: bb.result.status,
-      headers: { get: (k) => bb.result.headers?.[k] || bb.result.headers?.[k.toLowerCase()] || null },
-      text: async () => str,
-      body: isSSE ? (async function* () { yield Buffer.from(str); })() : null,
-    };
-    const r = await pipeline.execute({ res, upRes: fakeRes, body, requested, actual: model, lastErr, via: "broadband-local", lockModel, useAuto, handlerCtx, mark, perf0, attemptStartMs, stages, startedAt });
-    if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
-    return { handled: true };
-  }
-  evt("relay-miss", { reqId: handlerCtx.reqId, model });
-  return { handled: false };
-}
+import { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS } from "../stream.js";
+import { buildFallbackInfo } from "../fallback.js";
+import { createRelayPipeline } from "./relay-pipeline.js";
+import { tryBroadbandRelay } from "../relay-queue.js";
+import { overForwardLimit, contextGuardMessage } from "../../chat-pipeline/context-guard.js";
+
+/** 薄适配：broadband 两种形态合一经由 pipeline */
+export async function handleBroadbandRelay({
+  model,
+  body,
+  hops,
+  lastErr,
+  requested,
+  useAuto,
+  lockModel,
+  auto,
+  groups,
+  token,
+  bus,
+  logs,
+  handlerCtx,
+  evt,
+  mark,
+  perf0,
+  attemptStartMs,
+  stages,
+  res,
+  startedAt,
+  plugins,
+  deps = {},
+}) {
+  const { createPipeline = createRelayPipeline, tryBroadbandRelay: tryRelay = tryBroadbandRelay } = deps;
+  // 转发前上下文预检：宽带成员是完全不同的另一台机器，上下文撑爆的代价（白烧它的额度）最实在。
+  const guard = overForwardLimit(body);
+  if (guard) {
+    const msg = contextGuardMessage(guard);
+    evt("context-guard", { reqId: handlerCtx.reqId, model, via: "broadband", estimated: guard.estimated, limit: guard.limit, over: guard.over });
+    return { handled: false, lastErr: { model, upstream: null, status: 400, message: msg, contextGuard: true } };
+  }
+  const bb = await tryRelay({ groups, token, model, body, hops, bus, logs, reqId: handlerCtx.reqId, evt, res, mark, perf0, stages });
+  if (!bb) {
+    evt("relay-miss", { reqId: handlerCtx.reqId, model });
+    return { handled: false };
+  }
+  const pipeline = createPipeline({
+    relay,
+    buildFallbackInfo,
+    auto,
+    plugins,
+    evt,
+    mark,
+    logCall: () => {},
+    logError: () => {},
+    constants: { STREAM_TIMEOUT_MS, SLOW_TOTAL_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS },
+    startedAt,
+    stages,
+  });
+  const isResponse = bb.result && typeof bb.result.status === "number" && typeof bb.result.headers?.get === "function";
+  if (isResponse) {
+    const r = await pipeline.execute({ res, upRes: bb.result, body, requested, actual: model, lastErr, via: "broadband", lockModel, useAuto, handlerCtx, mark, perf0, attemptStartMs, stages, startedAt });
+    if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+    return { handled: true };
+  }
+  if (bb.result && typeof bb.result.status === "number") {
+    const b = bb.result.body || "";
+    const str = typeof b === "string" ? b : JSON.stringify(b);
+    const isSSE = bb.result.headers?.["Content-Type"]?.includes("text/event-stream");
+    const fakeRes = {
+      status: bb.result.status,
+      headers: { get: (k) => bb.result.headers?.[k] || bb.result.headers?.[k.toLowerCase()] || null },
+      text: async () => str,
+      body: isSSE ? (async function* () { yield Buffer.from(str); })() : null,
+    };
+    const r = await pipeline.execute({ res, upRes: fakeRes, body, requested, actual: model, lastErr, via: "broadband-local", lockModel, useAuto, handlerCtx, mark, perf0, attemptStartMs, stages, startedAt });
+    if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+    return { handled: true };
+  }
+  evt("relay-miss", { reqId: handlerCtx.reqId, model });
+  return { handled: false };
+}

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);
 }