mslxdff 0.1.101 → 0.1.102

package/package.json

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

package/src/chat-pipeline/index.js

@@ -30,10 +30,14 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     }
 
     // order 推导 + plugin model:select 可改
+    // 语义：指定模型 = 死锁单模型（本机→组员同款，挂了就报挂，不兜其他 picks）；只有 auto 才轮 picks
     let order;
     if (lockModel) order = [requested];
     else if (useAuto) order = auto ? await auto.candidates() : [""];
-    else order = auto ? await auto.candidatesFor(requested) : [requested];
+    else {
+      if (auto && requested) { try { await auto.candidatesFor(requested); } catch {} }
+      order = [requested];
+    }
     if (!order.length) order = [""];
     const canFallback = order.length > 1;
     const canForwardPeers = Boolean(peers) && hops < (maxHops ?? 3);

package/src/providers/workbuddy/chat.js

@@ -2,6 +2,7 @@ import { joinUrl } from "../base.js";
 import { isAuthError, isInsufficientStatus } from "./auth.js";
 import { appendRotationLog as defaultAppend } from "./rotation-log.js";
 import { createTransport } from "../../transport/index.js";
+import { reshapeWorkbuddySse } from "./reshape.js";
 
 function buildAuthHeaders(key, auth) {
   const h = {
@@ -86,7 +87,7 @@ export function createChatService({
     let res;
     try { res = await fetchOnce(url, body, key, auth); }
     catch (e) { throw e; }
-    if (res.status < 400) return res;
+    if (res.status < 400) return reshapeWorkbuddySse(res);
     let txt = "";
     try { txt = await res.text(); } catch {}
     if (!isAuthError(res.status, txt)) return res;
@@ -105,7 +106,7 @@ export function createChatService({
     if (stillAuth || res2.status === 429 || res2.status >= 500) try { ring.onError(newKey); } catch {}
     doLog({ uid: uid2, model: _modelForLog(), totalMs: Math.round(nowMs(clock) - _t0()), balanceHit: false, error: stillAuth ? `still auth ${res2.status}` : undefined });
     if (stillAuth) throw failErr(`workbuddy auth still failing after refresh for ${uid2}: ${stillTxt.slice(0, 120)}`, _t0(), clock);
-    return res2;
+    return reshapeWorkbuddySse(res2);
   }
 
   let _t0Val = 0;

package/src/providers/workbuddy/reshape.js

@@ -0,0 +1,142 @@
+// 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 {
+        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) return;
+        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("")));
+      } catch {
+        closed = true;
+        try { controller.close(); } catch {}
+      }
+    },
+    cancel() {
+      closed = true;
+      try { reader.cancel(); } 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/routes/hedge.js

@@ -20,6 +20,8 @@ function shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, mod
   if (!d || d <= 0) return false;
   // deepseek = 本机私有凭据供应商（组员节点没有凭据），对冲必败且 both-fail 会误杀本地慢首块流（reasoner 思考 3-30s），不走组员
   if (String(model || "").startsWith("deepseek/")) return false;
+  // muse-spark 走 /responses 流式（event: 包装 + 加密 reasoning），组员旧版无此整形且聚合 JSON 带错 header，必抢赢本地慢首块，需本地直出
+  if (String(model || "").toLowerCase().startsWith("muse-spark")) return false;
   return true;
 }
 

package/src/routes/stream.js

@@ -31,7 +31,8 @@ export const MAX_STREAM_MS = (() => {
 export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, streamTimeoutMs = STREAM_TIMEOUT_MS, fallback } = {}) {
   const t0 = performance.now();
   const contentType = upRes.headers.get("content-type") || "";
-  const isStream = Boolean(body?.stream) || contentType.includes("text/event-stream");
+  // 需同时满足：客户端要流 + 上游真的是 SSE；避免 muse-spark 聚合 JSON 被误判为流式，或 workbuddy SSE 被聚合
+  const isStream = Boolean(body?.stream) && contentType.includes("text/event-stream");
   res.statusCode = upRes.status;
   // propagate workbuddy uid / allowlist headers
   try {

package/src/upstream-responses.js

@@ -17,7 +17,7 @@ export function chatToResponsesBody(chatBody) {
     return `${m.role}: ${String(c || "")}`;
   });
   const input = inputParts.join("\n\n") || "hi";
-  const out = { model: chatBody.model, input, stream: false };
+  const out = { model: chatBody.model, input, stream: chatBody.stream !== false };
   if (system) out.instructions = system;
   if (chatBody.tools) out.tools = chatBody.tools;
   if (chatBody.tool_choice) out.tool_choice = chatBody.tool_choice;
@@ -62,3 +62,120 @@ export function toChatResponse(res, respJson) {
   headers.set("content-type", "application/json");
   return new Response(JSON.stringify(chatJson), { status: res.status, headers });
 }
+
+export function reshapeResponsesSse(res, fallbackModel) {
+  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 evtType = "";
+  let respId = "";
+  let respModel = fallbackModel || "";
+  let created = Math.floor(Date.now() / 1000);
+  let hasSentRole = false;
+
+  function chatChunk(delta, finish) {
+    const id = respId || `resp_${Date.now()}`;
+    const payload = {
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model: respModel,
+      choices: [{ index: 0, delta: delta || {}, finish_reason: finish || null }],
+    };
+    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 });
+        let out = "";
+        // 按 \n\n 分事件
+        while (true) {
+          const sep = buf.indexOf("\n\n");
+          if (sep < 0) break;
+          const raw = buf.slice(0, sep);
+          buf = buf.slice(sep + 2);
+          const lines = raw.split("\n");
+          let curEvent = evtType;
+          let dataStr = "";
+          for (const line of lines) {
+            if (line.startsWith("event:")) curEvent = line.slice(6).trim();
+            else if (line.startsWith("data:")) dataStr += line.slice(5).trim();
+          }
+          if (!dataStr) { evtType = ""; continue; }
+          evtType = "";
+          let data;
+          try { data = JSON.parse(dataStr); } catch { continue; }
+          // 记录 id/model/created
+          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;
+            const finish = 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);
+            }
+          }
+          // reasoning 加密块忽略
+        }
+        if (out) controller.enqueue(encoder.encode(out));
+      } catch {
+        closed = true;
+        try { controller.close(); } catch {}
+      }
+    },
+    cancel() {
+      closed = true;
+      try { reader.cancel(); } 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 });
+  try { out._t = res._t; } catch {}
+  return out;
+}

package/src/upstream.js

@@ -6,7 +6,7 @@ import { performance } from "node:perf_hooks";
 import { isFreeModel } from "./models.js";
 import { fmtShanghaiYMDHMS } from "./time.js";
 import { createTransport } from "./transport/index.js";
-import { isResponsesModel, chatToResponsesBody, toChatResponse } from "./upstream-responses.js";
+import { isResponsesModel, chatToResponsesBody, toChatResponse, reshapeResponsesSse } from "./upstream-responses.js";
 import { uuid } from "./compat.js";
 
 function genId(prefix) {
@@ -110,7 +110,7 @@ export function createUpstreamClient({
     const reqBody = isResp ? chatToResponsesBody(body) : body;
     const t0 = performance.now();
 
-    // 首发请求（transport 已处理 network/429 等重试）
+     // 首发请求（transport 已处理 network/429 等重试）
     let res;
     try {
       res = await transport.request({
@@ -151,15 +151,21 @@ export function createUpstreamClient({
           // responses 模型需转回 chat 形状（复用 upstream-responses）
           let outAnon = anonRes;
           if (isResp && anonRes.ok) {
-            try {
-              const txt = await anonRes.text();
-              const j = JSON.parse(txt);
-              if (j && Array.isArray(j.output)) {
-                outAnon = toChatResponse(anonRes, j);
-              } else {
-                outAnon = new Response(txt, { status: anonRes.status, headers: anonRes.headers });
-              }
-            } catch { outAnon = anonRes; }
+            const ctAnon = anonRes.headers.get("content-type") || "";
+            const isStreamAnon = body?.stream !== false && ctAnon.includes("text/event-stream");
+            if (isStreamAnon) {
+              outAnon = reshapeResponsesSse(anonRes, body.model);
+            } else {
+              try {
+                const txt = await anonRes.text();
+                const j = JSON.parse(txt);
+                if (j && Array.isArray(j.output)) {
+                  outAnon = toChatResponse(anonRes, j);
+                } else {
+                  outAnon = new Response(txt, { status: anonRes.status, headers: anonRes.headers });
+                }
+              } catch { outAnon = anonRes; }
+            }
           }
           outAnon._t = { ...(outAnon._t || {}), anonTried: true, anonAttempts: i + 1, totalMs: Math.round(performance.now() - t0) };
           consecutiveHits += 1;
@@ -180,6 +186,13 @@ export function createUpstreamClient({
 
     // responses 模型成功态转 chat（复用 upstream-responses）
     if (isResp && res.ok) {
+      const ct = res.headers.get("content-type") || "";
+      const isStream = body?.stream !== false && ct.includes("text/event-stream");
+      if (isStream) {
+        const transformed = reshapeResponsesSse(res, body.model);
+        transformed._t = { ...(res._t || {}), totalMs: Math.round(performance.now() - t0) };
+        return transformed;
+      }
       try {
         const txt = await res.text();
         const j = JSON.parse(txt);