mslxdff 0.1.106 → 0.1.109

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.106",
+  "version": "0.1.109",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/chat-pipeline/index.js

@@ -4,6 +4,7 @@ import { planRoute } from "./planner.js";
 import { createEngine } from "./engine.js";
 import { runHook } from "../plugins.js";
 import { isFreeModel } from "../models.js";
+import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
 import { clientIp, summarizePrompt } from "../routes/helpers.js";
 
 /**
@@ -85,7 +86,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
 
     const plan = planRoute(policy, {
       candidates: order,
-      viaRoute: Boolean(!useAuto && requested.includes("/") && canForwardPeers) ? { via: true } : null,
+      viaRoute: Boolean(!useAuto && requested.includes("/") && canForwardPeers && shouldUseGroupForModel(requested)) ? { via: true } : null,
     });
     await engine.run(plan, {
       reqId, startedAt, req, res, body: req?.body, policy,

package/src/chat-pipeline/serial-trial.js

@@ -35,7 +35,7 @@ export async function runSerialTrial(ctx, deps = {}) {
   const workbuddyUid = ctx.workbuddyUid ?? ctx.policy?.workbuddyUid ?? null;
 
   let viaRouteLastErr = null;
-  if (!useAuto && requested && requested.includes("/") && canForwardPeers && !lockModel && peers) {
+  if (!useAuto && requested && requested.includes("/") && canForwardPeers && !lockModel && peers && shouldUseGroupForModel(requested)) {
     try {
       const vr = await viaRoute({ model: requested, body, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, requested, useAuto, lockModel, auto });
       if (vr.handled) return { done: true };
@@ -131,7 +131,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     if (canForwardPeers) {
       if (!shouldUseGroupForModel(model)) {
-        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (peer)" });
+        evt("group-skip", { reqId, model, reason: "useGroup=off (peer)" });
       } else {
         const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
         if (pr.handled) return { done: true };
@@ -139,7 +139,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     if (groups) {
       if (!shouldUseGroupForModel(model)) {
-        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (broadband)" });
+        evt("group-skip", { reqId, model, reason: "useGroup=off (broadband)" });
       } else {
         const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
         if (br.handled) return { done: true };

package/src/cli/commands/use-group.js

@@ -33,7 +33,7 @@ export async function handleUseGroup(args) {
     console.log(`  stored: ${stored ? "on" : "off"} (state.json useGroup)`);
     if (envVal !== null) console.log(`  env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} (overrides stored)`);
     console.log(`  default: on`);
-    console.log(`  usage: mslxdff -use-group on|off  (opencode 供应商本机失败时是否走组员网络，默认 on)`);
+    console.log(`  usage: mslxdff -use-group on|off  (本机失败时是否走组员网络，默认 on)`);
     console.log(`  env:   MSLXDFF_USE_GROUP=0|1  (优先级高于 state)`);
     process.exit(0);
   }
@@ -50,7 +50,7 @@ export async function handleUseGroup(args) {
 
   saveUseGroup(parsed);
   console.log(`use-group set to ${parsed ? "on" : "off"} (stored in state.json)`);
-  console.log(`  opencode 供应商：本机失败时 ${parsed ? "允许" : "不再"} 通过组员网络请求上游`);
-  if (!parsed) console.log(`  提示：opencode 请求将仅在本机重试，不再走 peer/broadband 组员中继`);
+  console.log(`  ${parsed ? "允许" : "不再允许"}走组员网络（via-route/hedge/peer/broadband，全部供应商）`);
+  if (!parsed) console.log(`  提示：所有请求将仅在本机重试，不再走组员中继`);
   process.exit(0);
 }

package/src/cli/help.js

@@ -43,7 +43,7 @@ Usage:
   mslxdff -autostart status        查看自启状态
   mslxdff -chat ["prompt"]       chat REPL（mimo-v2.5-free 优先/big-pickle 兜底，自然语言转命令，模糊匹配由模型完成，历史持久化，超长自动压缩，仅拦 -uninstall，daemon 重启不影响）
   mslxdff -resetban [ip]           clear join-failure bans (all, or one ip)
-  mslxdff -use-group [on|off]     opencode 供应商本机失败时是否走组员网络（默认 on；off 则仅本机，MSLXDFF_USE_GROUP 环境变量可覆盖）
+  mslxdff -use-group [on|off]     本机失败时是否走组员网络（默认 on；off 则所有供应商仅本机，MSLXDFF_USE_GROUP 环境变量可覆盖）
   mslxdff -help                    show this help
 
 Environment:
@@ -63,7 +63,7 @@ Environment:
   MSLXDFF_BAN_THRESHOLD   failed joins before an ip is banned (default 5)
   MSLXDFF_BAN_WINDOW_MS   ban duration after too many failures (default 48h)
   MSLXDFF_HEDGE_DELAY_MS  hedge peer race when local stream first chunk slow (default 1000, 0/off to disable)
-  MSLXDFF_USE_GROUP       opencode 组员中继开关（默认 on；0/off/false 关闭后 opencode 仅本机，不走 peer/broadband）
+  MSLXDFF_USE_GROUP       组员中继总开关（默认 on；0/off/false 关闭后所有供应商仅本机，不走 via-route/hedge/peer/broadband）
   MSLXDFF_AUTO_UPDATE   auto-update: hourly by default, 0/off/false to disable, 1/true or ms
   MSLXDFF_AUTO_UPDATE_MS  same as above, explicit ms (overrides AUTO_UPDATE)
 `);

package/src/providers/cline/auth.js

@@ -19,6 +19,22 @@ export function parseCooldown(body, status) {
   return 60 * 1000;
 }
 
+/**
+ * 真死 vs 假死：对标官方 getValidClineCredentials 契约——只有 invalid_grant
+ *（refresh token 被拒）才判死，需重新授权；网络抖动/5xx/超时是瞬时失败，
+ * 手里 token 仍有效时继续用，且绝不清掉已存凭证。
+ */
+export function isInvalidGrant(bodyText, status) {
+  const t = String(bodyText || "").toLowerCase();
+  if (/invalid_grant|invalid_token/.test(t)) return true;
+  // 路由拼错/版本提示类 401（"...latest version...re-authenticate your Cline account"）
+  // 只是打错了地址，不是 token 死，绝不能判死，否则好号会被永久冷冻。
+  if (/latest version|re-authenticate/.test(t)) return false;
+  if ((status === 400 || status === 403) && /invalid|expired|revoked/.test(t)) return true;
+  if (status === 401 && /invalid_grant|invalid token|token[^.]{0,30}(expired|revoked|invalid)/.test(t)) return true;
+  return false;
+}
+
 /**
  * 一次性 refresh：bench/诊断用，不落盘、不建池。
  * 返回 accessToken 或 null。
@@ -90,6 +106,7 @@ export function createAuthPool({
     for (let k = 0; k < list.length; k++) {
       const acc = list[accountIndex % list.length];
       accountIndex = (accountIndex + 1) % list.length;
+      if (acc.dead) continue;
       if (!acc.cooldownUntil || acc.cooldownUntil <= clock()) {
         currentAccount = acc;
         return acc;
@@ -100,9 +117,13 @@ export function createAuthPool({
 
   async function refreshOne(account) {
     const now = clock();
+    if (account.dead) throw new Error("invalid_grant");
     if (account.cooldownUntil > now) throw new Error("account_cooldown");
     if (account.accessToken && now < account.expiry) return account.accessToken;
-    const url = joinUrl(resolvedBase, "/api/v1/auth/refresh");
+    // base 可能已含 /api/v1（state 里 clinebot baseUrl 就是 …/api/v1），直接拼会 double 成
+    // …/api/v1/api/v1/auth/refresh → 上游回 401 Unauthorized（版本/重认证提示），绝不能当 token 死。
+    const baseNoV1 = resolvedBase.replace(/\/api\/v1\/?$/, "");
+    const url = joinUrl(baseNoV1, "/api/v1/auth/refresh");
     const opts = {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -111,7 +132,12 @@ export function createAuthPool({
     if (dispatcher) opts.dispatcher = dispatcher;
     let res;
     try { res = await fetchImpl(url, opts); } catch { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed"); }
-    if (!res.ok) { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed"); }
+    if (!res.ok) {
+      let t = "";
+      try { t = await res.text(); } catch {}
+      if (isInvalidGrant(t, res.status)) { account.dead = true; throw new Error("invalid_grant"); }
+      account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed");
+    }
     let data;
     try { data = await res.json(); } catch { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_no_token"); }
     const accessToken = data?.data?.accessToken || data?.accessToken || data?.access_token;
@@ -138,11 +164,12 @@ export function createAuthPool({
     if (pool.length === 0) throw new Error("缺少 CLINE_REFRESH_TOKEN（请用 cline_oauth.py 获取）");
     for (let attempt = 0; attempt < pool.length; attempt++) {
       const acc = pool[attempt % pool.length];
+      if (acc.dead) continue;
       if (acc.cooldownUntil && acc.cooldownUntil > clock()) continue;
       currentAccount = acc;
       try { return await refreshOne(acc); } catch (e) { if (e.message === "account_cooldown") continue; continue; }
     }
-    const acc = pool[0];
+    const acc = pool.find((a) => !a.dead) || null;
     if (!acc) throw new Error("无可用 Cline 账号");
     currentAccount = acc;
     acc.cooldownUntil = 0;

package/src/providers/cline/chat.js

@@ -155,9 +155,14 @@ export function createChatService({
     const sessionId = genSessionId();
     const isStream = body?.stream === true;
     const upstreamModel = stripProviderPrefix(model);
+    // token 口径双写：对标官方 withMaxCompletionTokensForReasoningModels——
+    // cline 上游默认 reasoning_effort high，推理模型认 max_completion_tokens，
+    // 只发 max_tokens 会被部分通道拒；双写兼容最稳。
+    const tokLimit = body?.max_tokens || body?.max_completion_tokens || 4096;
     const upstreamBody = {
       model: upstreamModel,
-      max_tokens: body?.max_tokens || body?.max_completion_tokens || 4096,
+      max_tokens: tokLimit,
+      max_completion_tokens: tokLimit,
       session_id: sessionId,
       reasoning_effort: body?.reasoning_effort || body?.reasoningEffort || "high",
       messages: body?.messages || [],

package/src/providers/cline/models.js

@@ -16,10 +16,34 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
   let cache = null;
   let fetchedAt = 0;
 
+  // 离线兜底：对标官方 FALLBACK（free 数组实证含 z-ai/glm-5.3-flash）。
+  // 上游挂了/401 时也不返回空数组，保证 -provider clinebot models 与 picks 仍有免费可用。
+  const FALLBACK_FREE = [
+    { id: "deepseek/deepseek-v4-flash", name: "deepseek-v4-flash" },
+    { id: "z-ai/glm-5.3-flash", name: "glm-5.3-flash" },
+    { id: "poolside/laguna-s-2.1:free", name: "laguna-s-2.1:free" },
+  ];
+
+  function fallbackList() {
+    const out = FALLBACK_FREE.map((m) => ({ ...m, id: joinModelId(id, m.id) }));
+    cache = out; fetchedAt = Date.now();
+    return out;
+  }
+
+  // 端点归一化：官方取 {bareHost}/api/v1/ai/cline/recommended-models。
+  // baseUrl 可能是裸 host（https://api.cline.bot）也可能是带 /api/v1 的，
+  // 统一收敛到 …/api/v1/ai/cline/recommended-models；用户自定义 path 原样尊重。
+  function resolveModelsUrl() {
+    const custom = modelsPath && modelsPath !== "/models" && modelsPath !== "/ai/cline/recommended-models";
+    if (custom) return joinUrl(resolvedBase, resolvedPath);
+    const bare = resolvedBase.replace(/\/api\/v1\/?$/, "");
+    return joinUrl(bare, "/api/v1/ai/cline/recommended-models");
+  }
+
   async function listModels() {
     const now = Date.now();
     if (cache && now - fetchedAt < CACHE_TTL) return cache;
-    const url = joinUrl(resolvedBase, resolvedPath);
+    const url = resolveModelsUrl();
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error(`${id} models timed out`)), 15_000);
     try {
@@ -29,20 +53,22 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
       const opts = { headers, signal: controller.signal };
       if (dispatcher) opts.dispatcher = dispatcher;
       const res = await fetchImpl(url, opts);
-      if (!res.ok) return [];
+      if (!res.ok) return fallbackList();
       const json = await res.json().catch(() => ({}));
       if (isClineBotHost(resolvedBase) && Array.isArray(json.free)) {
         const out = json.free.filter((m) => m && typeof m.id === "string").map((m) => ({ ...m, id: joinModelId(id, m.id) }));
+        if (!out.length) return fallbackList();
         cache = out; fetchedAt = now; return out;
       }
       const raw = Array.isArray(json.data) ? json.data : Array.isArray(json.models) ? json.models : Array.isArray(json) ? json : [];
       const out = raw.filter((m) => m && typeof m.id === "string").map((m) => ({ ...m, id: joinModelId(id, m.id) }));
+      if (!out.length) return fallbackList();
       cache = out; fetchedAt = now; return out;
-    } catch { return []; } finally { clearTimeout(timer); }
+    } catch { return fallbackList(); } finally { clearTimeout(timer); }
   }
 
   async function preheat() {
-    const url = joinUrl(resolvedBase, resolvedPath);
+    const url = resolveModelsUrl();
     const t0 = performance.now();
     try {
       const headers = { Accept: "application/json" };

package/src/state/schemas/use-group.js

@@ -35,19 +35,8 @@ export function getEffectiveUseGroup({ file = defaultStateFile() } = {}) {
   return loadUseGroup({ file });
 }
 
-// 仅对 opencode 供应商生效：opencode 的模型为裸 id 或 opencode/ 前缀
+// 全局开关：off 则所有供应商都不走组员网络（via-route/hedge/peer/broadband 全禁），仅本机直连
 export function shouldUseGroupForModel(model, { file = defaultStateFile() } = {}) {
-  const m = String(model || "").trim();
-  if (!m) return getEffectiveUseGroup({ file });
-  // 带前缀：判断是否为 opencode
-  if (m.includes("/")) {
-    const head = m.split("/")[0].trim().toLowerCase();
-    if (head === "opencode" || head === "oc") {
-      return getEffectiveUseGroup({ file });
-    }
-    return true; // 其他供应商不受此开关限制
-  }
-  // 裸 id 视为 opencode
   return getEffectiveUseGroup({ file });
 }
 

package/src/upstream-responses.js

@@ -25,7 +25,9 @@ export function chatToResponsesBody(chatBody) {
     return base;
   });
   const input = inputParts.join("\n\n") || "hi";
-  const out = { model: chatBody.model, input, stream: false };
+  // 流式意图透传：客户端要 SSE 就向上游要 SSE（reshapeResponsesSse 负责转回 chat SSE）。
+  // 写死 stream:false 是历史折衷（当时聚合 JSON 直回），已由完整 SSE 转换取代。
+  const out = { model: chatBody.model, input, stream: chatBody?.stream === true };
   if (system) out.instructions = system;
   // responses 的 tools 形状为平铺 {type,name,description,parameters}，而 chat 为 {type,function:{name,...}}
   if (Array.isArray(chatBody.tools) && chatBody.tools.length) {
@@ -120,7 +122,6 @@ export function reshapeResponsesSse(res, fallbackModel) {
     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 = "";
@@ -143,22 +144,23 @@ export function reshapeResponsesSse(res, fallbackModel) {
     return `data: ${JSON.stringify(payload)}\n\n`;
   }
 
-  let closed = false;
-  const body = new ReadableStream({
-    async pull(controller) {
-      if (closed) { try { controller.close(); } catch {} return; }
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          closed = true;
-          if (buf.trim()) {
-            // 残余缓冲尝试处理
-          }
-          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-          controller.close();
-          return;
-        }
-        buf += decoder.decode(value, { stream: true });
+  function sendRole(out) {
+    if (!hasSentRole) {
+      hasSentRole = true;
+      out += chatChunk({ role: "assistant" }, null);
+    }
+    return out;
+  }
+
+  // TransformStream 泵：for await 直接驱动上游流，writer.write 背压回压。
+  // （自建 ReadableStream 的 pull 调度在本机 daemon 下出现"pull resolve 后不再续拉"
+  //   导致 muse SSE 卡死；async-iterator 泵是 undici 流已验证畅通的姿势）
+  const { readable, writable } = new TransformStream();
+  const writer = writable.getWriter();
+  (async () => {
+    try {
+      for await (const chunk of res.body) {
+        buf += decoder.decode(chunk, { stream: true });
         let out = "";
         // 按 \n\n 分事件
         while (true) {
@@ -181,92 +183,75 @@ export function reshapeResponsesSse(res, fallbackModel) {
           if (data.response?.id) respId = data.response.id;
           if (data.response?.model) respModel = data.response.model;
           if (data.response?.created_at) created = Math.floor(data.response.created_at);
-          if (data.response?.id && !respId) respId = data.response.id;
-          // 关注 output_text.delta
-           if (curEvent === "response.output_text.delta" || data.type === "response.output_text.delta") {
-             const deltaText = data.delta || "";
-             if (deltaText) {
-               if (!hasSentRole) {
-                 hasSentRole = true;
-                 out += chatChunk({ role: "assistant" }, null);
-               }
-               out += chatChunk({ content: deltaText }, null);
-             }
-           } else if (curEvent === "response.completed" || data.type === "response.completed") {
-             const usage = data.response?.usage || null;
-             // 若有 tool_calls，finish 应为 tool_calls
-             const hasTools = toolMap.size > 0;
-             const finish = hasTools ? "tool_calls" : (data.response?.status === "completed" ? "stop" : null);
-             // 末帧带 usage
-             const id = respId || `resp_${Date.now()}`;
-             const payload = {
-               id,
-               object: "chat.completion.chunk",
-               created,
-               model: respModel,
-               choices: [{ index: 0, delta: {}, finish_reason: finish }],
-               usage: usage || undefined,
-             };
-             out += `data: ${JSON.stringify(payload)}\n\n`;
-           } else if (data.type === "response.output_item.added" && data.item?.type === "message") {
-             // message 开始，可发送 role
-             if (!hasSentRole) {
-               hasSentRole = true;
-               out += chatChunk({ role: "assistant" }, null);
-             }
-           } else if (data.type === "response.output_item.added" && data.item?.type === "function_call") {
-             const outIdx = Number(data.output_index ?? 1);
-             const toolIdx = Math.max(0, outIdx - 1);
-             const callId = data.item?.call_id || data.item?.id || "";
-             const name = data.item?.name || "";
-             toolMap.set(outIdx, { idx: toolIdx, id: callId, name });
-             if (!hasSentRole) {
-               hasSentRole = true;
-               out += chatChunk({ role: "assistant" }, null);
-             }
-             const tc = { index: toolIdx, id: callId, type: "function", function: { name, arguments: "" } };
-             // 清理空字符串，避免 undefined
-             if (!callId) delete tc.id;
-             if (!name) delete tc.function.name;
-             out += chatChunk({ tool_calls: [tc] }, null);
-           } else if (data.type === "response.function_call_arguments.delta") {
-             const outIdx = Number(data.output_index ?? 1);
-             const entry = toolMap.get(outIdx) || { idx: Math.max(0, outIdx - 1) };
-             const deltaArgs = data.delta || "";
-             if (deltaArgs) {
-               if (!hasSentRole) {
-                 hasSentRole = true;
-                 out += chatChunk({ role: "assistant" }, null);
-               }
-               out += chatChunk({ tool_calls: [{ index: entry.idx, function: { arguments: deltaArgs } }] }, null);
-             }
-           } else if (data.type === "response.function_call_arguments.done") {
-             const outIdx = Number(data.output_index ?? 1);
-             const entry = toolMap.get(outIdx) || { idx: Math.max(0, outIdx - 1) };
-             const args = data.arguments || "";
-             if (args && !toolMap.get(outIdx)?._done) {
-               // done 可能带全量，若未通过 delta 发送过，补发
-               // 已通过 delta 流式发送则忽略，避免重复
-             }
-           } else if (data.type === "response.output_item.done" && data.item?.type === "function_call") {
-             // 可忽略，已通过 added+delta 完整
-           }
-           // reasoning 加密块忽略
+          // created/in_progress 即发 role 帧：muse reasoning 阶段可达数十秒，
+          // 尽早产出首帧避免 relay 的首块超时（25s）误杀
+          if (data.type === "response.created" || data.type === "response.in_progress") {
+            out = sendRole(out);
+          }
+          if (curEvent === "response.output_text.delta" || data.type === "response.output_text.delta") {
+            const deltaText = data.delta || "";
+            if (deltaText) {
+              out = sendRole(out);
+              out += chatChunk({ content: deltaText }, null);
+            }
+          } else if (curEvent === "response.completed" || data.type === "response.completed") {
+            const usage = data.response?.usage || null;
+            // 若有 tool_calls，finish 应为 tool_calls
+            const hasTools = toolMap.size > 0;
+            const finish = hasTools ? "tool_calls" : (data.response?.status === "completed" ? "stop" : null);
+            // 末帧带 usage
+            const id = respId || `resp_${Date.now()}`;
+            const payload = {
+              id,
+              object: "chat.completion.chunk",
+              created,
+              model: respModel,
+              choices: [{ index: 0, delta: {}, finish_reason: finish }],
+              usage: usage || undefined,
+            };
+            out += `data: ${JSON.stringify(payload)}\n\n`;
+          } else if (data.type === "response.output_item.added" && data.item?.type === "message") {
+            // message 开始，可发送 role
+            out = sendRole(out);
+          } else if (data.type === "response.output_item.added" && data.item?.type === "function_call") {
+            const outIdx = Number(data.output_index ?? 1);
+            const toolIdx = Math.max(0, outIdx - 1);
+            const callId = data.item?.call_id || data.item?.id || "";
+            const name = data.item?.name || "";
+            toolMap.set(outIdx, { idx: toolIdx, id: callId, name });
+            out = sendRole(out);
+            const tc = { index: toolIdx, id: callId, type: "function", function: { name, arguments: "" } };
+            // 清理空字符串，避免 undefined
+            if (!callId) delete tc.id;
+            if (!name) delete tc.function.name;
+            out += chatChunk({ tool_calls: [tc] }, null);
+          } else if (data.type === "response.function_call_arguments.delta") {
+            const outIdx = Number(data.output_index ?? 1);
+            const entry = toolMap.get(outIdx) || { idx: Math.max(0, outIdx - 1) };
+            const deltaArgs = data.delta || "";
+            if (deltaArgs) {
+              out = sendRole(out);
+              out += chatChunk({ tool_calls: [{ index: entry.idx, function: { arguments: deltaArgs } }] }, null);
+            }
+          } else if (data.type === "response.function_call_arguments.done") {
+            // done 可能带全量，若未通过 delta 发送过则补发；已通过 delta 发送则忽略，避免重复
+          } else if (data.type === "response.output_item.done" && data.item?.type === "function_call") {
+            // 可忽略，已通过 added+delta 完整
+          }
+          // reasoning 加密块忽略
         }
-        if (out) controller.enqueue(encoder.encode(out));
-      } catch {
-        closed = true;
-        try { controller.close(); } catch {}
+        if (out) await writer.write(encoder.encode(out));
       }
-    },
-    cancel() {
-      closed = true;
-      try { reader.cancel(); } catch {}
-    },
-  });
+      await writer.write(encoder.encode("data: [DONE]\n\n"));
+      await writer.close();
+    } catch (e) {
+      try { await writer.abort(e instanceof Error ? e : new Error(String(e))); } catch { try { writer.close(); } catch {} }
+    }
+  })();
   const headers = new Headers(res.headers);
   headers.set("content-type", "text/event-stream");
-  const out = new Response(body, { status: res.status, statusText: res.statusText, headers });
+  const out = new Response(readable, { status: res.status, statusText: res.statusText, headers });
   try { out._t = res._t; } catch {}
   return out;
 }
+