mslxdff 0.1.64 → 0.1.65

package/bin/mslxdff.js

@@ -1313,7 +1313,7 @@ if (args.includes("-provider") || args.includes("--provider")) {
     console.error(`       mslxdff -provider ${id} allowAny on|off   (empty allowlist = block or allow all)`);
     process.exit(1);
   }
-  if (sub === "models" || sub === "list-models" || sub === "ls") {
+  if (sub === "models" || sub === "show-models" || sub === "list-models" || sub === "ls") {
     const wantsJson = args.includes("--json") || args.includes("-json");
     const cfg = loadProviderConfig(id);
     // opencode: use aggregated cache + provider-specific? For opencode, show bare ids from cache
@@ -1354,20 +1354,57 @@ if (args.includes("-provider") || args.includes("--provider")) {
         provider = createGenericProvider({ id, baseUrl, apiKeys: keys, file: defaultStateFile() });
       }
       const all = await provider.listModels();
-      // apply allowlist filtering mirroring dispatcher
-      const filtered = all.filter((m) => {
-        const raw = String(m.id || "").includes("/") ? String(m.id).split("/").slice(1).join("/") : String(m.id);
-        // for workbuddy, raw is like hy3, for generic it's raw id without prefix? joinModelId adds prefix, so need to extract raw
-        const checkRaw = m.id.startsWith(`${id}/`) ? m.id.slice(id.length + 1) : raw;
+      // show 全部上游模型，仅标注是否被 allowlist 放行（不拦截展示）
+      const markAllowed = (mid) => {
+        const raw = String(mid || "").includes("/") ? String(mid).split("/").slice(1).join("/") : String(mid);
+        const checkRaw = mid.startsWith(`${id}/`) ? mid.slice(id.length + 1) : raw;
         return isModelAllowed(id, checkRaw);
-      });
+      };
       if (wantsJson) {
+        // --json 仍按 allowlist 过滤（给脚本消费可用模型）
+        const filtered = all.filter((m) => markAllowed(m.id));
         console.log(JSON.stringify({ object: "list", data: filtered }, null, 2));
       } else {
-        console.log(`${id} models (${filtered.length}${filtered.length !== all.length ? `/${all.length}` : ""}):`);
-        for (const m of filtered) console.log(`  ${m.id}`);
-        if (!filtered.length && all.length) console.log(`  (all ${all.length} filtered by allowlist — use: mslxdff -provider ${id} allowlist list)`);
+        const allowedCount = all.filter((m) => markAllowed(m.id)).length;
+        console.log(`${id} models (${all.length} total, ${allowedCount} ✓ allowed${allowedCount !== all.length ? `, ${all.length - allowedCount} x blocked by allowlist` : ""}):`);
+        const fmtPrice = (m) => {
+          const c = String(m.credits || "").trim();
+          if (c) {
+            // "x0.00 credits" / "x0.00" → 统一成 "x0.00"
+            const m0 = c.match(/x\s*([\d.]+)/i);
+            if (m0) return `x${m0[1]}`;
+            return c.replace(/\s*credits\s*/gi, "").trim().replace(/\s+/g, " ");
+          }
+          if (m.pricing && typeof m.pricing === "object") {
+            const p = m.pricing.prompt ?? m.pricing.input ?? m.pricing.completion ?? "";
+            if (p) return String(p);
+          }
+          if (m.price != null && String(m.price).trim()) return String(m.price).trim();
+          if (String(m.id).endsWith("/auto")) return "浮动";
+          return "—";
+        };
+        const fmtBadge = (m) => {
+          const tags = Array.isArray(m.tags) ? m.tags : [];
+          const b = tags.find((t) => String(t).includes("限时免费") || String(t).toLowerCase().includes("free"));
+          if (!b) return "";
+          const part = String(b).split(":")[1];
+          return part ? ` [${part}]` : ` [${b}]`;
+        };
+        // 按 credits 升序已在 provider 排好序，展示时对齐价格列便于分辨
+        const idW = Math.max(22, ...all.map((m) => String(m.id).length)) + 2;
+        const priceW = Math.max(6, ...all.map((m) => fmtPrice(m).length)) + 2;
+        for (const m of all) {
+          const ok = markAllowed(m.id);
+          const price = fmtPrice(m);
+          const badge = fmtBadge(m);
+          const name = m.name ? ` ${m.name}` : "";
+          const blocked = ok ? "" : "  [blocked — allowlist]";
+          const line = `  ${ok ? "✓" : "x"} ${String(m.id).padEnd(idW)}${String(price).padEnd(priceW)}${name}${badge}${blocked}`;
+          console.log(line);
+        }
         if (!all.length) console.log(`  (no models — check baseUrl/keys or try: curl ${baseUrl}/models)`);
+        else if (allowedCount === 0) console.log(`  tip: all blocked — mslxdff -provider ${id} allowAny on  或  allowlist set <model...>`);
+        else if (allowedCount !== all.length) console.log(`  tip: blocked 仅影响 /v1/chat 调用，展示已全量列出`);
       }
       try { await provider.close?.(); } catch {}
     } catch (e) {

package/package.json

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

package/src/chat/prompt.js

@@ -47,6 +47,11 @@ export function buildSystemPrompt({ modelsOverride } = {}) {
 
 ${mini}
 
+语言（最高优先级）：
+- 全部面向用户的自然语言回复**必须使用简体中文**（无论用户用英文/日文/拼音提问，都用中文回答）。
+- 仅代码、命令、模型 id、路径、JSON 等技术标识保持原文，不做翻译。
+- 禁止输出英文长段解释；中英文混排时中文为主。
+
 规则：
 - 用户说简称你必须自行查“可用模型”找到全称，例如 hy3→hy3-free，mimo→mimo-v2.5-free，bigpickle→big-pickle。
 - 永远输出精确的命令与模型 id，大小写敏感。
@@ -56,8 +61,8 @@ ${mini}
 - 严禁幻觉命令：mslxdff "hi" --model X / mslxdff --model X "hi" / mslxdff -chat --model X 都不存在，输出只会是 status 页。探活任意模型（含 clinebot/*、workbuddy/*、bai/*）必须用 curl POST http://localhost:8989/v1/chat/completions，body 为 {"model":"<前缀/模型>","messages":[{"role":"user","content":"hi"}],"stream":false}，成功 200 + x-mslxdff-via:local 即通；401 代表本机 token 陈旧需提示 mslxdff -stop && mslxdff；403 + x-mslxdff-allowlist:1 代表白名单未放行需 allowlist add。
 - **禁止重复调用（最高优先级）**：同一 run_command/curl/read_file 在本轮只执行一次，重复会被工具侧 SKIPPED_DUP 拦截；查询类（-showtoken/-status/-provider list/-providers list/-model list/-group list/-log 等）**调用一次即答案**，拿到 OK 结果后必须**立即用中文直接回答用户**，禁止再发起任何工具调用。收到 SKIPPED_DUP 或“请直接回答/禁止再调用”提示时，必须 0 工具直接回答。
 - 禁止调用 -uninstall，包含即拒绝；-showtoken 仅在用户明确要求查看/调试本机 token 时才用，查模型/查供应商严禁调用。
-- 回复用中文，简洁友好，执行前后说明你在做什么。
-- 若用户只是闲聊/提问且可用模型列表已能回答，不调工具，直接回答。`;
+- 回复风格：简洁友好，执行前后用中文说明你在做什么。
+- 若用户只是闲聊/提问且可用模型列表已能回答，不调工具，直接用中文回答。`;
 }
 
 export function getModelsForPrompt() {

package/src/chat/repl.js

@@ -59,6 +59,7 @@ async function runAgentTurn(userText, messages) {
   messages.push({ role: "user", content: userText });
   let loops = 0;
   let lastModel = null;
+  let lastProvider = null;
   let lastUsage = null;
   let lastFallback = false;
   let lastFallbackGateway = false;
@@ -105,6 +106,7 @@ async function runAgentTurn(userText, messages) {
       return { text: err, model: null, latency: lastLatency, usage: null, fallback: false, ok: false };
     }
     lastModel = res.model;
+    lastProvider = res.provider || null;
     lastUsage = res.usage || null;
     lastFallback = !!res.fallback;
     lastFallbackGateway = !!res.fallbackGateway || !!res.viaGateway;
@@ -123,7 +125,7 @@ async function runAgentTurn(userText, messages) {
       if (lastFallbackGateway) note = "\n\x1b[90m[注：mimo/big-pickle 均不可用，已自动切本地网关 auto（:8989）]\x1b[0m";
       else if (lastFallback) note = "\n\x1b[90m[注：mimo 不可用，已用 big-pickle]\x1b[0m";
       trace(`[turn] 完成 总计 ${totalMs}ms · LLM ${lastLatency}ms · 0 工具${lastFallbackGateway ? " · gateway-fallback" : ""}`);
-      return { text: text + note, model: lastModel, latency: lastLatency, usage: lastUsage, fallback: lastFallback, fallbackGateway: lastFallbackGateway, ok: true, totalMs };
+      return { text: text + note, model: lastModel, provider: lastProvider, latency: lastLatency, usage: lastUsage, fallback: lastFallback, fallbackGateway: lastFallbackGateway, ok: true, totalMs };
     }
     const calls = toolCalls.length ? toolCalls : [{ id: "fallback-1", function: { name: "run_command", arguments: JSON.stringify({ command: fallbackCmd }) } }];
     messages.push({ role: "assistant", content: msg.content || "", tool_calls: calls.map((c) => ({ id: c.id, type: "function", function: c.function })) });
@@ -217,7 +219,7 @@ async function runAgentTurn(userText, messages) {
         messages.push({ role: "assistant", content: synth });
         const totalMs = Math.round(performance.now() - t0);
         trace(`[turn] 提前结束（重复阈值） 总计 ${totalMs}ms`);
-        return { text: synth, model: lastModel || "local", latency: lastLatency, usage: lastUsage, fallback: lastFallback, ok: true, totalMs };
+        return { text: synth, model: lastModel || "local", provider: lastProvider, latency: lastLatency, usage: lastUsage, fallback: lastFallback, ok: true, totalMs };
       }
     }
     const toolsMs = Math.round(performance.now() - tTools);
@@ -228,12 +230,14 @@ async function runAgentTurn(userText, messages) {
   return { text: "（工具调用次数已达上限，已停止）", model: lastModel, latency: lastLatency, usage: lastUsage, fallback: lastFallback, fallbackGateway: lastFallbackGateway, ok: false };
 }
 
-function printFooter({ model, latency, usage, totalMs, fallback, fallbackGateway, viaGateway }) {
+function printFooter({ model, provider, latency, usage, totalMs, fallback, fallbackGateway, viaGateway }) {
   const dim = "\x1b[90m";
   const rst = "\x1b[0m";
   let gw = null;
   try { gw = collectStats(); } catch {}
-  const modelLabel = model ? (fallbackGateway || viaGateway ? `${model} (gateway auto)` : model) : "—";
+  const prov = provider && provider !== "opencode" ? `${provider}/` : "";
+  const baseLabel = model ? `${prov}${model}` : "—";
+  const modelLabel = model ? (fallbackGateway || viaGateway ? `${baseLabel} (gateway auto)` : baseLabel) : "—";
   const latLabel = latency ? `${latency}ms` : "—";
   const totalLabel = totalMs ? ` · 总耗时 ${totalMs}ms` : "";
   const tokLabel = usage ? ` · tokens ${usage.prompt_tokens ?? "?"}→${usage.completion_tokens ?? "?"}` : "";

package/src/chat/upstream.js

@@ -8,6 +8,10 @@ function modelForAttempt(attempt) {
 }
 
 export async function chatOnce({ messages, tools, model }) {
+  // 直连 mimo/pickle 不走 anon 3s 额外探测，避免 800ms 对冲被拖慢
+  const prevAnon = process.env.MSLXDFF_FREE_ANON;
+  const needDisableAnon = model === CHAT_PREFERRED || model === CHAT_FALLBACK;
+  if (needDisableAnon) process.env.MSLXDFF_FREE_ANON = "0";
   const client = createUpstreamClient({ connectTimeoutMs: CHAT_TIMEOUT_MS, keepAlive: false, fetchImpl: globalThis.fetch });
   const body = {
     model: model || CHAT_PREFERRED,
@@ -39,10 +43,17 @@ export async function chatOnce({ messages, tools, model }) {
     return { ok: true, message: choice.message, usage: j.usage, raw: j, status: res.status };
   } finally {
     try { await client.close(); } catch {}
+    if (needDisableAnon) {
+      if (prevAnon === undefined) delete process.env.MSLXDFF_FREE_ANON;
+      else process.env.MSLXDFF_FREE_ANON = prevAnon;
+    }
   }
 }
 
 async function chatOnceNoTools({ messages, model }) {
+  const prevAnon2 = process.env.MSLXDFF_FREE_ANON;
+  const needDisable2 = model === CHAT_PREFERRED || model === CHAT_FALLBACK;
+  if (needDisable2) process.env.MSLXDFF_FREE_ANON = "0";
   const client = createUpstreamClient({ connectTimeoutMs: CHAT_TIMEOUT_MS, keepAlive: false, fetchImpl: globalThis.fetch });
   const body = { model: model || CHAT_PREFERRED, messages, stream: false };
   try {
@@ -54,7 +65,13 @@ async function chatOnceNoTools({ messages, model }) {
     const choice = j.choices?.[0];
     if (!choice) return { ok: false, error: "no choice", status: res.status };
     return { ok: true, message: choice.message, usage: j.usage, raw: j, status: res.status };
-  } finally { try { await client.close(); } catch {} }
+  } finally {
+    try { await client.close(); } catch {}
+    if (needDisable2) {
+      if (prevAnon2 === undefined) delete process.env.MSLXDFF_FREE_ANON;
+      else process.env.MSLXDFF_FREE_ANON = prevAnon2;
+    }
+  }
 }
 
 // 带自动降级：mimo-v2.5-free → big-pickle → 本地 8989 auto（网关 auto，含多供应商择优/hedge/peer）
@@ -108,8 +125,10 @@ async function chatViaGateway({ messages, tools }) {
         try {
           const lines = txt.split(/\r?\n/);
           let content = "";
+          let toolCallsMap = new Map();
           let model = "auto";
           let usage = null;
+          let finishReason = "stop";
           let sseOk = false;
           for (const line of lines) {
             const t = String(line).trim();
@@ -120,24 +139,50 @@ async function chatViaGateway({ messages, tools }) {
               const obj = JSON.parse(payload);
               sseOk = true;
               const ch = obj.choices?.[0];
-              // 兼容 thinking 模型的 reasoning_content（delta 阶段 content 为空，实际在 reasoning_content）
+              if (ch?.finish_reason) finishReason = ch.finish_reason;
+              // content / reasoning_content
               if (ch?.delta?.content) content += ch.delta.content;
               else if (ch?.delta?.reasoning_content) content += ch.delta.reasoning_content;
               else if (ch?.message?.content) content += ch.message.content;
               else if (ch?.message?.reasoning_content) content += ch.message.reasoning_content;
               else if (typeof ch?.text === "string") content += ch.text;
               else if (typeof obj.content === "string") content += obj.content;
+              if (ch?.delta?.tool_calls) {
+                for (const tc of ch.delta.tool_calls) {
+                  const idx = tc.index ?? 0;
+                  const cur = toolCallsMap.get(idx) || { id: tc.id || `chatcmpl-tool-${idx}`, type: tc.type || "function", function: { name: "", arguments: "" } };
+                  if (tc.id) cur.id = tc.id;
+                  if (tc.type) cur.type = tc.type;
+                  if (tc.function?.name) cur.function.name = tc.function.name;
+                  if (typeof tc.function?.arguments === "string") cur.function.arguments += tc.function.arguments;
+                  toolCallsMap.set(idx, cur);
+                }
+              }
+              if (ch?.message?.tool_calls) {
+                for (const tc of ch.message.tool_calls) {
+                  const idx = tc.index ?? toolCallsMap.size;
+                  toolCallsMap.set(idx, tc);
+                }
+              }
               if (obj.model) model = obj.model;
               if (obj.usage) usage = obj.usage;
-              // 有些 SSE 直接是完整 chat.completion
               if (obj.choices?.[0]?.message?.content && !content) content = obj.choices[0].message.content;
               if (obj.choices?.[0]?.message?.reasoning_content && !content) content = obj.choices[0].message.reasoning_content;
+              if (obj.choices?.[0]?.message?.tool_calls && toolCallsMap.size === 0) {
+                for (const tc of obj.choices[0].message.tool_calls) toolCallsMap.set(tc.index ?? 0, tc);
+              }
             } catch {}
           }
-          if (sseOk && content) {
-            j = { id: `sse-${Date.now()}`, object: "chat.completion", model, choices: [{ index: 0, finish_reason: "stop", message: { role: "assistant", content } }], usage };
+          const hasToolCalls = toolCallsMap.size > 0;
+          const hasContent = !!content;
+          if (sseOk && (hasContent || hasToolCalls)) {
+            const tool_calls = hasToolCalls ? [...toolCallsMap.values()].sort((a,b)=>(a.index??0)-(b.index??0)) : undefined;
+            const msg = { role: "assistant", content: content || "" };
+            if (tool_calls) msg.tool_calls = tool_calls;
+            // 若 finish_reason 为 tool_calls 但 content 为空，仍视为有效 tool_calls
+            if (hasToolCalls && !hasContent) finishReason = "tool_calls";
+            j = { id: `sse-${Date.now()}`, object: "chat.completion", model, choices: [{ index: 0, finish_reason: finishReason, message: msg }], usage };
           } else if (sseOk) {
-            // SSE 但无 content，按失败处理
             return { ok: false, error: `gateway SSE no content: ${txt.slice(0, 800)}`, status: res.status };
           } else {
             return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
@@ -164,13 +209,39 @@ async function chatViaGateway({ messages, tools }) {
       if (TRACE) console.log(`\x1b[90m· [gateway debug] no choice, txt=${txt.slice(0, 800)} · j=${JSON.stringify(j).slice(0, 800)}\x1b[0m`);
       return { ok: false, error: `gateway no choice: ${txt.slice(0, 800)}`, status: res.status };
     }
+    // 推断供应商：读 models.json 前缀表，匹配 raw → provider
+    let provider = "opencode";
+    const rawModel = effectiveJ.model || j.model || choice.message?.model || "auto";
+    try {
+      const { readFileSync: rfs, existsSync: es } = await import("node:fs");
+      const { join: jn } = await import("node:path");
+      const { homedir: hd } = await import("node:os");
+      const cache = jn(hd(), ".config", "mslxdff", "models.json");
+      if (es(cache)) {
+        const c = JSON.parse(rfs(cache, "utf8"));
+        const ids = (c.data || []).map((x) => x.id).filter(Boolean);
+        for (const pid of ids) {
+          const slash = pid.indexOf("/");
+          const prov = slash > 0 ? pid.slice(0, slash) : "opencode";
+          const raw = slash > 0 ? pid.slice(slash + 1) : pid;
+          if (pid === rawModel || raw === rawModel || pid.endsWith("/" + rawModel)) {
+            provider = prov;
+            break;
+          }
+        }
+        if (provider === "opencode" && rawModel.includes("/")) {
+          const maybe = rawModel.split("/")[0];
+          if (["workbuddy", "clinebot", "sensenova", "openrouter", "generic"].includes(maybe)) provider = maybe;
+        }
+      }
+    } catch {}
     if (TRACE) {
       const dt = Math.round(performance.now() - t0);
-      const m = effectiveJ.model || j.model || choice.message?.model || "auto";
-      console.log(`\x1b[90m· [LLM] gateway auto OK · ${dt}ms · 模型 ${m} · 总 ${Math.round(performance.now() - t0)}ms (gateway-fallback)\x1b[0m`);
+      const m = rawModel;
+      console.log(`\x1b[90m· [LLM] gateway auto OK · ${dt}ms · 模型 ${provider !== "opencode" ? provider + "/" : ""}${m} · 总 ${Math.round(performance.now() - t0)}ms (gateway-fallback)\x1b[0m`);
     }
     // 透传 usage/raw，并标记 gateway（兼容 data 包装）
-    return { ok: true, message: choice.message, usage: effectiveJ.usage || j.usage, raw: j, status: res.status, model: effectiveJ.model || j.model || "auto", viaGateway: true };
+    return { ok: true, message: choice.message, usage: effectiveJ.usage || j.usage, raw: j, status: res.status, model: rawModel, provider, viaGateway: true };
   } catch (err) {
     const msg = String(err?.message || err).slice(0, 800);
     if (TRACE) {
@@ -193,6 +264,9 @@ async function safeChatOnce(opts, model) {
   }
 }
 
+const CHAT_COOLDOWN_MS = 10 * 60 * 1000; // mimo 429 后至少 10min 不再试直连
+const CHAT_SLOW_COOLDOWN_MS = 10 * 60 * 1000;
+
 async function isCoolingAsync(id) {
   try {
     const state = await import("../state.js");
@@ -202,57 +276,218 @@ async function isCoolingAsync(id) {
     const at = Number(e.at || 0);
     if (!at) return false;
     const isSlow = !!e.slow;
-    const cd = isSlow ? 5 * 60 * 1000 : 60 * 1000;
+    const cd = isSlow ? CHAT_SLOW_COOLDOWN_MS : CHAT_COOLDOWN_MS;
     return Date.now() - at < cd && (e.status === "limit" || e.status === "error");
   } catch { return false; }
 }
 
+async function recordChatError(id, status, { slow = false, latencyMs = 0 } = {}) {
+  try {
+    const state = await import("../state.js");
+    const errors = state.loadModelErrors();
+    const isLimit = Number(status) === 429 || String(status).includes("429");
+    // 复用 auto 的分类：429/limit → limit，否则 error
+    const entryStatus = isLimit ? "limit" : "error";
+    errors[id] = { status: entryStatus, at: Date.now(), code: Number.isInteger(Number(status)) ? Number(status) : null, slow: !!slow };
+    state.saveModelErrors(errors);
+    try { state.flushStateSync(); } catch {}
+    if (slow && Number.isFinite(latencyMs) && latencyMs > 0) {
+      try {
+        const lat = state.loadModelLatencies();
+        const prev = lat[id]?.emaMs;
+        const ema = prev ? Math.round(prev * 0.7 + latencyMs * 0.3) : Math.round(latencyMs);
+        lat[id] = { emaMs: ema, lastMs: Math.round(latencyMs), at: Date.now(), count: (lat[id]?.count ?? 0) + 1 };
+        state.saveModelLatencies(lat);
+        try { state.flushStateSync(); } catch {}
+      } catch {}
+    }
+  } catch {}
+}
+
+async function recordChatOk(id, latencyMs) {
+  try {
+    const state = await import("../state.js");
+    const errors = state.loadModelErrors();
+    errors[id] = { status: "normal", at: Date.now(), code: 200, slow: false };
+    state.saveModelErrors(errors);
+    try { state.flushStateSync(); } catch {}
+    if (Number.isFinite(latencyMs) && latencyMs > 0) {
+      const lat = state.loadModelLatencies();
+      const prev = lat[id]?.emaMs;
+      const ema = prev ? Math.round(prev * 0.7 + latencyMs * 0.3) : Math.round(latencyMs);
+      lat[id] = { emaMs: ema, lastMs: Math.round(latencyMs), at: Date.now(), count: (lat[id]?.count ?? 0) + 1 };
+      state.saveModelLatencies(lat);
+      try { state.flushStateSync(); } catch {}
+    }
+  } catch {}
+}
+
 export async function chatWithFallback(opts) {
   const TRACE = process.env.MSLXDFF_CHAT_TRACE !== "0";
+  const HEDGE_MS = (() => {
+    const v = Number(process.env.MSLXDFF_HEDGE_DELAY_MS);
+    return Number.isInteger(v) && v >= 0 ? v : 800;
+  })();
   const t0 = TRACE ? performance.now() : 0;
   // 若上次已确认冷却（429/limit），直接跳过，避免 7+7 秒白等，第二次直接走“上次成功”的网关
   const firstCooling = await isCoolingAsync(CHAT_PREFERRED);
   let first;
+  let firstMs = 0;
   if (firstCooling) {
     if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 跳过（冷却中）· 直接试 ${CHAT_FALLBACK}\x1b[0m`);
     first = { ok: false, error: "skip cooling", status: 429 };
   } else {
+    const t = performance.now();
     first = await safeChatOnce(opts, CHAT_PREFERRED);
+    firstMs = Math.round(performance.now() - t);
+    if (TRACE) {
+      const dt = Math.round(performance.now() - t0);
+      console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} ${first.ok ? "OK" : "FAIL"} · ${dt}ms${first.ok ? "" : ` · ${String(first.error).slice(0, 80)}`}\x1b[0m`);
+    }
+    if (first.ok) {
+      await recordChatOk(CHAT_PREFERRED, firstMs);
+      return { ...first, model: CHAT_PREFERRED };
+    } else {
+      const slow = firstMs > 20000;
+      await recordChatError(CHAT_PREFERRED, first.status, { slow, latencyMs: firstMs });
+    }
   }
-  if (TRACE) {
-    const dt = Math.round(performance.now() - t0);
-    console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} ${first.ok ? "OK" : "FAIL"} · ${dt}ms${first.ok ? "" : ` · ${String(first.error).slice(0, 80)}`}\x1b[0m`);
+  if (firstCooling) {
+    // 已跳过，无需重复日志
+  } else if (TRACE) {
+    // fail 日志已在上面
   }
-  if (first.ok) return { ...first, model: CHAT_PREFERRED };
   const t1 = TRACE ? performance.now() : 0;
+  // 按用户要求：mimo 一旦 429，10min 内第二次直接走 gateway，跳过 big-pickle
+  if (firstCooling) {
+    if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却中（${CHAT_COOLDOWN_MS/60000}min）· 直接走网关 auto，跳过 ${CHAT_FALLBACK}\x1b[0m`);
+    const t2 = TRACE ? performance.now() : 0;
+    if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 冷却，直接走网关 auto（:8989）\x1b[0m`);
+    const third = await chatViaGateway(opts);
+    if (TRACE) {
+      const dt = Math.round(performance.now() - t2);
+      const total = Math.round(performance.now() - t0);
+      console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${dt}ms · 总 ${total}ms (gateway-fallback)\x1b[0m`);
+    }
+    if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: "skip big-pickle (mimo cooling)", viaGateway: true };
+    return { ok: false, error: `${CHAT_PREFERRED} cooling: ${first.error}; gateway auto failed: ${third.error}`, status: third.status || 429 };
+  }
   const secondCooling = await isCoolingAsync(CHAT_FALLBACK);
-  let second;
-  if (secondCooling && firstCooling) {
-    if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} 跳过（冷却中）· 直接走网关 auto\x1b[0m`);
-    second = { ok: false, error: "skip cooling", status: 429 };
-  } else if (secondCooling) {
+  // 800ms 对冲：big-pickle 与 gateway 并发，谁快谁赢
+  // 若 big-pickle 冷却则只走 gateway；否则两者并行 800ms staggered
+  const doGateway = () => chatViaGateway(opts);
+  const doSecond = async () => {
+    const t = performance.now();
+    const r = await safeChatOnce(opts, CHAT_FALLBACK);
+    const ms = Math.round(performance.now() - t);
+    if (r.ok) await recordChatOk(CHAT_FALLBACK, ms);
+    else await recordChatError(CHAT_FALLBACK, r.status, { slow: ms > 20000, latencyMs: ms });
+    return { res: r, ms };
+  };
+
+  if (secondCooling) {
     if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} 跳过（冷却中）· 直接走网关 auto\x1b[0m`);
-    second = { ok: false, error: "skip cooling", status: 429 };
+    const t2 = performance.now();
+    const third = await doGateway();
+    if (TRACE) {
+      const dt = Math.round(performance.now() - t2);
+      const total = Math.round(performance.now() - t0);
+      console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${dt}ms · 总 ${total}ms (gateway-fallback)\x1b[0m`);
+    }
+    if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: "skip cooling", viaGateway: true };
+    return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: skip cooling; gateway auto failed: ${third.error}`, status: third.status || first.status };
+  }
+
+  // 两者皆需尝试：并行对冲（800ms staggered），首个 OK 即胜
+  if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} 失败，${CHAT_FALLBACK} + gateway 对冲中（${HEDGE_MS}ms）\x1b[0m`);
+  const hedgeStart = performance.now();
+  let secondRes = null;
+  let secondMs = 0;
+  let gatewayRes = null;
+
+  const secondPromise = doSecond().then(({ res, ms }) => {
+    secondRes = res; secondMs = ms;
+    if (TRACE) {
+      const dt = Math.round(performance.now() - t1);
+      console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} ${res.ok ? "OK" : "FAIL"} · ${dt}ms · 总 ${Math.round(performance.now() - t0)}ms (hedge)\x1b[0m`);
+    }
+    return res;
+  });
+
+  // gateway 800ms 后启动，对冲慢链路
+  let gatewayPromise = null;
+  const gatewayDelay = HEDGE_MS > 0 ? HEDGE_MS : 0;
+  if (gatewayDelay > 0) {
+    gatewayPromise = new Promise((resolve) => {
+      setTimeout(async () => {
+        const r = await doGateway();
+        gatewayRes = r;
+        resolve(r);
+      }, gatewayDelay);
+    });
+    // 同时也准备一个立即启动的 fallback 若 second 极快失败，则不等待 delay（用 raceFirstOk 覆盖）
+    // 为保证“谁快用谁”，实际让 gateway 立即也准备好，若 second 800ms 内未回，gateway 已在路上
   } else {
-    second = await safeChatOnce(opts, CHAT_FALLBACK);
+    gatewayPromise = doGateway().then((r) => { gatewayRes = r; return r; });
+  }
+  // 为了不让 gatewayDelay 成为必经等待，采用并发 race 策略：
+  // 若 secondPromise 在 hedgeDelay 内成功，则直接返回；否则等待 gateway
+  const raceFirstOk = async () => {
+    // 等 second 或 timeout
+    const secondOrTimeout = await Promise.race([
+      secondPromise.then((r) => ({ kind: "second", r })),
+      new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), gatewayDelay)),
+    ]);
+    if (secondOrTimeout.kind === "second" && secondOrTimeout.r?.ok) {
+      // second 成功，直接赢
+      // 取消后续 gateway（无需等待）
+      return { ok: true, res: secondOrTimeout.r, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+    }
+    // second 失败或超时 → 等 gateway
+    // 确保 gateway 已启动：若之前延迟启动，立即再启动一个即时 gateway 并 race
+    if (!gatewayPromise || secondOrTimeout.kind === "timeout") {
+      // 若 gateway 仍在延迟窗口，提前触发
+      const immediate = doGateway().then((r) => { gatewayRes = r; return r; });
+      if (gatewayPromise) {
+        // 有延迟版本，race 即时 vs 延迟
+        gatewayRes = await Promise.race([gatewayPromise, immediate]);
+      } else {
+        gatewayRes = await immediate;
+      }
+    } else {
+      // second 已失败但 gatewayDelay 已过，等待 gateway
+      gatewayRes = await gatewayPromise;
+    }
+    if (gatewayRes?.ok) return { ok: true, res: gatewayRes, model: gatewayRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: secondRes?.error, viaGateway: true };
+    // 两者皆败
+    if (secondRes?.ok) return { ok: true, res: secondRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+    return { ok: false, gatewayRes, secondRes };
+  };
+
+  // 若 gatewayDelay 0，则直接双并发
+  if (gatewayDelay === 0) {
+    const [sRes, gRes] = await Promise.all([secondPromise.catch((e) => ({ ok: false, error: String(e), status: 502 })), doGateway().catch((e) => ({ ok: false, error: String(e), status: 502 }))]);
+    secondRes = sRes; gatewayRes = gRes;
+    if (sRes?.ok) return { ...sRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+    if (gRes?.ok) return { ...gRes, model: gRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: sRes?.error, viaGateway: true };
+    return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${sRes?.error}; gateway auto failed: ${gRes?.error}`, status: gRes?.status || sRes?.status || first.status };
+  }
+
+  const raced = await raceFirstOk();
+  if (raced.ok) {
+    const r = raced.res;
+    return { ...r, model: raced.model, fallback: raced.fallback, fallbackGateway: raced.fallbackGateway, firstError: raced.firstError, secondError: raced.secondError, viaGateway: raced.viaGateway };
   }
-  if (TRACE) {
-    const dt = Math.round(performance.now() - t1);
-    const total = Math.round(performance.now() - t0);
-    console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} ${second.ok ? "OK" : "FAIL"} · ${dt}ms · 总 ${total}ms (fallback)\x1b[0m`);
+  // 双失败兜底：若 race 未决出 OK，取最终结果
+  if (!secondRes) {
+    try { secondRes = await secondPromise; } catch (e) { secondRes = { ok: false, error: String(e), status: 502 }; }
   }
-  if (second.ok) return { ...second, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
-  // 两者皆失败 → 兜底到本地网关 auto（会走 auto 择优、hedge、peer 等完整链路）
-  const t2 = TRACE ? performance.now() : 0;
-  if (TRACE) console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} + ${CHAT_FALLBACK} 均失败，尝试本地网关 auto（:8989）\x1b[0m`);
-  const third = await chatViaGateway(opts);
-  if (TRACE) {
-    const dt = Math.round(performance.now() - t2);
-    const total = Math.round(performance.now() - t0);
-    console.log(`\x1b[90m· [LLM] gateway auto ${third.ok ? "OK" : "FAIL"} · ${dt}ms · 总 ${total}ms (gateway-fallback)\x1b[0m`);
+  if (secondRes?.ok) return { ...secondRes, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+  if (!gatewayRes) {
+    try { gatewayRes = await (gatewayPromise || doGateway()); } catch (e) { gatewayRes = { ok: false, error: String(e), status: 502 }; }
   }
-  if (third.ok) return { ...third, model: third.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: second.error, viaGateway: true };
-  return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${second.error}; gateway auto failed: ${third.error}`, status: third.status || second.status || first.status };
+  if (gatewayRes?.ok) return { ...gatewayRes, model: gatewayRes.model || "auto", fallbackGateway: true, fallback: true, firstError: first.error, secondError: secondRes?.error, viaGateway: true };
+  return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${secondRes?.error}; gateway auto failed: ${gatewayRes?.error}`, status: gatewayRes?.status || secondRes?.status || first.status };
 }
 
 // 压缩用：简短摘要请求（不带 tools），128k 上下文下仅 95% 触发，需完整摘要

package/src/models.js

@@ -30,8 +30,11 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
     let lastAllowlistKey = "";
     async function currentAllowlistKey() {
       try {
-        const { loadProviderAllowedModels } = await import("./state.js");
-        return providers.map((p) => `${p.id}:${loadProviderAllowedModels(p.id).join(",")}`).join("|");
+        const { loadProviderAllowedModels, loadProviderAllowAnyModels } = await import("./state.js");
+        return providers.map((p) => {
+          const allowAny = loadProviderAllowAnyModels(p.id) ? "any" : "block";
+          return `${p.id}:${allowAny}:${loadProviderAllowedModels(p.id).join(",")}`;
+        }).join("|");
       } catch {
         return "";
       }
@@ -41,10 +44,15 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
       for (const p of providers) {
         try {
           let list = (await p.listModels?.()) ?? [];
-          // 白名单过滤：若该供应商设置了 allowlist，则仅保留名单内模型
+          // 白名单过滤：空名单且 allowAny=false → 该供应商不暴露任何模型（安全默认全拦，auto 直接跳过该供应商）
           try {
-            const { loadProviderAllowedModels } = await import("./state.js");
+            const { loadProviderAllowedModels, loadProviderAllowAnyModels } = await import("./state.js");
             const allowed = loadProviderAllowedModels(p.id);
+            const allowAny = loadProviderAllowAnyModels(p.id);
+            if (!allowed.length && !allowAny) {
+              // 该供应商被全拦，auto 直接跳过整个供应商
+              continue;
+            }
             if (allowed.length) {
               const allowedSet = new Set(allowed);
               const { splitModelId } = await import("./providers/model-id.js");
@@ -81,12 +89,14 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
         } catch {}
         // 否则尝试在缓存上二次过滤（处理 allowlist 从空变非空等未触发重载的场景）
         try {
-          const { loadProviderAllowedModels } = await import("./state.js");
+          const { loadProviderAllowedModels, loadProviderAllowAnyModels } = await import("./state.js");
           const { splitModelId } = await import("./providers/model-id.js");
           const filteredData = aggregate.data.filter((m) => {
             if (!m || !m.id) return false;
             const { provider, raw } = splitModelId(m.id, providers.map((x) => x.id));
             const allowed = loadProviderAllowedModels(provider);
+            const allowAny = loadProviderAllowAnyModels(provider);
+            if (!allowed.length && !allowAny) return false;
             if (!allowed.length) return true;
             return allowed.includes(String(raw || "").trim());
           });

package/src/providers/keyring.js

@@ -30,9 +30,27 @@ export function createKeyRing(keys = [], { cooldownMs = DEFAULT_COOLDOWN_MS, now
     if (list.includes(key)) errAt.set(key, now());
   }
 
+  function replace(oldKey, newKey) {
+    const idx = list.indexOf(oldKey);
+    if (idx < 0) {
+      if (newKey && !list.includes(newKey)) list.push(newKey);
+      return false;
+    }
+    if (newKey && oldKey !== newKey) {
+      list[idx] = newKey;
+      // 迁移冷却状态：旧 key 的冷却移到新 key，避免新 token 立即被误判可用
+      if (errAt.has(oldKey)) {
+        const t = errAt.get(oldKey);
+        errAt.delete(oldKey);
+        // 新 token 刚刷新，不应继承旧冷却，直接清掉
+      }
+    }
+    return true;
+  }
+
   function available() {
     return list.filter((k) => !isCooling(k)).length;
   }
 
-  return { next, onError, available, size: list.length, cooldownMs, keys: [...list] };
+  return { next, onError, replace, available, size: list.length, cooldownMs, keys: [...list] };
 }

package/src/providers/workbuddy.js

@@ -71,6 +71,30 @@ function isInsufficientStatus(status, bodyText, cached) {
   return false;
 }
 
+// 401/403 或 body 含 token 失效关键词 → 视为需刷新（workbuddy 返回 200+JSON 或 SSE 错误时也能命中）
+function isAuthError(status, bodyText) {
+  if (status === 401 || status === 403) return true;
+  const t = String(bodyText || "").toLowerCase();
+  // 常见 workbuddy 鉴权失败文案
+  if (t.includes("unauthorized") || t.includes("authenticate") || t.includes("invalid token") || t.includes("token expired") || t.includes("token invalid") || t.includes("access token") || t.includes("login expired") || t.includes("need login") || t.includes("session expired")) return true;
+  if (t.includes("code") && (t.includes("401") || t.includes("403")) && t.includes("token")) return true;
+  // JWT 失效的 400 也可能带 token
+  if (status === 400 && t.includes("token")) return true;
+  return false;
+}
+
+function decodeJwtExp(token) {
+  try {
+    const payload = String(token || "").split(".")[1];
+    if (!payload) return 0;
+    const json = JSON.parse(Buffer.from(payload.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8"));
+    return Number(json.exp || 0);
+  } catch { return 0; }
+}
+
+// 并发去重：同一 uid 同时只刷一次
+const inflightRefresh = new Map();
+
 function withUidHeader(res, uid) {
   try {
     // try mutable set first
@@ -184,7 +208,7 @@ export function createWorkbuddyProvider({
     } catch {}
   }
 
-  const ring = createKeyRing(keys, { cooldownMs });
+  let ring = createKeyRing(keys, { cooldownMs });
 
   let dispatcher = null;
   let agent = null;
@@ -212,51 +236,76 @@ export function createWorkbuddyProvider({
     const rt = auth?.refreshToken;
     const uid = auth?.uid;
     if (!rt || !uid) return null;
-    const url = joinUrl(resolvedBase, "/v2/plugin/auth/token/refresh");
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${key}`,
-      "X-Refresh-Token": rt,
-      "X-User-Id": uid,
-      "X-Domain": auth.domain || "www.codebuddy.cn",
-      "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
-      Origin: "https://www.codebuddy.cn",
-      Referer: "https://www.codebuddy.cn/",
-    };
-    try {
-      const opts = { method: "POST", headers, body: "{}" };
-      if (dispatcher) opts.dispatcher = dispatcher;
-      const res = await fetchImpl(url, opts);
-      const text = await res.text();
-      const j = JSON.parse(text);
-      if (j.code === 0 && j.data?.accessToken) {
-        const newAt = j.data.accessToken;
-        const newRt = j.data.refreshToken || rt;
-        // update in-memory
-        const idx = keys.indexOf(key);
-        if (idx >= 0) {
-          keys[idx] = newAt;
-          // also update ring? createKeyRing holds reference? need to reset
-          // simplest: save to state and update authList
-          authList[idx] = { ...auth, refreshToken: newRt };
-          try {
-            saveProviderConfig(id, { baseUrl: resolvedBase, keys: [...keys], auths: [...authList] }, file ? { file } : {});
-          } catch {}
-          try {
-            const authDir = process.env.WORKBUDDY_AUTH_DIR || (isTestEnv() ? join(tmpdir(), "mslxdff-test-auths") : (file && String(file).includes("mslxdff-") ? join(dirname(String(file)), "auths") : join(process.cwd(), "auths")));
-            mkdirSync(authDir, { recursive: true });
-            const expAt = (() => { try { return JSON.parse(Buffer.from(newAt.split(".")[1], "base64").toString()).exp; } catch { return Math.floor(Date.now()/1000)+5184000; } })();
-            const doc = { account: { uid, enterpriseId: auth.enterpriseId || "", nickname: "" }, auth: { accessToken: newAt, refreshToken: newRt, expiresAt: expAt, domain: auth.domain || "www.codebuddy.cn" } };
-            const fp = join(authDir, `workbuddy-${uid}.json`);
-            const tmp = fp + ".tmp";
-            writeFileSync(tmp, JSON.stringify(doc, null, 2), { mode: 0o600 });
-            try { if (existsSync(fp)) { const { unlinkSync, renameSync } = await import("node:fs"); unlinkSync(fp); renameSync(tmp, fp); } else { const { renameSync } = await import("node:fs"); renameSync(tmp, fp); } } catch { writeFileSync(fp, JSON.stringify(doc, null, 2), { mode: 0o600 }); }
-          } catch {}
+    const dedupKey = String(uid);
+    if (inflightRefresh.has(dedupKey)) {
+      try { return await inflightRefresh.get(dedupKey); } catch { return null; }
+    }
+    const p = (async () => {
+      const url = joinUrl(resolvedBase, "/v2/plugin/auth/token/refresh");
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`,
+        "X-Refresh-Token": rt,
+        "X-User-Id": uid,
+        "X-Domain": auth.domain || "www.codebuddy.cn",
+        "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
+        Origin: "https://www.codebuddy.cn",
+        Referer: "https://www.codebuddy.cn/",
+      };
+      try {
+        const opts = { method: "POST", headers, body: "{}" };
+        if (dispatcher) opts.dispatcher = dispatcher;
+        const res = await fetchImpl(url, opts);
+        const text = await res.text();
+        const j = JSON.parse(text);
+        if (j.code === 0 && j.data?.accessToken) {
+          const newAt = j.data.accessToken;
+          const newRt = j.data.refreshToken || rt;
+          const idx = keys.indexOf(key);
+          if (idx >= 0) {
+            keys[idx] = newAt;
+            authList[idx] = { ...auth, refreshToken: newRt };
+            // 同步 ring，避免下一轮仍取旧 token
+            try { ring.replace(key, newAt); } catch {}
+            try { saveProviderConfig(id, { baseUrl: resolvedBase, keys: [...keys], auths: [...authList] }, file ? { file } : {}); } catch {}
+            try {
+              const authDir = process.env.WORKBUDDY_AUTH_DIR || (isTestEnv() ? join(tmpdir(), "mslxdff-test-auths") : (file && String(file).includes("mslxdff-") ? join(dirname(String(file)), "auths") : join(process.cwd(), "auths")));
+              mkdirSync(authDir, { recursive: true });
+              const expAt = (() => { try { return JSON.parse(Buffer.from(newAt.split(".")[1], "base64").toString()).exp; } catch { return Math.floor(Date.now()/1000)+5184000; } })();
+              const doc = { account: { uid, enterpriseId: auth.enterpriseId || "", nickname: "" }, auth: { accessToken: newAt, refreshToken: newRt, expiresAt: expAt, domain: auth.domain || "www.codebuddy.cn" } };
+              const fp = join(authDir, `workbuddy-${uid}.json`);
+              const tmp = fp + ".tmp";
+              writeFileSync(tmp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+              try { if (existsSync(fp)) { const { unlinkSync, renameSync } = await import("node:fs"); unlinkSync(fp); renameSync(tmp, fp); } else { const { renameSync } = await import("node:fs"); renameSync(tmp, fp); } } catch { writeFileSync(fp, JSON.stringify(doc, null, 2), { mode: 0o600 }); }
+            } catch {}
+          } else {
+            // 未在 keys 里的 key（如临时 ring），也尝试追加
+            if (!keys.includes(newAt)) {
+              keys.push(newAt);
+              authList.push({ ...auth, refreshToken: newRt });
+              try { ring.replace(key, newAt); } catch {}
+            }
+          }
+          return newAt;
         }
-        return newAt;
+      } catch {}
+      return null;
+    })();
+    inflightRefresh.set(dedupKey, p);
+    try { const r = await p; return r; } finally { inflightRefresh.delete(dedupKey); }
+  }
+
+  // 主动续期：JWT 5 分钟内过期则后台刷新一次（不阻塞当前请求）
+  function maybeProactiveRefresh(auth, key) {
+    try {
+      const exp = decodeJwtExp(key);
+      if (!exp) return;
+      const remain = exp * 1000 - Date.now();
+      if (remain < 5 * 60 * 1000 && remain > -60 * 60 * 1000) {
+        // 剩余 <5min 且未过期太久才刷，避免每次都刷
+        void refreshTokenFor(key, auth).catch(() => {});
       }
     } catch {}
-    return null;
   }
 
   async function attemptOnce(url, body, key) {
@@ -294,6 +343,7 @@ export function createWorkbuddyProvider({
       }
       const key = keys[idx];
       const auth = authList[idx];
+      maybeProactiveRefresh(auth, key);
       const cached = getCachedBalance(auth.uid);
       if (cached && Number(cached.total) === 0) {
         const errBody = JSON.stringify({ error: `workbuddy uid in cooldown (balance 0): ${auth.uid}` });
@@ -301,9 +351,6 @@ export function createWorkbuddyProvider({
         res._t = { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - t0) };
         return res;
       }
-      // check ring cooldown by peeking if key is cooling (ring doesn't expose, so try next and see)
-      // we enforce by attempting; if ring would skip, we still allow manual but mark cooling
-      // do single attempt with this key
       const attempts = [];
       let waitMs = 0;
       for (let attempt = 0; ; attempt++) {
@@ -318,24 +365,33 @@ export function createWorkbuddyProvider({
           result._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) };
           throw result;
         }
-        if ((result.status === 401 || result.status === 403) && attempt === 0) {
-          const newKey = await refreshTokenFor(key, auth);
-          if (newKey) {
-            const auth2 = authForKey(newKey);
-            const headers2 = buildAuthHeaders(newKey, auth2);
-            const finalBody = { ...body, stream: true };
-            const controller2 = new AbortController();
-            const timer2 = setTimeout(() => controller2.abort(new Error(`${id} timed out after ${connectTimeoutMs}ms`)), connectTimeoutMs);
-            try {
-              const opts2 = { method: "POST", headers: headers2, body: JSON.stringify(finalBody), signal: controller2.signal };
-              if (dispatcher) opts2.dispatcher = dispatcher;
-              let res2 = await fetchImpl(url, opts2);
-              res2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0), refreshed: true };
-              res2 = withUidHeader(res2, auth2.uid || auth.uid);
-              if (res2.status === 401 || res2.status === 403 || res2.status === 429 || res2.status >= 500) activeRing.onError(newKey);
-              appendRotationLog({ uid: auth2.uid || auth.uid, model: modelForLog, totalMs: Math.round(performance.now() - t0), balanceHit: false });
-              return res2;
-            } catch (e2) { e2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) }; throw e2; } finally { clearTimeout(timer2); }
+        // 401/403 或 body 含 token 失效 → 自动续期（覆盖 workbuddy 200+JSON 错误体）
+        if (attempt === 0) {
+          let bodyText = "";
+          try { bodyText = await result.clone().text(); } catch {}
+          if (isAuthError(result.status, bodyText)) {
+            const newKey = await refreshTokenFor(key, auth);
+            if (newKey) {
+              const auth2 = authForKey(newKey);
+              const headers2 = buildAuthHeaders(newKey, auth2);
+              const finalBody = { ...body, stream: true };
+              const controller2 = new AbortController();
+              const timer2 = setTimeout(() => controller2.abort(new Error(`${id} timed out after ${connectTimeoutMs}ms`)), connectTimeoutMs);
+              try {
+                const opts2 = { method: "POST", headers: headers2, body: JSON.stringify(finalBody), signal: controller2.signal };
+                if (dispatcher) opts2.dispatcher = dispatcher;
+                let res2 = await fetchImpl(url, opts2);
+                // 刷新后若仍 401/403，视为刷新未生效，标记新 key 冷却并返回错误
+                let res2Body = "";
+                try { res2Body = await res2.clone().text(); } catch {}
+                const stillAuth = isAuthError(res2.status, res2Body);
+                res2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0), refreshed: true };
+                res2 = withUidHeader(res2, auth2.uid || auth.uid);
+                if (stillAuth || res2.status === 429 || res2.status >= 500) activeRing.onError(newKey);
+                appendRotationLog({ uid: auth2.uid || auth.uid, model: modelForLog, totalMs: Math.round(performance.now() - t0), balanceHit: false, error: stillAuth ? `still auth ${res2.status}` : undefined });
+                return res2;
+              } catch (e2) { e2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) }; throw e2; } finally { clearTimeout(timer2); }
+            }
           }
         }
         const entry = retry?.[result.status];
@@ -381,6 +437,8 @@ export function createWorkbuddyProvider({
         err._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) };
         throw err;
       }
+      // 主动续期（JWT 5min 内过期）
+      maybeProactiveRefresh(auth, key);
       // single attempt with retry for network/429
       let result = null;
       let attempt = 0;
@@ -397,24 +455,45 @@ export function createWorkbuddyProvider({
           result._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) };
           break;
         }
-        if ((result.status === 401 || result.status === 403) && attempt === 0) {
-          const newKey = await refreshTokenFor(key, auth);
-          if (newKey) {
-            const auth2 = authForKey(newKey);
-            const headers2 = buildAuthHeaders(newKey, auth2);
-            const finalBody = { ...body, stream: true };
-            const controller2 = new AbortController();
-            const timer2 = setTimeout(() => controller2.abort(new Error(`${id} timed out after ${connectTimeoutMs}ms`)), connectTimeoutMs);
-            try {
-              const opts2 = { method: "POST", headers: headers2, body: JSON.stringify(finalBody), signal: controller2.signal };
-              if (dispatcher) opts2.dispatcher = dispatcher;
-              let res2 = await fetchImpl(url, opts2);
-              res2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0), refreshed: true };
-              if (res2.status === 401 || res2.status === 403 || res2.status === 429 || res2.status >= 500) activeRing.onError(newKey);
-              res2 = withUidHeader(res2, auth2.uid || uid);
-              appendRotationLog({ uid: auth2.uid || uid, model: modelForLog, totalMs: Math.round(performance.now() - t0), balanceHit: false });
-              return res2;
-            } catch (e2) { e2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) }; lastErr = e2; break; } finally { clearTimeout(timer2); }
+        // 401/403 或 body 含 token 失效 → 自动续期后重试一次；若仍失败则切下一账号
+        if (attempt === 0) {
+          let bodyText = "";
+          try { bodyText = await result.clone().text(); } catch {}
+          const needRefresh = isAuthError(result.status, bodyText);
+          if (needRefresh) {
+            const newKey = await refreshTokenFor(key, auth);
+            if (newKey) {
+              const auth2 = authForKey(newKey);
+              const headers2 = buildAuthHeaders(newKey, auth2);
+              const finalBody = { ...body, stream: true };
+              const controller2 = new AbortController();
+              const timer2 = setTimeout(() => controller2.abort(new Error(`${id} timed out after ${connectTimeoutMs}ms`)), connectTimeoutMs);
+              try {
+                const opts2 = { method: "POST", headers: headers2, body: JSON.stringify(finalBody), signal: controller2.signal };
+                if (dispatcher) opts2.dispatcher = dispatcher;
+                let res2 = await fetchImpl(url, opts2);
+                let res2Body = "";
+                try { res2Body = await res2.clone().text(); } catch {}
+                const stillAuth = isAuthError(res2.status, res2Body);
+                res2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0), refreshed: true };
+                res2 = withUidHeader(res2, auth2.uid || uid);
+                if (stillAuth || res2.status === 429 || res2.status >= 500) activeRing.onError(newKey);
+                appendRotationLog({ uid: auth2.uid || uid, model: modelForLog, totalMs: Math.round(performance.now() - t0), balanceHit: false, error: stillAuth ? `still auth ${res2.status}` : undefined });
+                if (stillAuth) {
+                  lastErr = new Error(`workbuddy auth still failing after refresh for ${uid}: ${res2Body.slice(0,120)}`);
+                  lastErr._t = res2._t;
+                  activeRing.onError(newKey);
+                  break; // 切下一账号
+                }
+                return res2;
+              } catch (e2) { e2._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) }; lastErr = e2; break; } finally { clearTimeout(timer2); }
+            } else {
+              // 刷新失败也切下一账号
+              lastErr = new Error(`workbuddy refresh failed for ${uid}: ${bodyText.slice(0,120)}`);
+              lastErr._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) };
+              activeRing.onError(key);
+              break;
+            }
           }
         }
         const entry = retry?.[result.status];
@@ -500,24 +579,41 @@ export function createWorkbuddyProvider({
     const now = Date.now();
     if (cache && now - fetchedAt < CACHE_TTL_MS) return cache;
     const url = joinUrl(resolvedBase, resolvedModelsPath);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(new Error(`${id} models timed out`)), 15_000);
+    const execList = async (useKey, useAuth) => {
+      const controller2 = new AbortController();
+      const timer2 = setTimeout(() => controller2.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}`;
+        const opts = { headers, signal: controller2.signal };
+        if (dispatcher) opts.dispatcher = dispatcher;
+        return await fetchImpl(url, opts);
+      } finally { clearTimeout(timer2); }
+    };
     try {
       const key = ring.next() || keys[0] || "";
       const auth = authForKey(key);
-      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}`;
-      const opts = { headers, signal: controller.signal };
-      if (dispatcher) opts.dispatcher = dispatcher;
-      const res = await fetchImpl(url, opts);
+      maybeProactiveRefresh(auth, key);
+      let res = await execList(key, auth);
+      if (!res.ok) {
+        let t = "";
+        try { t = await res.clone().text(); } catch {}
+        if (isAuthError(res.status, t)) {
+          const newKey = await refreshTokenFor(key, auth);
+          if (newKey) {
+            const auth2 = authForKey(newKey);
+            res = await execList(newKey, auth2);
+          }
+        }
+      }
       if (!res.ok) return [];
       const json = await res.json().catch(() => ({}));
       const models = json?.data?.models;
@@ -528,8 +624,6 @@ export function createWorkbuddyProvider({
       return cache;
     } catch {
       return [];
-    } finally {
-      clearTimeout(timer);
     }
   }
 

package/src/routes/chat/index.js

@@ -127,6 +127,138 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
 
   const handlerCtx = { reqId, model: null, body, hops, peers, plugins, evt, logError, logCall, logs };
 
+  // 首次 auto 并发测速：勾选的供应商并发比谁快，谁快下次优先（跳过明知故障的模型）
+  // 胜者会同时写入 preferredModel + auto 成功，下次 plugin 会将其排首位
+  if (useAuto && order.length > 1 && auto && !lockModel) {
+    const statuses = auto.statuses?.() ?? {};
+    const hasPriorSuccess = Object.values(statuses).some((e) => e && typeof e === "object" && e.status === "normal");
+    const nonCoolingOrder = order.filter((m) => {
+      try { return !auto.isCooling(m); } catch { return true; }
+    });
+    // 首次（无 normal）且至少 2 个非冷却候选 → 并发赛跑
+    if (!hasPriorSuccess && nonCoolingOrder.length > 1) {
+      const concLimit = (() => {
+        const v = Number(process.env.MSLXDFF_AUTO_CONCURRENT);
+        if (Number.isInteger(v) && v > 0) return Math.min(v, nonCoolingOrder.length);
+        return Math.min(nonCoolingOrder.length, 5);
+      })();
+      const raceModels = nonCoolingOrder.slice(0, concLimit);
+      evt("auto-concurrent-race", { reqId, models: raceModels, skippedFaulty: order.length - nonCoolingOrder.length, limit: concLimit });
+      // 并发发起 upstream.chat，取首个 200 成功者
+      const raceStart = performance.now();
+      const attempts = raceModels.map(async (m) => {
+        const fwd = { ...injectReasoningContent(m, body), model: m };
+        let r = null;
+        try {
+          const chatOpts = {};
+          if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
+          if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
+          r = await upstream.chat(fwd, Object.keys(chatOpts).length ? chatOpts : undefined);
+        } catch (err) {
+          return { model: m, ok: false, error: errMsg(err), status: 502, timing: err?._t ?? null };
+        }
+        if (r && r.status >= 400) {
+          const isAllow = r.status === 403 && r.headers?.get?.("x-mslxdff-allowlist") === "1";
+          if (isAllow) return { model: m, ok: false, error: "allowlist", status: 403, allowlist: true };
+          return { model: m, ok: false, error: `upstream ${r.status}`, status: r.status, res: r, timing: r._t ?? null };
+        }
+        if (r instanceof Error) return { model: m, ok: false, error: errMsg(r), status: 502 };
+        return { model: m, ok: true, res: r, status: r.status, timing: r._t ?? null };
+      });
+      // 首个成功优先：轮询 settled，首个 ok 即胜；若全 fail 则走原串行兜底
+      let winner = null;
+      let winnerIdx = -1;
+      const pending = new Set(attempts.map((p, i) => ({ p, i })));
+      // 用 allSettled + 最快成功挑选（最小 timing 或最先 settled 的 ok）
+      const results = await Promise.allSettled(attempts);
+      // 按实际成功且 timing 最小排序（首包/总耗时最小者胜）
+      const okList = results.map((r, i) => ({ r, i, model: raceModels[i] }))
+        .filter(({ r }) => r.status === "fulfilled" && r.value?.ok)
+        .map(({ r, i, model }) => ({ model, idx: i, val: r.value, t: r.value.timing?.totalMs ?? r.value.timing?.ms ?? Number.MAX_SAFE_INTEGER }));
+      if (okList.length) {
+        okList.sort((a, b) => a.t - b.t);
+        const best = okList[0];
+        winner = best.val.res;
+        winnerIdx = best.idx;
+        const winModel = best.model;
+        evt("auto-concurrent-win", { reqId, model: winModel, timing: best.val.timing, totalMs: Math.round(performance.now() - raceStart), tried: raceModels.length });
+        // 记录优胜者为 normal + 设为 preferred（下次 plugin 排首位），其余失败者计 error 但不影响优先
+        for (const { r, i } of results.map((r, i) => ({ r, i }))) {
+          const m = raceModels[i];
+          if (r.status === "fulfilled" && r.value?.ok) {
+            if (m === winModel) {
+              const latencyMs = r.value.timing?.totalMs ?? Math.round(performance.now() - raceStart);
+              await auto.recordOk(m, { latencyMs });
+              try {
+                const { savePreferredModel } = await import("../../state.js");
+                savePreferredModel(m);
+                evt("auto-concurrent-preferred", { reqId, model: m });
+              } catch {}
+            }
+          } else if (r.status === "fulfilled" && !r.value?.ok && !r.value?.allowlist) {
+            // 非 allowlist 的失败才计 error（跳过的 allowlist 不计）
+            await auto.recordError(m, { status: r.value.status || 502 });
+          } else if (r.status === "rejected") {
+            await auto.recordError(m, { status: 502 });
+          }
+        }
+        // 直接中继优胜者
+        handlerCtx.model = winModel;
+        const isStream = Boolean(body.stream);
+        // 复用本地中继逻辑（不走 hedge，直接 relay）
+        const { handleLocalRelay: _relay } = await import("./local-handler.js");
+        const lr = await _relay({
+          upRes: winner,
+          model: winModel,
+          body,
+          order: raceModels,
+          idx: winnerIdx,
+          lastErr: null,
+          requested,
+          useAuto,
+          lockModel,
+          auto,
+          handlerCtx,
+          evt,
+          logCall,
+          logError,
+          mark,
+          perf0,
+          stages,
+          startedAt,
+          plugins,
+          res,
+        });
+        if (lr.handled) return;
+        // 若中继未 handled（如 interrupted），按原逻辑继续
+        if (lr.lastErr) {
+          // 优胜者中继失败，降级为串行兜底（剩余 order 中未测的继续）
+        } else {
+          return;
+        }
+      } else {
+        evt("auto-concurrent-all-fail", { reqId, tried: raceModels.length, totalMs: Math.round(performance.now() - raceStart) });
+        // 全失败：记录失败并继续走原串行（会按 order 逐个重试，含未并发的尾部）
+        for (const { r, i } of results.map((r, i) => ({ r, i }))) {
+          const m = raceModels[i];
+          if (r.status === "fulfilled" && !r.value?.ok && !r.value?.allowlist) await auto.recordError(m, { status: r.value.status || 502 });
+          else if (r.status === "rejected") await auto.recordError(m, { status: 502 });
+        }
+      }
+      // 并发未决出胜者或中继失败，回落到原串行循环（会跳过已试的 raceModels，继续 trial 剩余 order）
+      // 为避免重复试已失败的 raceModels，过滤 order
+      const triedSet = new Set(raceModels);
+      order = order.filter((m) => !triedSet.has(m));
+      if (!order.length) {
+        // 首次并发已试全部且全失败 → 按“所有勾选都不通”直接失败
+        const last = { model: raceModels[0] || requested, status: 502, message: "all concurrent candidates failed" };
+        await handleExhaustedAll({ res, body, lastErr: last, order: raceModels, requested, handlerCtx: { ...handlerCtx, reqId, startedAt }, evt, logCall, mark, perf0, stages });
+        return;
+      }
+      // 继续走下方串行 for 循环（新 order）
+    }
+  }
+
   let lastErr = null;
   for (let idx = 0; idx < order.length; idx++) {
     const model = order[idx];
@@ -175,15 +307,28 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
     }
     mark(`up-${model}`);
     if (upRes && upRes.status >= 400) {
-      // 白名单 403 直通，不计冷却、不 fallback
       const isAllowlistBlock = upRes.status === 403 && (upRes.headers?.get?.("x-mslxdff-allowlist") === "1");
       if (isAllowlistBlock) {
         let bodyText = null;
         try { bodyText = await upRes.clone().text(); } catch {}
         let errBody = { error: `model not allowed for provider` };
         try { errBody = bodyText ? JSON.parse(bodyText) : errBody; } catch { errBody = { error: bodyText || "model not allowed" }; }
+        // 白名单 403：显式模型直通 403；auto 时跳过该候选继续往下走（不打断多供应商 auto）
+        if (useAuto) {
+          // auto：软错跳过，不计冷却，继续试下一个供应商/模型
+          logError(model, 403, errBody.error || "model not allowed");
+          evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true, skipped: true });
+          lastErr = { model, upstream: upRes, status: 403, message: errBody.error || "model not allowed" };
+          if (canFallback && idx < order.length - 1) {
+            evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: `allowlist skip ${errBody.error || "blocked"}` });
+            continue;
+          }
+          // auto 已到末尾仍全被拦 → 直通 403
+          return json(res, 403, errBody);
+        }
+        // 非 auto：显式指定被拦 → 硬 403，不 fallback（防绕过 allowlist）
         logError(model, 403, errBody.error || "model not allowed");
-        evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null });
+        evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true });
         return json(res, 403, errBody);
       }
       if (auto) await auto.recordError(model, { status: upRes.status });