mslxdff 0.1.145 → 0.1.148

package/package.json

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

package/src/providers/cline/chat.js

@@ -170,18 +170,21 @@ export function createChatService({
     const sessionId = genSessionId();
     const isStream = body?.stream === true;
     const upstreamModel = stripProviderPrefix(model, id);
-    // token 口径双写：对标官方 withMaxCompletionTokensForReasoningModels——
-    // cline 上游默认 reasoning_effort high，推理模型认 max_completion_tokens，
-    // 只发 max_tokens 会被部分通道拒；双写兼容最稳。
-    const tokLimit = body?.max_tokens || body?.max_completion_tokens || 4096;
+    // token 上限对标 dsh-cline-pass（DEFAULT_MAX_TOKENS=32000）：客户端显式 max 优先，
+    // 缺省给 32000 而非 4096——旧 4096 默认会在长文处 finish=length 拦腰截断（2026-09-23 实测）。
+    // reasoning_effort 缺省不发（dsh 同款：调用方自选 none→max，不替上游做 high 假设；
+    // 高推理+小预算双挤是超大上下文秒回超短答的推手之一）；max_completion_tokens 双写保留
+    //（只发 max_tokens 会被部分通道拒，历史教训）。
+    const tokLimit = body?.max_tokens || body?.max_completion_tokens || 32000;
     const upstreamBody = {
       model: upstreamModel,
       max_tokens: tokLimit,
       max_completion_tokens: tokLimit,
       session_id: sessionId,
-      reasoning_effort: body?.reasoning_effort || body?.reasoningEffort || "high",
       messages: body?.messages || [],
     };
+    const effort = body?.reasoning_effort || body?.reasoningEffort;
+    if (effort) upstreamBody.reasoning_effort = effort;
     // 部分免费通道（deepseek 家族，含 cline-free/deepseek-*）原生非流式不可靠
     //（500 empty response）：这类模型在内部走 stream+聚合成 JSON，对外仍按请求方
     // stream 标志返回（true 直透，false 聚合）。其它模型完全尊重请求方，不强制。

package/src/providers/qoder/index.js

@@ -81,20 +81,63 @@ export function createQoderProvider({
     return chatSvc.runChat(stripped, picked.sess, picked.region);
   }
 
-  async function listModels() {
-    const picked = pickSession();
-    if (!picked) return [];
-    try { return await modelsSvc.listModels(picked.sess, picked.region); } catch { return []; }
-  }
-
-  async function preheat() {
-    try {
-      const picked = pickSession();
-      if (!picked) return { ok: false, error: "no account" };
-      await modelsSvc.listModels(picked.sess, picked.region);
-      return { ok: true };
-    } catch (e) { return { ok: false, error: String(e?.message || e).slice(0, 120) }; }
-  }
+   // 全号聚合：双号分属 cn/global 两区，模型表各不同（cn 14 个/global 15 个）；
+   // 只取单号会漏另一区（如轮询到 global 就看不到 cn 独有的 q37fmodel/gm51model）。
+   // 按 id 并集去重，只返回 enable=true 的可调用模型（过滤已下沉到 models.js）。
+   function eachCred() {
+     const out = [];
+     const seen = new Set();
+     const push = (blob, auth) => {
+       if (!blob?.deviceToken || seen.has(blob.deviceToken)) return;
+       seen.add(blob.deviceToken);
+       out.push({ blob, auth: auth || {} });
+     };
+     for (const k of keys) {
+       const blob = accountFromBlob(k);
+       if (!blob?.deviceToken) continue;
+       const auth = authList.find((a) => String(a?.refreshToken || "") === String(blob.refreshToken || "")) || authList[0] || {};
+       push(blob, auth);
+     }
+     if (!out.length) {
+       // keys 为空但 auth 目录有号（如 state 被外部改写）：从落盘 doc 合成凭据，目录不断即可出列表
+       try {
+         for (const { uid, doc } of listAccountDocs()) {
+           const a = doc?.auth || {};
+           if (!a.deviceToken) continue;
+           push({ deviceToken: a.deviceToken, refreshToken: a.refreshToken || "" },
+             { uid, name: doc?.account?.name || "", region: a.region || "global", refreshToken: a.refreshToken || "" });
+         }
+       } catch {}
+     }
+     return out;
+   }
+ 
+   async function listModels() {
+     const creds = eachCred();
+     if (!creds.length) return [];
+     const seen = new Set();
+     const out = [];
+     for (const { blob, auth } of creds) {
+       const region = normalizeRegion(region0 || auth.region || "global");
+       const sess = buildSessionFor({ ...blob, uid: auth.uid, name: auth.name, region });
+       try {
+         const list = await modelsSvc.listModels(sess, region);
+         for (const m of list) {
+           if (!m?.id || seen.has(m.id)) continue;
+           seen.add(m.id);
+           out.push(m);
+         }
+       } catch {}
+     }
+     return out;
+   }
+ 
+   async function preheat() {
+     try {
+       const list = await listModels();
+       return list.length ? { ok: true } : { ok: false, error: "no account" };
+     } catch (e) { return { ok: false, error: String(e?.message || e).slice(0, 120) }; }
+   }
 
   async function close() {}
   async function chatWithKeys(body, keysOverride) {

package/src/providers/qoder/models.js

@@ -1,5 +1,5 @@
-// qoder 模型服务（转译 bridge.go ListModels/extractModels）：原生 COSY 签名拉 /model/list，
-// 10min 缓存；暴露全部 15 个 key（含 enable=false 的展示，allowlist 由上层过滤）。
+ // qoder 模型服务（转译 bridge.go ListModels/extractModels）：原生 COSY 签名拉 /model/list，
+ // 10min 缓存（按 region 分桶）；只暴露 enable=true 的可用模型（enable=false 调对话必挂，不展示）。
 import { compatFetch, timeoutSignal } from "../../compat.js";
 import { getEndpoints, normalizeRegion } from "./constants.js";
 import { buildCosyHeaders, pathSigFrom } from "./session.js";
@@ -29,34 +29,45 @@ export function extractModels(chatList) {
 export function createModelsService({ id = "qoder", fetchImpl, clock = Date.now } = {}) {
   let cache = null, fetchedAt = 0;
 
-  async function listModels(sess, region = "global") {
-    const normRegion = normalizeRegion(region);
-    const now = clock();
-    if (cache && now - fetchedAt < CACHE_TTL_MS) return cache;
-    const ep = getEndpoints(normRegion);
-    const url = ep.modelListURL;
-    const headers = buildCosyHeaders(sess, pathSigFrom(url), "", "application/json");
-    const res = await fetchImpl(url, { headers, signal: timeoutSignal(15000) });
-    if (!res.ok) throw new Error(`models http ${res.status}`);
-    const j = await res.json().catch(() => ({}));
-    const models = extractModels(j.chat) || extractModels(j.assistant);
-    if (!models.length) throw new Error("models list empty");
-    cache = models.map((m) => ({
-      id: joinModelId(id, m.id),
-      object: "model",
-      created: CREATED,
-      owned_by: OWNER,
-      name: m.name,
-      context_length: m.contextLength,
-      enable: m.enable,
-      is_reasoning: m.isReasoning,
-      price_factor: m.priceFactor,
-    }));
-    fetchedAt = now;
-    return cache;
-  }
-
-  function clearCache() { cache = null; fetchedAt = 0; }
-
-  return { listModels, clearCache, _getCache: () => cache };
-}
+   // 按 region 分桶缓存：同一进程可能有 cn + global 双号，混用单桶会串区（cn 14 个/global 15 个各不同）。
+   const cacheByRegion = new Map();
+   async function listModels(sess, region = "global") {
+     const normRegion = normalizeRegion(region);
+     const now = clock();
+     const hit = cacheByRegion.get(normRegion);
+     if (hit && now - hit.at < CACHE_TTL_MS) return hit.list;
+     const ep = getEndpoints(normRegion);
+     const url = ep.modelListURL;
+     const headers = buildCosyHeaders(sess, pathSigFrom(url), "", "application/json");
+     const res = await fetchImpl(url, { headers, signal: timeoutSignal(15000) });
+     if (!res.ok) throw new Error(`models http ${res.status}`);
+     const j = await res.json().catch(() => ({}));
+     // extractModels 恒返回数组（空数组亦 truthy），必须按长度选 chat/assistant 分支
+     const chatModels = extractModels(j.chat);
+     const models = chatModels.length ? chatModels : extractModels(j.assistant);
+     if (!models.length) throw new Error("models list empty");
+     // 只留可用：enable=false 的 key（如 global 的 auto/ultimate，cn 的绝大多数）展示即误导
+     const usable = models.filter((m) => m.enable);
+     if (!usable.length) throw new Error("models list empty (no enabled models)");
+     const list = usable.map((m) => ({
+       id: joinModelId(id, m.id),
+       object: "model",
+       created: CREATED,
+       owned_by: OWNER,
+       name: m.name,
+       context_length: m.contextLength,
+       enable: true,
+       is_reasoning: m.isReasoning,
+       price_factor: m.priceFactor,
+     }));
+     cacheByRegion.set(normRegion, { list, at: now });
+     // 兼容旧单测 _getCache：默认读 global 桶
+     cache = normRegion === "global" ? list : cache;
+     fetchedAt = normRegion === "global" ? now : fetchedAt;
+     return list;
+   }
+ 
+   function clearCache() { cache = null; fetchedAt = 0; cacheByRegion.clear(); }
+ 
+   return { listModels, clearCache, _getCache: () => cache ?? cacheByRegion.get("global")?.list ?? null };
+ }

package/src/responses/translate.js

@@ -54,6 +54,9 @@ export function responsesToChatBody(req = {}) {
   // 客户端重试/重放历史时会把同一 item 存两份），故按 id 保首个、丢后续——重复项无合法语义，删了不吃亏。
   let pendingReasoning = [];
   const seenReasoningIds = new Set();
+  // 同 call_id 的 function_call_output 重复出现 → 上游 400 "Duplicate function_call_output"
+  // （2026-09-23 实测，客户端重试/重放历史时会把同一工具结果存两份），故同样按 call_id 保首个、丢后续。
+  const seenToolResultIds = new Set();
   for (const it of items) {
     if (!it || typeof it !== "object") continue;
     if (it.type === "reasoning") {
@@ -81,6 +84,8 @@ export function responsesToChatBody(req = {}) {
       if (pendingReasoning.length) { msg.reasoning_items = pendingReasoning; pendingReasoning = []; }
       messages.push(msg);
     } else if (it.type === "function_call_output") {
+      const _tkey = String(it.call_id || "");
+      if (_tkey) { if (seenToolResultIds.has(_tkey)) continue; seenToolResultIds.add(_tkey); }
       messages.push({ role: "tool", tool_call_id: it.call_id || "", content: typeof it.output === "string" ? it.output : JSON.stringify(it.output ?? "") });
     }
   }

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

@@ -117,6 +117,26 @@ export function createRelayPipeline({
       detail: out.detail ?? null,
     });
 
+    // 5a0. 空转 200：流正常结束但零正文零工具调用 → 客户端会报 EMPTY_MODEL_RESPONSE
+    // （"The model ended its turn without producing any output"）；转 failover 而不是
+    // 把空轮递给客户端。chatShaped 是前置证据：只有看得出是 chat 轮才判空，
+    // 非 chat SSE/无 choices JSON 透传是正式契约（chat-route 单测锁死），一律放行。
+    // 工具轮豁免：tool_calls 无正文是合法 agent 形态；
+    // finish=tool_calls/function_call 兜底豁免（防计数漏检误杀）；下游已断开不重试（写给谁看）。
+    // 对标 dsh-cline-pass 的 EMPTY_RESPONSE 语义；不记 auto 冷却（空转≠模型坏，重试多半能好）。
+    const _d = out.detail || {};
+    const _emptyTurn = out.status === 200 && !out.timedOut && !out.interrupted && !_d.downstreamClosed &&
+      _d.chatShaped === true &&
+      (Number(_d.chars) || 0) === 0 && (Number(_d.toolCalls) || 0) === 0 &&
+      !["tool_calls", "function_call"].includes(_d.sawFinishReason);
+    if (_emptyTurn) {
+      const _why = _d.sawFinishReason ? ` (finish_reason=${_d.sawFinishReason})` : " (no content, no tool calls)";
+      try { _logError(actual, 502, `empty turn${_why}`); } catch {}
+      _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null });
+      _evt("fallback", { reqId, from: actual, to: null, reason: "empty turn" });
+      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why} — retry or rephrase` } };
+    }
+
     // 5a. 首块超时未写字节 → 回退（显式 timedOut 字段，status 只是 HTTP 语义展示）
     if (out.timedOut === true) {
       const why = out.detail?.upstreamError ? ` (upstream read error: ${out.detail.upstreamError})` : "";

package/src/routes/stream.js

@@ -114,6 +114,8 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
     downstreamClosed: false,
     usage: null,
     chars: 0,
+    toolCalls: 0,
+    chatShaped: false,
     recoveries: 0,
   };
   let prevChunkAt = t0;
@@ -209,6 +211,12 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
             if (txt.includes("[DONE]")) detail.sawDone = true;
             const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);
             if (m) detail.sawFinishReason = m[1];
+            // chat 形状证据：只有看得出是 chat 轮才配判空（非 chat SSE/JSON 透传是正式契约，不得误伤）
+            if (!detail.chatShaped && (txt.includes('"choices"') || txt.includes('"delta"') || txt.includes('"finish_reason"') || txt.includes('"usage"') || txt.includes('"prompt_tokens"') || txt.includes("[DONE]"))) detail.chatShaped = true;
+            // 工具调用计数（空数组不算）：tool_calls 无正文是合法 agent 轮，
+            // 空转闸门必须豁免它，否则所有工具轮都会被误判为空轮——见 relay-pipeline 4b。
+            const tc = txt.match(/"tool_calls"\s*:\s*\[\s*\{/g);
+            if (tc) detail.toolCalls = (detail.toolCalls || 0) + tc.length;
             // 尝试提取 usage（流式末帧）：口径收口到 metrics.js，与未流式分支共用
             if (txt.includes("\"usage\"") || txt.includes("\"prompt_tokens\"")) {
               try {
@@ -326,6 +334,10 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
     if (u) detail.usage = u;
     if (parsed.choices?.[0]?.message?.content) detail.chars = String(parsed.choices[0].message.content).length;
     else if (parsed.choices?.[0]?.text) detail.chars = String(parsed.choices[0].text).length;
+    // 非流式同样只判 chat 形状：无 choices 的任意 JSON 是透传契约（chat-route 单测锁死），不得判空
+    if (Array.isArray(parsed?.choices)) detail.chatShaped = true;
+    const _tcList = parsed.choices?.[0]?.message?.tool_calls;
+    if (Array.isArray(_tcList) && _tcList.length) detail.toolCalls = _tcList.length;
     const enriched = enrichNonStreamJson(parsed, fallback);
     json(res, upRes.status, enriched);
   } catch {

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

@@ -62,6 +62,9 @@ export function toModelPrompt(messages, { dropEncrypted = false } = {}) {
   // （上游报错原文即要求 Remove duplicate items）。这里按 itemId 保首个、丢后续，
   // 防客户端重放/其他生产者把同一加密 item 组装两次。
   const seenReasoningIds = new Set();
+  // 同 toolCallId 的 tool 结果重复出现 → 上游 400 "Duplicate function_call_output"
+  // （2026-09-23 实测：responses 入站虽已去重，此处仍加防线，防其他生产者直接组装 chat messages 重放）。
+  const seenToolResultIds = new Set();
   for (const m of Array.isArray(messages) ? messages : []) {
     if (!m || typeof m !== "object") continue;
     const role = String(m.role || "");
@@ -112,6 +115,8 @@ export function toModelPrompt(messages, { dropEncrypted = false } = {}) {
       }
       out.push({ role: "assistant", content: parts });
     } else if (role === "tool") {
+      const _tkey = String(m.tool_call_id || "");
+      if (_tkey) { if (seenToolResultIds.has(_tkey)) continue; seenToolResultIds.add(_tkey); }
       out.push({
         role: "tool",
         content: [{

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

@@ -24,6 +24,7 @@ export function diagnoseToolSequence(messages) {
   const list = Array.isArray(messages) ? messages : [];
   const issues = [];
   const open = new Map();
+  const seenResults = new Set();
   let calls = 0;
   let results = 0;
   const first = list[0];
@@ -50,8 +51,8 @@ export function diagnoseToolSequence(messages) {
       results++;
       const id = String(m.tool_call_id || "");
       if (!id) issues.push(`#${i} tool 结果空 id`);
-      else if (!open.has(id)) issues.push(`#${i} 孤立结果:${id}`);
-      else open.delete(id);
+      else if (seenResults.has(id)) issues.push(`#${i} 结果重复:${id}（上游按 call_id 查重会 400 Duplicate function_call_output，去重后只应出现一次）`);
+      else { seenResults.add(id); if (!open.has(id)) issues.push(`#${i} 孤立结果:${id}`); else open.delete(id); }
     } else if (open.size) {
       issues.push(`#${i} ${role} 打断{${[...open.keys()].join(",")}}`);
     }