mslxdff 0.1.231 → 0.1.232

package/src/providers/workbuddy/client-headers.js

@@ -0,0 +1,148 @@
+// WorkBuddy 出站请求头——照抄本机官方桌面端 5.8.3 的组装真值（buildVlmGatewayHeaders +
+// applyGatewayHeaders + applyTraceHeaders 三函数，逆向自 app.asar @89622109，见 .scratch/wb-chat-headers.txt）。
+// 为什么要它：2026-10-21 三号集体撞 `403 11140 账号存在异常行为` 封号，且换 UA 到官方完整口径也照样 11140
+//   ——判的是账号本体，但旧出站指纹是**自造杂交串**：UA `CLI/2.115.0 WorkBuddy/2.115.0`（真机是
+//   `WorkBuddy/5.8.3 WorkBuddy/5.8.3`）、缺 X-IDE-*/X-Private-Data/x-codebuddy-request/X-Conversation-*/
+//   traceparent 全链追踪头、还多带真机 chat 明确排除的 Origin/Referer。裸指纹 + 桌面登录号 = 风控画像。
+//   对齐口径降低「登新号又被带进沟」的概率。⚠ 对齐是降风险非保命，封号是账号级、refresh 已证实无效。
+// 版本随客户端自动更新会漂移：MSLXDFF_WORKBUDDY_APP_VERSION 覆盖（缺省 5.8.3）；
+//   MSLXDFF_WORKBUDDY_CLI_VERSION 非空才追加 ` CLI/<v>` 段（真机 buildVlmGatewayHeaders 的 i 参数可为空）。
+// 一键回退旧口径：MSLXDFF_WORKBUDDY_LEGACY_HEADERS=1。
+import { randomBytes } from "node:crypto";
+
+const APP_VERSION = () => (process.env.MSLXDFF_WORKBUDDY_APP_VERSION || "5.8.3").trim();
+// CLI 段版本取自本机活体日志（a06ef5f8 实时 chat 请求 UA `WorkBuddy/5.8.3 WorkBuddy/5.8.3 CLI/2.161.0`）。
+const CLI_VERSION = () => {
+  const v = (process.env.MSLXDFF_WORKBUDDY_CLI_VERSION ?? "").trim();
+  return v === "" ? "2.161.0" : v; // 缺省跟本机真值；显式空串仍可关掉该段
+};
+const isLegacy = () => process.env.MSLXDFF_WORKBUDDY_LEGACY_HEADERS === "1";
+
+function hex(n) { return randomBytes(n).toString("hex"); }
+
+// 真机 X-Request-ID 家族是 UUIDv7（毫秒时间戳打头 48bit + 版本位 7 + 变体位 10xx），
+// 活体日志证实：`01a15dcaf9a97a86a215ac50f6bcdfff` 第 13 位恒为 '7'。裸 hex 版本位 15/16 概率错、
+// 时间戳前缀是乱码——风控一眼假。按 https://www.rfc-editor.org/rfc/rfc9562 组真 v7。
+function uuidv7hex() {
+  const b = Buffer.from(randomBytes(16));
+  const ts = Date.now();
+  b[0] = Math.floor(ts / 2 ** 40) & 0xff;
+  b[1] = Math.floor(ts / 2 ** 32) & 0xff;
+  b[2] = Math.floor(ts / 2 ** 24) & 0xff;
+  b[3] = Math.floor(ts / 2 ** 16) & 0xff;
+  b[4] = Math.floor(ts / 2 ** 8) & 0xff;
+  b[5] = ts & 0xff;
+  b[6] = (b[6] & 0x0f) | 0x70; // version 7
+  b[8] = (b[8] & 0x3f) | 0x80; // variant 10xx
+  return b.toString("hex");
+}
+// 真机 X-Conversation-ID 家族是 UUIDv4（带横线，版本位 4 / 变体位 8~b），活体：`b84c6a36-bd21-461a-b9be-…`。
+function uuidv4dashed() {
+  const b = Buffer.from(randomBytes(16));
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  const h = b.toString("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+
+// 真机 CLI trace 头（bundle @4733511 trace_start_hook，**不是** Electron 代理链的 applyTraceHeaders）：
+// 只设 X-Trace-ID/X-B3-TraceId(=同 traceId 32hex)/X-B3-SpanId(16hex)/X-B3-Sampled=1/b3(<trace32>-<span16>-1 三段)。
+// 无 traceparent、无 X-B3-ParentSpanId——那两个是 Electron web 转发链的形状，chat 实发者是 CLI 子进程，别抄错链路。
+function traceHeaders() {
+  const n = hex(16), r = hex(8);
+  return {
+    "X-Trace-ID": n,
+    "X-B3-TraceId": n,
+    "X-B3-SpanId": r,
+    "X-B3-Sampled": "1",
+    b3: `${n}-${r}-1`,
+  };
+}
+
+// 网关态：每次调用是一条新逻辑会话。id 形状取自活体日志（2026-10-21 a06ef5f8 正常发 200 的 CLI 请求）：
+// 会话 id = **UUIDv4 带横线**（`b84c6a36-bd21-461a-b9be-…`）；请求 id = **UUIDv7 去横线**（第 13 位恒 '7'）。
+// bundle 逐字（@5997642 buildConversationHeaders）：X-Conversation-ID=会话 id；X-Request-ID=X-Conversation-Message-ID
+// =同一 uuidv7 双写；X-Conversation-Request-ID=**另一个** uuidv7（turn 级生成器）。网关一调用=新会话=新 turn，
+// 两值各生成一份即可（真机一 turn 多请求时才复用 Conversation-Request-ID）。
+// ⚠ X-Root-Request-ID / X-Parent-Conversation-ID 真机是**条件头**（meta 有值才设——sub-agent/续聊轮才带）。
+//   网关永远首请求，带上=把每条请求伪造成续聊，画像反常 → 不带。X-Session-ID 保留（活体 config/日志有同值头）。
+function conversationHeaders() {
+  const conv = uuidv4dashed();
+  const req = uuidv7hex();
+  const turn = uuidv7hex();
+  return {
+    "X-Conversation-ID": conv,
+    "X-Session-ID": conv,
+    "X-Request-ID": req,
+    "X-Conversation-Request-ID": turn,
+    "X-Conversation-Message-ID": req,
+    "X-Agent-Type": "main",
+    "acp-connection-id": req,
+  };
+}
+
+function legacyHeaders(key, auth, accept) {
+  const h = {
+    "Content-Type": "application/json",
+    Accept: accept,
+    "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
+    Origin: "https://www.codebuddy.cn",
+    Referer: "https://www.codebuddy.cn/",
+    "X-Product": "SaaS",
+  };
+  if (key) h["Authorization"] = `Bearer ${key}`;
+  if (auth?.uid) h["X-User-Id"] = auth.uid;
+  h["X-Domain"] = auth?.domain || "www.codebuddy.cn";
+  if (auth?.enterpriseId) { h["X-Enterprise-Id"] = auth.enterpriseId; h["X-Tenant-Id"] = auth.enterpriseId; }
+  return h;
+}
+
+// 官方桌面端完整口径。三处出口（chat / refresh / config）共用，保证**一个号一张脸**：
+//   chat 带每请求 conversation/trace id；refresh、config 无会话 → withConversation:false。
+//   真机 buildVlmGatewayHeaders 的 Accept 是 application/json（SSE 靠 body.stream 协商），故 accept 默认即此。
+export function buildWorkbuddyHeaders(key, auth, { accept = "application/json", withConversation = true } = {}) {
+  if (isLegacy()) return legacyHeaders(key, auth, accept);
+  const app = APP_VERSION(), cli = CLI_VERSION();
+  const ua = [`WorkBuddy/${app}`, `WorkBuddy/${app}`, ...(cli ? [`CLI/${cli}`] : [])].join(" ");
+  const h = {
+    "Content-Type": "application/json",
+    Accept: accept,
+    "Accept-Encoding": "identity",
+    "User-Agent": ua,
+    "X-IDE-Type": "WorkBuddy",
+    "X-IDE-Name": "WorkBuddy",
+    "X-IDE-Version": app,
+    "X-Private-Data": process.env.MSLXDFF_WORKBUDDY_PRIVATE_DATA || "false",
+    "X-Product": "SaaS",
+    "x-requested-with": "XMLHttpRequest",
+    "x-codebuddy-request": "1",
+    "X-Agent-Intent": "craft",
+    "X-Agent-Purpose": "conversation",
+    ...(withConversation ? conversationHeaders() : {}),
+    ...(withConversation ? traceHeaders() : {}),
+  };
+  if (key) h["Authorization"] = `Bearer ${key}`;
+  if (auth?.uid) h["X-User-Id"] = auth.uid;
+  h["X-Domain"] = auth?.domain || "www.codebuddy.cn";
+  if (auth?.enterpriseId) { h["X-Enterprise-Id"] = auth.enterpriseId; h["X-Tenant-Id"] = auth.enterpriseId; }
+  return h;
+}
+
+// GET /v3/config 专用：活体真值＝本机 CLI 子进程（好号 a06ef5f8 正常工作中）2026-10-21 17:29 实发的 6 头集
+//（客户端日志逐字：authorization/user-agent(WorkBuddy/5.8.3 WorkBuddy/5.8.3 CLI/2.161.0)/x-domain/x-product/x-request-id/x-user-id）。
+// ⚠ config 的 x-request-id=`b1f4cb939a57486d86d16b74bec13511` 第13位='4'、第17位='8' → 是**去横线 UUIDv4**，
+//   与 chat 的 UUIDv7 生成器不同（两条链路各自的 id 策略）。**无 Content-Type（GET）、无 X-IDE-*、无 trace、无 Origin/Referer**——
+//   别拿 chat 全量头套它（2026-10-21 曾 over-align，按活体回退）。
+export function buildWorkbuddyConfigHeaders(key, auth) {
+  const app = APP_VERSION(), cli = CLI_VERSION();
+  const ua = [`WorkBuddy/${app}`, `WorkBuddy/${app}`, ...(cli ? [`CLI/${cli}`] : [])].join(" ");
+  const h = {
+    "User-Agent": ua,
+    "X-Domain": auth?.domain || "www.codebuddy.cn",
+    "X-Product": "SaaS",
+    "X-Request-ID": uuidv4dashed().replace(/-/g, ""),
+  };
+  if (key) h["Authorization"] = `Bearer ${key}`;
+  if (auth?.uid) h["X-User-Id"] = auth.uid;
+  return h;
+}

package/src/providers/workbuddy/desktop-info.js

@@ -73,6 +73,22 @@ export function readDesktopAccount(fp) {
     accessToken: j.auth.accessToken,
     refreshToken: j.auth.refreshToken || "",
     expiresAt: exp,
-    domain: j.auth.domain || "www.codebuddy.cn",
+    // domain 以 token 的 iss realm 为准（比 auth.domain 更贴近 cop 网关鉴权域）；auth.domain 兜底。
+    // 注：从桌面 info 导入不等于能对话——2026-10-21 一台桌面态 token 对网关直连仍 401（疑似内嵌 CLI 与
+    // 桌面 Electron 双鉴权）；入池正解是设备授权流 `-provider workbuddy login`，本函数只负责解析登录态字段。
+    domain: issDomain(j.auth.accessToken) || j.auth.domain || "www.codebuddy.cn",
   };
 }
+
+// 从 JWT payload.iss（如 https://www.codebuddy.cn/auth/realms/copilot）提取主机名；解析失败返回 ""。
+export function issDomain(token) {
+  try {
+    const payload = String(token || "").split(".")[1];
+    if (!payload) return "";
+    let b = payload.replace(/-/g, "+").replace(/_/g, "/");
+    while (b.length % 4) b += "=";
+    const iss = JSON.parse(Buffer.from(b, "base64").toString("utf8"))?.iss;
+    if (typeof iss !== "string") return "";
+    return new URL(iss).host || "";
+  } catch { return ""; }
+}

package/src/providers/workbuddy/models.js

@@ -1,5 +1,7 @@
 import { joinModelId } from "../model-id.js";
 import { joinUrl } from "../base.js";
+import { isAccountRestricted } from "./auth.js";
+import { buildWorkbuddyConfigHeaders } from "./client-headers.js";
 
 function creditsValue(c) {
   if (!c || !String(c).trim()) return 0;
@@ -28,16 +30,8 @@ export function createModelsService({
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error(`${id} models timed out`)), 15_000);
     try {
-      const headers = {
-        Accept: "application/json",
-        "X-User-Id": useAuth?.uid || "",
-        "X-Domain": useAuth?.domain || "www.codebuddy.cn",
-        "X-Product": "SaaS",
-        "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
-        Origin: "https://www.codebuddy.cn",
-        Referer: "https://www.codebuddy.cn/",
-      };
-      if (useKey) headers["Authorization"] = `Bearer ${useKey}`;
+      // config 端点按活体真值只发 6 头（GET 简头通道，勿套 chat 全量头——2026-10-21 实测回退）。
+      const headers = buildWorkbuddyConfigHeaders(useKey, useAuth);
       const opts = { headers, signal: controller.signal };
       if (dispatcher) opts.dispatcher = dispatcher;
       return await fetchImpl(`${joinUrl(baseUrl, modelsPath)}`, opts);
@@ -65,6 +59,8 @@ export function createModelsService({
         if (!r.ok) {
           let t = "";
           try { t = await r.clone().text(); } catch {}
+          // 封号 11140：refresh 无效（判账号本体），跳过刷新直接换下一个 key，别白烧 refresh 端点。
+          if (isAccountRestricted(r.status, t)) continue;
           if (isAuthError?.(r.status, t)) {
             const newKey = await refreshTokenFor?.(key, auth);
             if (newKey && !tried.has(newKey)) {
@@ -98,16 +94,8 @@ export function createModelsService({
     try {
       const key = getKey ? getKey() : "";
       const auth = getAuth ? getAuth(key) : null;
-      const headers = {
-        Accept: "application/json",
-        "X-User-Id": auth?.uid || "",
-        "X-Domain": auth?.domain || "www.codebuddy.cn",
-        "X-Product": "SaaS",
-        "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
-        Origin: "https://www.codebuddy.cn",
-        Referer: "https://www.codebuddy.cn/",
-      };
-      if (key) headers["Authorization"] = `Bearer ${key}`;
+      // 与 listModels 同一口径：config 简头集（活体真值）。
+      const headers = buildWorkbuddyConfigHeaders(key, auth);
       const opts = { headers };
       if (dispatcher) opts.dispatcher = dispatcher;
       const res = await fetchImpl(joinUrl(baseUrl, modelsPath), opts);

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