mslxdff 0.1.113 → 0.1.115

package/package.json

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

package/src/chat-pipeline/auto-race.js

@@ -65,6 +65,7 @@ export async function runAutoRace(ctx, deps = {}) {
       const o = {};
       if (Object.keys(shareKeys).length) o.shareKeys = shareKeys;
       if (workbuddyUid) o.workbuddyUid = workbuddyUid;
+      if (handlerCtx?.sessionId) o.sessionId = handlerCtx.sessionId;
       r = await upstream.chat(f, Object.keys(o).length ? o : undefined);
     } catch (e) {
       if (plugins?.length) runHook(plugins, "upstream:response", { reqId, requested, model: m, status: null, ok: false, error: errMsg(e), timing: e?._t ?? null }).catch(() => {});

package/src/chat-pipeline/index.js

@@ -82,7 +82,11 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
       for (const e of sel.errors) evt("plugin-hook-error", { reqId, hook: "model:select", plugin: e.plugin, error: e.error });
     }
 
-    const handlerCtx = { reqId, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid };
+    // 客户端会话标识（opencode 插件 chat.headers 注入）→ 透传上游做粘性路由/缓存亲和；
+    // 无头时由 upstream.js 按对话首两条消息哈希兜底（不再每请求随机）
+    const clientSession = String(req?.headers?.["x-session-affinity"] || req?.headers?.["x-session-id"] || "").trim() || null;
+    const handlerCtx = { reqId, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid, sessionId: clientSession };
+    if (clientSession) evt("client-session", { reqId, sessionId: clientSession.slice(0, 24) });
 
     const plan = planRoute(policy, {
       candidates: order,

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

@@ -49,6 +49,8 @@ export async function runSerialTrial(ctx, deps = {}) {
   for (let idx = 0; idx < order.length; idx++) {
     const model = order[idx];
     handlerCtx.model = model;
+    handlerCtx.orderLen = order.length;
+    handlerCtx.idx = idx;
     evt("model-try", { reqId, model, idx, remaining: order.length - idx });
     if (plugins?.length) {
       const bt = await runHook(plugins, "model:beforeTry", { reqId, requested, model, idx, hops });
@@ -68,6 +70,7 @@ export async function runSerialTrial(ctx, deps = {}) {
       const chatOpts = {};
       if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
       if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
+      if (handlerCtx?.sessionId) chatOpts.sessionId = handlerCtx.sessionId;
       upRes = await upstream.chat(forwarded, Object.keys(chatOpts).length ? chatOpts : undefined);
       evt("upstream-done", { reqId, model, ok: !(upRes instanceof Error) && upRes.status < 400, status: upRes instanceof Error ? null : upRes.status, timing: upRes._t ?? null, error: null });
     } catch (err) {

package/src/model-capabilities/index.js

@@ -28,15 +28,22 @@ export function createCapabilitiesService({
 } = {}) {
   let raw = null;          // 原始目录（全 provider）
   let capsIndex = new Map(); // providerId -> { modelId -> caps }
+  let npmIndex = new Map();  // opencode 裸 modelId -> provider.npm（responses 判定用；null = 继承默认）
   let loadedAt = 0;
   let inflight = null;
 
   function buildIndex(data) {
     const idx = new Map();
+    const npm = new Map();
     for (const [pid, p] of Object.entries(data || {})) {
       if (!p || typeof p !== "object") continue;
-      idx.set(pid, normalizeProviderModels(p.models || {}));
+      const caps = normalizeProviderModels(p.models || {});
+      idx.set(pid, caps);
+      if (String(pid).toLowerCase() === "opencode") {
+        for (const [mid, c] of Object.entries(caps)) npm.set(mid, c.npm ?? null);
+      }
     }
+    npmIndex = npm;
     return idx;
   }
 
@@ -111,7 +118,7 @@ export function createCapabilitiesService({
     return [...capsIndex.keys()].sort();
   }
 
-  return { ready, get, list, providers };
+  return { ready, get, list, providers, npmIndex: () => new Map(npmIndex) };
 }
 
 // 模块级单例（与 globalDedup 同模式）：HTTP handler 懒加载，测试 _reset 后注入

package/src/model-capabilities/parse.js

@@ -24,6 +24,8 @@ export function normalizeModelCaps(_id, m) {
     releaseDate: typeof m?.release_date === "string" && m.release_date ? m.release_date : null,
     inputModalities: input.length ? input : ["text"],
     outputModalities: Array.isArray(m?.modalities?.output) && m.modalities.output.length ? m.modalities.output : ["text"],
+    // 模型级 SDK 覆盖（models.dev provider.npm）：@ai-sdk/openai → responses 端点；null = 继承 provider 默认
+    npm: typeof m?.provider?.npm === "string" && m.provider.npm ? m.provider.npm : null,
   };
 }
 

package/src/providers/dispatcher.js

@@ -53,9 +53,9 @@ export function createProviderDispatcher(providers = [], opts = {}) {
       return provider.chatWithKeys(forwarded, sharedKeys);
     }
     if (provider.id === "workbuddy" && workbuddyUid) {
-      return provider.chat(forwarded, { workbuddyUid });
+      return provider.chat(forwarded, { ...opts, workbuddyUid });
     }
-    return provider.chat(forwarded);
+    return provider.chat(forwarded, opts);
   }
 
   // 聚合所有供应商的模型列表；默认供应商（opencode）裸 id，其它带前缀

package/src/providers/opencode.js

@@ -8,7 +8,7 @@ export function createOpenCodeProvider({ upstream, modelsService, baseUrl, authT
   return {
     id: "opencode",
     upstream: client,
-    chat: (body) => client.chat(body),
+    chat: (body, opts) => client.chat(body, opts),
     preheat: (args) => client.preheat(args),
     close: () => client.close(),
     async listModels() {

package/src/responses/translate.js

@@ -33,15 +33,27 @@ export function responsesToChatBody(req = {}) {
   if (req.instructions) messages.push({ role: "system", content: String(req.instructions) });
   const input = req.input;
   const items = typeof input === "string" ? [{ type: "message", role: "user", content: input }] : Array.isArray(input) ? input : [];
+  // 加密思考往返：input 里的 reasoning item 挂到下一条 assistant 消息（thinking 跨轮必需，不能丢）
+  let pendingReasoning = [];
   for (const it of items) {
     if (!it || typeof it !== "object") continue;
+    if (it.type === "reasoning") {
+      if (it.id || it.encrypted_content) {
+        pendingReasoning.push({ id: it.id, encrypted_content: it.encrypted_content, summary: it.summary });
+      }
+      continue;
+    }
     if (it.type === "message") {
-      messages.push({ role: it.role || "user", content: inputTextOf(it.content) });
+      const msg = { role: it.role || "user", content: inputTextOf(it.content) };
+      if (pendingReasoning.length && msg.role === "assistant") { msg.reasoning_items = pendingReasoning; pendingReasoning = []; }
+      messages.push(msg);
     } else if (it.type === "function_call") {
-      messages.push({
+      const msg = {
         role: "assistant", content: "",
         tool_calls: [{ id: it.call_id || it.id || "", type: "function", function: { name: it.name || "", arguments: it.arguments || "" } }],
-      });
+      };
+      if (pendingReasoning.length) { msg.reasoning_items = pendingReasoning; pendingReasoning = []; }
+      messages.push(msg);
     } else if (it.type === "function_call_output") {
       messages.push({ role: "tool", tool_call_id: it.call_id || "", content: typeof it.output === "string" ? it.output : JSON.stringify(it.output ?? "") });
     }
@@ -115,7 +127,16 @@ export function createChunkTranslator(model = "") {
   let textLen = 0;
   let lastFinish = "stop";
   let lastUsage = null;
-  const tools = new Map(); // index → {id, name, args, announced}
+  const tools = new Map(); // index → {id, name, args, announced, outputIndex}
+  // output_index 按 item 出现顺序动态分配（reasoning 可能先于 message/tool 出现）
+  let nextIdx = 0;
+  let textIdx = null;
+  // 加密思考（thinking 跨轮）：sse.js 首帧带 x_reasoning_item（含加密态），translator 据此建 reasoning item
+  let reasoningOpen = false;
+  let reasoningId = null;
+  let reasoningEncrypted = null;
+  let reasoningIdx = null;
+  let reasoningText = "";
   const ev = (type, extra = {}) => ({ type, ...extra });
 
   function begin() {
@@ -125,8 +146,9 @@ export function createChunkTranslator(model = "") {
   function ensureTextItem() {
     if (textItemOpen) return [];
     textItemOpen = true;
+    textIdx = nextIdx++;
     const item = { type: "message", id: `msg_${id}`, status: "in_progress", role: "assistant", content: [{ type: "output_text", text: "", annotations: [] }] };
-    return [ev("response.output_item.added", { output_index: 0, item }), ev("response.content_part.added", { item_id: item.id, output_index: 0, content_index: 0, part: { type: "output_text", text: "", annotations: [] } })];
+    return [ev("response.output_item.added", { output_index: textIdx, item }), ev("response.content_part.added", { item_id: item.id, output_index: textIdx, content_index: 0, part: { type: "output_text", text: "", annotations: [] } })];
   }
 
   let fullText = "";
@@ -135,26 +157,51 @@ export function createChunkTranslator(model = "") {
     const out = ensureTextItem();
     textLen += delta.length;
     fullText += delta;
-    out.push(ev("response.output_text.delta", { item_id: `msg_${id}`, output_index: 0, content_index: 0, delta }));
+    out.push(ev("response.output_text.delta", { item_id: `msg_${id}`, output_index: textIdx, content_index: 0, delta }));
+    return out;
+  }
+
+  function pushReasoning(delta, meta) {
+    const out = ensureReasoningItem(meta);
+    reasoningText += delta;
+    if (delta) out.push(ev("response.reasoning_summary_text.delta", { item_id: reasoningId, output_index: reasoningIdx, summary_index: 0, delta }));
     return out;
   }
 
+  function ensureReasoningItem(meta) {
+    if (reasoningOpen) {
+      // 补丁：加密态可能晚到（sse.js 在收尾帧补发无文本的 x_reasoning_item）
+      if (!reasoningEncrypted && typeof meta?.encrypted_content === "string") reasoningEncrypted = meta.encrypted_content;
+      return [];
+    }
+    reasoningOpen = true;
+    reasoningId = meta?.id || `rs_${id}`;
+    reasoningEncrypted = typeof meta?.encrypted_content === "string" ? meta.encrypted_content : null;
+    reasoningIdx = nextIdx++;
+    const item = { type: "reasoning", id: reasoningId, summary: [], ...(reasoningEncrypted ? { encrypted_content: reasoningEncrypted } : {}) };
+    return [
+      ev("response.output_item.added", { output_index: reasoningIdx, item }),
+      ev("response.reasoning_summary_part.added", { item_id: reasoningId, output_index: reasoningIdx, summary_index: 0, part: { type: "summary_text", text: "" } }),
+    ];
+  }
+
   function pushTool(tc) {
     const idx = Number(tc.index ?? 0);
     let t = tools.get(idx);
-    if (!t) { t = { id: "", name: "", args: "", announced: false }; tools.set(idx, t); }
+    if (!t) { t = { id: "", name: "", args: "", announced: false, outputIndex: null }; tools.set(idx, t); }
     if (tc.id) t.id = tc.id;
     if (tc.function?.name) t.name += tc.function.name;
     const frag = tc.function?.arguments || "";
     const out = [];
     if (!t.announced && t.id && t.name) {
       t.announced = true;
-      out.push(ev("response.output_item.added", { output_index: idx + 1, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: "" } }));
+      t.outputIndex = nextIdx++;
+      out.push(ev("response.output_item.added", { output_index: t.outputIndex, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: "" } }));
     }
     if (frag) {
       if (!t.announced) { t.args += frag; return out; } // id/name 未到先攒着
       t.args += frag;
-      out.push(ev("response.function_call_arguments.delta", { item_id: `fc_${id}_${idx}`, output_index: idx + 1, delta: frag }));
+      out.push(ev("response.function_call_arguments.delta", { item_id: `fc_${id}_${idx}`, output_index: t.outputIndex, delta: frag }));
     }
     return out;
   }
@@ -181,29 +228,34 @@ export function createChunkTranslator(model = "") {
       if (typeof delta.content === "string" && delta.content) { dbg.textChars += delta.content.length; out.push(...pushText(delta.content)); }
       for (const tc of delta.tool_calls || []) { dbg.toolDeltas++; out.push(...pushTool(tc)); }
       const rc = typeof delta.reasoning_content === "string" ? delta.reasoning_content : "";
-      if (rc) { dbg.reasoningChars += rc.length; out.push(...pushText(rc)); }
+      if (rc || chunk.x_reasoning_item) { if (rc) dbg.reasoningChars += rc.length; out.push(...pushReasoning(rc, chunk.x_reasoning_item)); }
     }
     return out;
   }
 
   function end({ finish = "stop", usage = null } = {}) {
     const out = [];
+    if (reasoningOpen) {
+      out.push(ev("response.reasoning_summary_text.done", { item_id: reasoningId, output_index: reasoningIdx, summary_index: 0, text: reasoningText }));
+      out.push(ev("response.reasoning_summary_part.done", { item_id: reasoningId, output_index: reasoningIdx, summary_index: 0, part: { type: "summary_text", text: reasoningText } }));
+      out.push(ev("response.output_item.done", { output_index: reasoningIdx, item: { type: "reasoning", id: reasoningId, summary: [{ type: "summary_text", text: reasoningText }], ...(reasoningEncrypted ? { encrypted_content: reasoningEncrypted } : {}) } }));
+    }
     if (textItemOpen) {
-      out.push(ev("response.output_text.done", { item_id: `msg_${id}`, output_index: 0, content_index: 0, text: fullText }));
-      out.push(ev("response.content_part.done", { item_id: `msg_${id}`, output_index: 0, content_index: 0, part: { type: "output_text", text: fullText, annotations: [] } }));
-      out.push(ev("response.output_item.done", { output_index: 0, item: { type: "message", id: `msg_${id}`, status: "completed", role: "assistant", content: [{ type: "output_text", text: fullText, annotations: [] }] } }));
+      out.push(ev("response.output_text.done", { item_id: `msg_${id}`, output_index: textIdx, content_index: 0, text: fullText }));
+      out.push(ev("response.content_part.done", { item_id: `msg_${id}`, output_index: textIdx, content_index: 0, part: { type: "output_text", text: fullText, annotations: [] } }));
+      out.push(ev("response.output_item.done", { output_index: textIdx, item: { type: "message", id: `msg_${id}`, status: "completed", role: "assistant", content: [{ type: "output_text", text: fullText, annotations: [] }] } }));
     }
-    let i = 0;
     for (const [idx, t] of tools) {
-      if (!t.id && !t.name && !t.args) { i++; continue; }
+      if (!t.id && !t.name && !t.args) continue;
       if (!t.announced) {
-        out.push(ev("response.output_item.added", { output_index: idx + 1, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: "" } }));
+        t.announced = true;
+        t.outputIndex = nextIdx++;
+        out.push(ev("response.output_item.added", { output_index: t.outputIndex, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: "" } }));
       }
-      if (t.args) out.push(ev("response.function_call_arguments.done", { item_id: `fc_${id}_${idx}`, output_index: idx + 1, arguments: t.args }));
-      out.push(ev("response.output_item.done", { output_index: idx + 1, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: t.args, status: "completed" } }));
-      i++;
+      if (t.args) out.push(ev("response.function_call_arguments.done", { item_id: `fc_${id}_${idx}`, output_index: t.outputIndex, arguments: t.args }));
+      out.push(ev("response.output_item.done", { output_index: t.outputIndex, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: t.args, status: "completed" } }));
     }
-    void i; void textLen;
+    void textLen;
     out.push(ev("response.completed", { response: { id, object: "response", created_at: createdAt, status: finish === "length" ? "incomplete" : "completed", model, output: [], usage: toResponsesUsage(usage) } }));
     return out;
   }

package/src/routes/chat/relay-pipeline.js

@@ -3,6 +3,13 @@ import { recordModelStats } from "../../state.js";
 import { normalizeFullId } from "../../providers/model-id.js";
 import { computeMetrics, extractUsageFromJson, extractUsageFromSseText } from "../../metrics.js";
 
+// 唯一/最后候选没有 failover 去向：首块闸门退化为纯"防连接泄漏"，放宽避免误杀慢模型
+// （参考 opencode：zen 通道不设超时；openai responses 硬编码 300s headerTimeout）
+const LAST_CANDIDATE_TIMEOUT_MS = (() => {
+  const n = Number(process.env.MSLXDFF_LAST_CANDIDATE_TIMEOUT_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 120_000;
+})();
+
 /**
  * RelayPipeline 深模块
  * 把 5 个 handler 各自的 fallback→relay→scoring→事件 6段流水收敛为单一真相。
@@ -72,9 +79,16 @@ export function createRelayPipeline({
     }
     _evt("relay-start", { reqId, model: actual, via, isStream: Boolean(body?.stream), fallback });
 
-    // 3. relay
+    // 3. relay（唯一/最后候选：无 failover 去向 → 闸门放宽到防泄漏级别）
+    const orderLen = handlerCtx?.orderLen;
+    const curIdx = handlerCtx?.idx;
+    const isLastCandidate =
+      Number.isInteger(orderLen) && orderLen > 0 &&
+      (orderLen === 1 || (Number.isInteger(curIdx) && curIdx >= orderLen - 1));
+    const streamTimeoutMs = isLastCandidate ? LAST_CANDIDATE_TIMEOUT_MS : C.STREAM_TIMEOUT_MS;
     const out = await _relay(res, upRes, body, {
       fallback,
+      streamTimeoutMs,
       onFirstChunk: (delta) => {
         try { markFn(`ttf-${actual}`); } catch {}
         _evt("relay-first-chunk", { reqId, model: actual, ttfMs: delta, via });
@@ -99,12 +113,12 @@ export function createRelayPipeline({
     });
 
     // 5a. 首块超时未写字节 → 回退
-    if (out.status === C.STREAM_TIMEOUT_MS) {
-      if (auto) try { await auto.recordError(actual, { status: 502, slow: true, note: `stream timeout ${C.STREAM_TIMEOUT_MS}ms` }); } catch {}
-      try { _logError(actual, 502, `stream timeout ${C.STREAM_TIMEOUT_MS}ms`); } catch {}
+    if (streamTimeoutMs > 0 && out.status === streamTimeoutMs) {
+      if (auto) try { await auto.recordError(actual, { status: 502, slow: true, note: `stream timeout ${streamTimeoutMs}ms` }); } catch {}
+      try { _logError(actual, 502, `stream timeout ${streamTimeoutMs}ms`); } catch {}
       _evt("upstream-error", { reqId, model: actual, status: 502, message: "stream timeout", timing: null });
       _evt("fallback", { reqId, from: actual, to: null, reason: "stream timeout" });
-      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `stream timed out after ${C.STREAM_TIMEOUT_MS}ms` } };
+      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `stream timed out after ${streamTimeoutMs}ms` } };
     }
 
     // 5b. 中断（stall 超时 / max 流时长）

package/src/routes/stream.js

@@ -11,6 +11,14 @@ function chunkText(chunk) {
   return "";
 }
 
+// body.cancel() 可能返回非 Promise（自定义/AI SDK 流）——同步异常与 rejection 双路径都要吞掉
+function cancelBody(body) {
+  try {
+    const p = typeof body?.cancel === "function" ? body.cancel() : null;
+    if (p && typeof p.catch === "function") p.catch(() => {});
+  } catch { /* ignore */ }
+}
+
 export const SLOW_TOTAL_MS = (() => {
   const n = Number(process.env.MSLXDFF_SLOW_TOTAL_MS);
   return Number.isInteger(n) && n > 0 ? n : 20_000;
@@ -18,7 +26,14 @@ export const SLOW_TOTAL_MS = (() => {
 
 export const STREAM_TIMEOUT_MS = (() => {
   const n = Number(process.env.MSLXDFF_STREAM_TIMEOUT_MS);
-  return Number.isInteger(n) && n > 0 ? n : 25_000;
+  // 0 = 显式关闭首块超时（慢思考模型专用）；未设/非法值 → 默认 25s
+  return Number.isInteger(n) && n >= 0 ? n : 25_000;
+})();
+
+// 等首块期间的心跳间隔（SSE 注释帧，标准客户端忽略）：上游偶发卡 90s+，避免客户端误判卡死/断连
+export const KEEPALIVE_MS = (() => {
+  const n = Number(process.env.MSLXDFF_KEEPALIVE_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 10_000;
 })();
 
 export const STALL_TIMEOUT_MS = (() => {
@@ -37,7 +52,7 @@ export const MAX_STREAM_MS = (() => {
   return Number.isInteger(n) && n > 0 ? n : 0;
 })();
 
-export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, streamTimeoutMs = STREAM_TIMEOUT_MS, fallback } = {}) {
+export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, streamTimeoutMs = STREAM_TIMEOUT_MS, keepaliveMs = KEEPALIVE_MS, fallback } = {}) {
   const t0 = performance.now();
   const contentType = upRes.headers.get("content-type") || "";
   // 需同时满足：客户端要流 + 上游真的是 SSE；避免 muse-spark 聚合 JSON 被误判为流式，或 workbuddy SSE 被聚合
@@ -75,6 +90,7 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
     downstreamClosed: false,
     usage: null,
     chars: 0,
+    recoveries: 0,
   };
   let prevChunkAt = t0;
   const onClose = () => {
@@ -100,26 +116,34 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
       let stalled = false;
       let tooLong = false;
       let stallTimer = null;
+      let pingTimer = keepaliveMs > 0
+        ? setInterval(() => {
+            if (wroteAny) return;
+            try { res.write(": keepalive\n\n"); } catch { /* ignore */ }
+          }, keepaliveMs)
+        : null;
       const armStall = () => {
         if (stallTimer) clearTimeout(stallTimer);
         stallTimer = STALL_TIMEOUT_MS
           ? setTimeout(() => {
               stalled = true;
               detail.exitReason = "stall";
-              if (typeof upRes.body.cancel === "function") upRes.body.cancel().catch(() => {});
+              cancelBody(upRes.body);
             }, STALL_TIMEOUT_MS)
           : null;
       };
-      let firstTimer = setTimeout(() => {
-        timedOut = true;
-        detail.exitReason = "first-timeout";
-        if (typeof upRes.body.cancel === "function") upRes.body.cancel().catch(() => {});
-      }, streamTimeoutMs);
+      let firstTimer = streamTimeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            detail.exitReason = "first-timeout";
+            cancelBody(upRes.body);
+          }, streamTimeoutMs)
+        : null;
       const maxTimer = MAX_STREAM_MS
         ? setTimeout(() => {
             tooLong = true;
             detail.exitReason = "max";
-            if (typeof upRes.body.cancel === "function") upRes.body.cancel().catch(() => {});
+            cancelBody(upRes.body);
           }, MAX_STREAM_MS)
         : null;
       try {
@@ -177,6 +201,15 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
               } catch {}
             }
           } catch { /* ignore */ }
+          // 首块/空闲超时后上游仍吐出了数据 → 只是慢，不是死：撤销超时判定，照常转发
+          //（cancel 是协作式的，缓冲数据仍会到达；丢掉已到达的数据是纯损失）
+          if (timedOut || stalled) {
+            timedOut = false;
+            stalled = false;
+            detail.recoveries = (detail.recoveries || 0) + 1;
+            if (detail.exitReason === "first-timeout" || detail.exitReason === "stall") detail.exitReason = null;
+            if (firstTimer) { clearTimeout(firstTimer); firstTimer = null; }
+          }
           if (timedOut || stalled || tooLong) break;
           if (first) {
             first = false;
@@ -213,10 +246,11 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
         if (firstTimer) clearTimeout(firstTimer);
         if (maxTimer) clearTimeout(maxTimer);
         if (stallTimer) clearTimeout(stallTimer);
+        if (pingTimer) clearInterval(pingTimer);
       }
       if (timedOut && !wroteAny) {
         res.removeListener("close", onClose);
-        return { status: STREAM_TIMEOUT_MS, ttfMs: null, totalMs: Math.round(performance.now() - t0), aborted: true, interrupted: false, detail };
+        return { status: streamTimeoutMs, ttfMs: null, totalMs: Math.round(performance.now() - t0), aborted: true, interrupted: false, detail };
       }
       if ((stalled || tooLong) && wroteAny) {
         interrupted = true;

package/src/runtime/server-lifecycle.js

@@ -115,6 +115,24 @@ export async function startServerLifecycle({ VERSION, token, created, upstream,
     }).catch(() => {});
   }, 100).unref?.();
 
+  // responses 模型判定改元数据驱动（models.dev provider.npm）：就绪后注入，每小时重查使新模型自动识别
+  void (async () => {
+    try {
+      const { globalCapabilities } = await import("../model-capabilities/index.js");
+      const { setResponsesNpmIndex } = await import("../upstream-responses.js");
+      const svc = globalCapabilities();
+      const apply = () => setResponsesNpmIndex(svc.npmIndex());
+      await svc.ready();
+      apply();
+      const entry = { ts: Date.now(), type: "responses-npm-index", models: svc.npmIndex().size };
+      try { bus.emit(entry); } catch {}
+      try { logs.appendEvent(entry); } catch {}
+      setInterval(() => { svc.ready().then(apply).catch(() => {}); }, 60 * 60 * 1000).unref?.();
+    } catch (e) {
+      try { logs.appendEvent({ ts: Date.now(), type: "responses-npm-index-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
+    }
+  })();
+
   models.startAutoRefresh();
   if (process.env.MSLXDFF_DAEMON) {
     writePid(process.pid, VERSION);

package/src/upstream-engine/sdk/attempt.js

@@ -57,9 +57,9 @@ export function errorResponseFromSdkError(e, { marker = null } = {}) {
   });
 }
 
-// SDK parts → OpenAI SSE Response（chat/responses 共用同一序列化器）。
-export function streamResponseFromParts(parts, { marker = null, clock = Date.now, t0 = clock() } = {}) {
-  const ser = createSseSerializer();
+// SDK parts → OpenAI SSE Response（chat/responses 共用同一序列化器；captured 为 responses 侧信道）。
+export function streamResponseFromParts(parts, { marker = null, clock = Date.now, t0 = clock(), captured = null } = {}) {
+  const ser = createSseSerializer(captured);
   const enc = new TextEncoder();
   let cancelled = false;
   const stream = new ReadableStream({
@@ -67,6 +67,11 @@ export function streamResponseFromParts(parts, { marker = null, clock = Date.now
       try {
         for await (const part of parts) {
           if (cancelled) break;
+          // 侧信道（captured）可能落后几毫秒：收尾前给 encrypted 一点就绪时间（最多 150ms）
+          if (captured && !captured.reasoning && part?.type === "finish") {
+            const tw = Date.now();
+            while (!captured.reasoning && Date.now() - tw < 150) await new Promise((r) => setTimeout(r, 10));
+          }
           const text = ser.push(part);
           if (text) controller.enqueue(enc.encode(text));
         }

package/src/upstream-engine/sdk/convert.js

@@ -52,7 +52,21 @@ export function toModelPrompt(messages) {
       const parts = [];
       const text = textOf(m.content);
       if (text) parts.push({ type: "text", text });
-      if (m.reasoning_content) parts.push({ type: "reasoning", text: String(m.reasoning_content) });
+      // 带加密态的 reasoning items（responses 通道思考跨轮）：AI SDK 会转成上游要的 encrypted reasoning item。
+      // 无加密态时才退回纯文本 reasoning（chat 通道的 reasoning_content）。
+      const items = Array.isArray(m.reasoning_items) ? m.reasoning_items : [];
+      let pushedEncrypted = false;
+      for (const r of items) {
+        if (!r || typeof r !== "object") continue;
+        const summaryText = Array.isArray(r.summary) ? r.summary.map((s) => s?.text || "").join("\n") : "";
+        parts.push({
+          type: "reasoning",
+          text: summaryText || " ",
+          providerOptions: { openai: { itemId: r.id, reasoningEncryptedContent: r.encrypted_content } },
+        });
+        pushedEncrypted = true;
+      }
+      if (!pushedEncrypted && m.reasoning_content) parts.push({ type: "reasoning", text: String(m.reasoning_content) });
       for (const tc of Array.isArray(m.tool_calls) ? m.tool_calls : []) {
         if (!tc || typeof tc !== "object") continue;
         parts.push({

package/src/upstream-engine/sdk/responses.js

@@ -8,6 +8,50 @@ import { ENGINE_MARKER } from "./chat.js";
 
 export const RESPONSES_CHAT_PATH = "/zen/v1/responses";
 
+// 上游 encrypted reasoning 只在 output_item.done 里给，而 AI SDK 仅在有 summary 文本时才透出到 parts
+// （muse-spark 这类无 summary 的思考模型会被吞掉）。这里在 fetch 层 tee 一份原始 SSE 自行解析，
+// 侧信道把加密思考交给序列化器，收尾帧补发。
+function captureReasoningFetch(baseFetch, sink) {
+  const dbg = process.env.MSLXDFF_RESPONSES_DEBUG === "1";
+  return async (input, init) => {
+    const res = await baseFetch(input, init);
+    const ct = res.headers.get("content-type") || "";
+    if (dbg) console.log(`[capture] enter ct=${ct} hasBody=${Boolean(res.body)}`);
+    if (!ct.includes("text/event-stream") || !res.body) return res;
+    const [passthrough, probe] = res.body.tee();
+    (async () => {
+      const reader = probe.getReader();
+      const dec = new TextDecoder();
+      let buf = "";
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buf += dec.decode(value, { stream: true });
+          let nl;
+          while ((nl = buf.indexOf("\n")) >= 0) {
+            const line = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!line.startsWith("data:")) continue;
+            const d = line.slice(5).trim();
+            if (!d || d === "[DONE]") continue;
+            try {
+              const j = JSON.parse(d);
+              if (dbg && j.type === "response.output_item.done") console.log(`[capture] item.done type=${j.item?.type} enc=${typeof j.item?.encrypted_content}`);
+              if (j.type === "response.output_item.done" && j.item?.type === "reasoning" && typeof j.item.encrypted_content === "string") {
+                sink.reasoning = { id: j.item.id, encrypted: j.item.encrypted_content, summary: j.item.summary ?? [] };
+                if (dbg) console.log(`[capture] hit id=${String(j.item.id).slice(0, 24)} len=${j.item.encrypted_content.length}`);
+              }
+            } catch { /* ignore */ }
+          }
+        }
+      } catch { /* ignore */ }
+      if (dbg) console.log(`[capture] stream end captured=${sink.reasoning ? "yes" : "no"}`);
+    })();
+    return new Response(passthrough, { status: res.status, statusText: res.statusText, headers: res.headers });
+  };
+}
+
 let sdkPromise = null;
 
 export function loadOpenAISdk() {
@@ -37,19 +81,34 @@ export async function attemptOnceResponsesSdk({
     throw err;
   }
   // headers 由调用方构造（含 Authorization），headers 优先于 apiKey 默认头
+  const captured = { reasoning: null };
+  const baseFetch = fetchImpl ?? ((u, i) => globalThis.fetch(u, i));
   const provider = createOpenAI({
     name: providerName,
     baseURL,
     apiKey: "public",
     headers: sanitizeHeaders(headers),
-    ...(fetchImpl ? { fetch: fetchImpl } : {}),
+    fetch: captureReasoningFetch(baseFetch, captured),
   });
   const model = provider.responses(String(body?.model || ""));
+  const params = toModelParams(body, providerName);
+  // 无状态 + 加密思考回传（thinking 跨轮）：上游把思考以加密块发回，客户端持有并每轮带回。
+  // AI SDK responses 的 providerOptionsName 对非 azure 硬编码为 "openai"（dist/index.js:5240）。
+  const providerOptions = {
+    ...(params.providerOptions || {}),
+    openai: {
+      store: false,
+      include: ["reasoning.encrypted_content"],
+      reasoningSummary: "auto",
+      ...((params.providerOptions || {}).openai || {}),
+    },
+  };
   let res;
   try {
     res = await model.doStream({
       prompt: toModelPrompt(body?.messages),
-      ...toModelParams(body, providerName),
+      ...params,
+      providerOptions,
       tools: toModelTools(body?.tools),
       toolChoice: toModelToolChoice(body?.tool_choice),
     });
@@ -58,7 +117,7 @@ export async function attemptOnceResponsesSdk({
     if (mapped) return mapped;
     throw e;
   }
-  return streamResponseFromParts(res.stream, { marker, clock, t0 });
+  return streamResponseFromParts(res.stream, { marker, clock, t0, captured });
 }
 
 export function createSdkResponses({

package/src/upstream-engine/sdk/sse.js

@@ -32,14 +32,18 @@ export function usageToOpenAI(u) {
   return out;
 }
 
-export function createSseSerializer() {
+export function createSseSerializer(captured = null) {
   const meta = { id: "chatcmpl-wb-sdk", model: "", created: Math.floor(Date.now() / 1000) };
   let roleSent = false;
   let nextIndex = 0;
   const toolIndex = new Map();
   const toolDeltaIds = new Set();
+  // 加密思考往返：reasoning-start 的 providerMetadata 带 itemId + 加密态，随首帧透出
+  let reasoningMeta = null;
+  let reasoningFrameSent = false;
+  let reasoningEncSent = false;
 
-  function frame(delta, { finishReason = null, usage } = {}) {
+  function frame(delta, { finishReason = null, usage, extra } = {}) {
     const obj = {
       id: meta.id,
       object: "chat.completion.chunk",
@@ -48,6 +52,7 @@ export function createSseSerializer() {
       choices: [{ index: 0, delta, finish_reason: finishReason }],
     };
     if (usage !== undefined) obj.usage = usage;
+    if (extra) Object.assign(obj, extra);
     return `data: ${JSON.stringify(obj)}\n\n`;
   }
 
@@ -69,8 +74,30 @@ export function createSseSerializer() {
         }
         return null;
       }
-      case "reasoning-delta":
-        return ensureRole() + frame({ reasoning_content: String(part.delta ?? "") });
+      case "reasoning-start": {
+        const pm = part.providerMetadata?.openai || part.providerMetadata || {};
+        reasoningMeta = {
+          id: String(pm.itemId ?? part.id ?? "reasoning"),
+          encrypted: typeof pm.reasoningEncryptedContent === "string" ? pm.reasoningEncryptedContent : null,
+        };
+        // 即时透出 item 元数据（含加密态）：上游可能只给 encrypted 不给 summary 文本，不能等 delta
+        reasoningFrameSent = true;
+        if (reasoningMeta.encrypted) reasoningEncSent = true;
+        return ensureRole() + frame({ reasoning_content: "" }, { extra: { x_reasoning_item: { id: reasoningMeta.id, encrypted_content: reasoningMeta.encrypted } } });
+      }
+      case "reasoning-delta": {
+        const delta = String(part.delta ?? "");
+        let extra;
+        if (reasoningMeta && !reasoningFrameSent) {
+          reasoningFrameSent = true;
+          if (reasoningMeta.encrypted) reasoningEncSent = true;
+          // x_reasoning_item：responses translator 据此建 reasoning item（chat 客户端忽略未知顶层字段）
+          extra = { x_reasoning_item: { id: reasoningMeta.id, encrypted_content: reasoningMeta.encrypted } };
+        } else if (reasoningMeta) {
+          extra = { x_reasoning_id: reasoningMeta.id };
+        }
+        return ensureRole() + frame({ reasoning_content: delta }, { extra });
+      }
       case "text-delta":
         return ensureRole() + frame({ content: String(part.delta ?? "") });
       case "tool-input-start": {
@@ -98,7 +125,14 @@ export function createSseSerializer() {
         const fr = part.finishReason;
         const raw = typeof fr === "string" ? fr : (fr?.raw ?? fr?.unified);
         const reason = raw === "tool-calls" ? "tool_calls" : raw === "content-filter" ? "content_filter" : (raw ?? "stop");
-        return frame({}, { finishReason: reason, usage: usageToOpenAI(part.usage) });
+        // 加密思考补发：上游 encrypted_content 只在流末尾可得（fetch 侧信道捕获），
+        // 无 summary 文本时 AI SDK parts 不会带出 → 收尾帧前补一帧
+        let pre = "";
+        if (captured?.reasoning && !reasoningEncSent) {
+          reasoningEncSent = true;
+          pre = ensureRole() + frame({ reasoning_content: "" }, { extra: { x_reasoning_item: { id: captured.reasoning.id, encrypted_content: captured.reasoning.encrypted } } });
+        }
+        return pre + frame({}, { finishReason: reason, usage: usageToOpenAI(part.usage) });
       }
       case "error": {
         const message = part.error?.message

package/src/upstream-responses.js

@@ -2,8 +2,26 @@
  * responses 转换层 — 从 upstream.js 抽出的 muse-spark 专用形状转换。
  * chat ⇄ responses 互转纯函数，无网络、无副作用。
  */
+// responses 判定索引（models.dev 模型级 provider.npm，启动时注入）：
+// "@ai-sdk/openai" → responses 端点；未注入/未命中 → 前缀兜底（新模型早于 models.dev 刷新时仍可用）。
+let responsesNpmIndex = null;
+
+export function setResponsesNpmIndex(idx) {
+  responsesNpmIndex = idx instanceof Map ? idx : null;
+}
+
+export function _resetResponsesNpmIndex() {
+  responsesNpmIndex = null;
+}
+
 export function isResponsesModel(model) {
-  return String(model || "").toLowerCase().startsWith("muse-spark");
+  const m = String(model || "").toLowerCase().trim();
+  if (!m) return false;
+  if (responsesNpmIndex) {
+    const bare = m.replace(/^opencode\//, "");
+    if (responsesNpmIndex.has(bare)) return responsesNpmIndex.get(bare) === "@ai-sdk/openai";
+  }
+  return m.startsWith("muse-spark");
 }
 
 export function chatToResponsesBody(chatBody) {

package/src/upstream.js

@@ -12,6 +12,24 @@ import { uuid } from "./compat.js";
 function genId(prefix) {
   return `${prefix}${uuid().replace(/-/g, "")}`;
 }
+// 上游按 session 做粘性路由（实测：固定 session 两次请求均 ~1.2s；每次随机时可能撞冷机器 26s+）。
+// 客户端（opencode AI SDK 路径）不带会话标识 → 用对话首两条消息（system + 首条 user）哈希做稳定会话：
+// 同一会话多轮里这两条不变 ⇒ 路由亲和稳定；不同会话天然分散。
+function sessionFromMessages(messages) {
+  try {
+    const msgs = Array.isArray(messages) ? messages : [];
+    const pick = (role) => {
+      const m = msgs.find((x) => x?.role === role);
+      if (!m) return "";
+      return typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
+    };
+    const seed = `${pick("system")}|${pick("user")}`.slice(0, 4000);
+    if (seed === "|") return null;
+    return `ses_${crypto.createHash("sha1").update(seed).digest("hex").slice(0, 32)}`;
+  } catch {
+    return null;
+  }
+}
 function envInt(name, fallback) {
   const v = Number(process.env[name]);
   return Number.isInteger(v) && v > 0 ? v : fallback;
@@ -47,13 +65,16 @@ export function createOpencodeHeaderBuilder({ authToken = "public", env = proces
         Authorization: `Bearer ${authToken}`,
         "x-opencode-client": "desktop",
       };
-  function buildHeaders(body, { anonymous = anonFirst } = {}) {
+  // 无 messages 可哈希时的进程级兜底：至少 daemon 生命周期内稳定，不再每请求随机
+  const FALLBACK_SESSION = genId("ses_");
+  function buildHeaders(body, { anonymous = anonFirst, sessionId = null } = {}) {
     const isStream = body?.stream !== false;
+    const session = sessionId || sessionFromMessages(body?.messages) || FALLBACK_SESSION;
     const base = {
       ...baseHeaders,
       Accept: isStream ? "text/event-stream" : "*/*",
       "User-Agent": "opencode",
-      "x-opencode-session": genId("ses_"),
+      "x-opencode-session": session,
       "x-opencode-request": genId("msg_"),
       "x-opencode-project": "global",
     };
@@ -111,8 +132,10 @@ export function createUpstreamClient({
     hooks,
   });
 
-  async function chat(body) {
+  async function chat(body, opts = {}) {
     const isResp = isResponsesModel(body?.model);
+    // responses 路径的 reqBody 无 messages，会话哈希必须基于原始 chat body 计算
+    const sessionId = opts?.sessionId || sessionFromMessages(body?.messages) || null;
     const url = isResp ? `${baseUrl}/zen/v1/responses` : `${baseUrl}/zen/v1/chat/completions`;
     const reqBody = isResp ? chatToResponsesBody(body) : body;
     const t0 = performance.now();
@@ -123,7 +146,7 @@ export function createUpstreamClient({
       res = await transport.request({
         url,
         method: "POST",
-        headers: buildHeaders(reqBody),
+        headers: buildHeaders(reqBody, { sessionId }),
         body: reqBody,
         stream: body?.stream !== false,
         timeoutMs: connectTimeoutMs,
@@ -145,7 +168,7 @@ export function createUpstreamClient({
           anonRes = await transport.request({
             url,
             method: "POST",
-            headers: buildHeaders(reqBody, { anonymous: true }),
+            headers: buildHeaders(reqBody, { anonymous: true, sessionId }),
             body: reqBody,
             stream: body?.stream !== false,
             timeoutMs: connectTimeoutMs,