mslxdff 0.1.63 → 0.1.65

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