mslxdff 0.1.216 → 0.1.218

package/package.json

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

package/src/providers/codearts/chat.js

@@ -26,6 +26,12 @@ export function injectReasoningPlaceholder(messages, model) {
 
 const PASSTHROUGH_KEYS = ["temperature", "top_p", "max_tokens", "max_completion_tokens", "reasoning_effort", "tools", "tool_choice", "stop", "presence_penalty", "frequency_penalty", "response_format", "user", "n", "seed"];
 
+// 账号级「会话/并发饱和」：上游按账号限同时活跃会话数（TM.00001041 = 并发会话数已达上限(3个)）。
+// 这是账号此刻进不去，不是本请求参数错；槽位在上游保留分钟级才回收（与本地进程无关）。
+// 多号场景换另一个账号通常立即成功——故短冷却本账号让下一次 next() 换号并 continue 重试。
+const SESSION_SATURATED_RE = /TM\.00001041|并发会话数已达上限/;
+const SESSION_SATURATED_COOLDOWN_MS = Number.parseInt(process.env.MSLXDFF_CODEARTS_SESSION_COOLDOWN_MS ?? "", 10) || 30_000;
+
 export function buildUpstreamBody(body, { chatId, upstreamModel }) {
   const out = {
     model: upstreamModel,
@@ -59,6 +65,12 @@ function stripOwnPrefix(model, providerId) {
   return s.slice(0, i).toLowerCase() === String(providerId || "").toLowerCase() ? s.slice(i + 1) : s;
 }
 
+// 从 4xx/5xx 正文里判「账号级会话饱和」：命中则可换号重试（不同于参数类 400，换号无意义）。
+export function isSessionSaturated(status, bodyText) {
+  if (status !== 400 && status !== 429 && status < 500) return false;
+  return SESSION_SATURATED_RE.test(String(bodyText || ""));
+}
+
 export function createChatService({
   id = "codearts",
   baseUrl = SNAP_BASE,
@@ -155,8 +167,16 @@ export function createChatService({
       }
       if (res.status >= 400) {
         const txt = await res.text().catch(() => "");
+        const msg = `codearts upstream http ${res.status}: ${String(txt).slice(0, 300)}`;
+        // 账号会话饱和：短冷却本号并换号重试（多号场景另一号通常立即成功）；
+        // 所有号都饱和才落到重试耗尽分支，交给上层按上游不可用输出。
+        if (isSessionSaturated(res.status, txt)) {
+          try { activeRing.onError(blob, SESSION_SATURATED_COOLDOWN_MS); } catch {}
+          lastErr = Object.assign(new Error(msg), { upstreamStatus: res.status, upstreamBody: txt });
+          continue;
+        }
         if (res.status === 429 || res.status >= 500) try { activeRing.onError(blob); } catch {}
-        return withTiming(errRes(res.status, `codearts upstream http ${res.status}: ${String(txt).slice(0, 300)}`), t0);
+        return withTiming(errRes(res.status, msg), t0);
       }
       try {
         const pre = await preflightResponse(res); // HTTP 200 内嵌错误（排队/未注册/福利未领）→ 抛 UpstreamEventError
@@ -173,6 +193,11 @@ export function createChatService({
         continue;
       }
     }
+    // 全部号跑完仍无成功：若最后一个是账号会话饱和（非参数错），如实回传上游 400，
+    // 别退化成笼统的 "all accounts unavailable"——用户要看得到「并发会话数已达上限」。
+    if (lastErr?.upstreamStatus && lastErr?.upstreamBody != null && isSessionSaturated(lastErr.upstreamStatus, lastErr.upstreamBody)) {
+      return withTiming(errRes(lastErr.upstreamStatus, lastErr.message), t0);
+    }
     throw Object.assign(lastErr || new Error("codearts: all accounts unavailable"), {
       _t: { attempts: [], waitMs: 0, totalMs: Math.round(clock() - t0) },
     });

package/src/providers/codearts/concurrency.js

@@ -1,27 +1,51 @@
 // codearts 上游硬限并发：FIFO 排队闸，超限请求等前面的让出额度再发（该上游对并发极敏感）。
-export function createGate({ limit = 3 } = {}) {
+//
+// 两道约束同时生效：
+//  ① 在途并发（active < cap）：同一时刻打到上游的请求数 ≤3。
+//  ② 最近窗口内已开会话数（opens < cap）：上游按「账号最近约 90s 内打开过的会话数」判限，
+//     每个请求占一个会话槽、**请求结束不立即释放**（实测 ~80s 才回收）。只压 ① 不够——
+//     串行连发 4 个（间隔 1s）第 4 个仍被拒 TM.00001041 并发会话数已达上限(3个)（2026-10-19 现网实测）。
+//     故本闸维护「窗口内已开会话」这个**动态值**，到 cap 就让下一个请求等到最早一次会话过期再放。
+const DEFAULT_SESSION_WINDOW_MS = 90_000;
+
+export function createGate({ limit = 3, sessionWindowMs = DEFAULT_SESSION_WINDOW_MS } = {}) {
   const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : Infinity;
+  const winMs = Number.isFinite(sessionWindowMs) && sessionWindowMs >= 0 ? sessionWindowMs : DEFAULT_SESSION_WINDOW_MS;
   let active = 0;
-  const waiters = [];
+  let waiting = 0;
+  const opens = []; // 窗口内每次「开会话」的时间戳（升序）；不随 release 移除，靠时间过期
+
+  function prune(now) {
+    const cut = now - winMs;
+    while (opens.length && opens[0] <= cut) opens.shift();
+  }
 
   function release() {
     active--;
-    const w = waiters.shift();
-    if (w) w();
   }
 
-  // 取得一个槽位，返回「释放一次」的幂等函数。超限时 FIFO 排队（并回调 onWait）。
-  // 关键：释放的时机交给调用方——流式请求必须**等流真正读完/取消**才释放，
-  // 否则 runChat 一返回（流还没消费）就放行，上游其实仍占着会话 ⇒ 第 4 路被上游拒
-  // （TM.00001041 并发会话数已达上限）。见 index.js 的 chat 接线。
+  // 取得一个槽位，返回「释放一次」的幂等函数。释放的时机交给调用方——
+  // 流式请求必须**等流真正读完/取消**才释放 active，否则 runChat 一返回（流还没消费）就放行。
+  // 注意：releaseOnce 只回收 active；窗口内的 opens 记录不被它清掉（会话槽在上游还要占 ~80s）。
   async function acquire(onWait) {
-    if (active >= cap) {
-      const t0 = Date.now();
-      const queued = waiters.length + 1;
-      await new Promise((resolve) => waiters.push(resolve));
-      if (onWait) { try { onWait({ waitedMs: Date.now() - t0, queued, limit: cap }); } catch {} }
+    const t0 = Date.now();
+    let counted = false;
+    for (;;) {
+      const now = Date.now();
+      prune(now);
+      if (active < cap && opens.length < cap) break;
+      if (!counted) { counted = true; waiting++; }
+      // 等到「最早那次会话过期」才能再开；若只是 active 满（窗口还没满），短轮询等释放
+      const untilExpire = opens.length >= cap ? Math.max(0, winMs - (now - opens[0])) : 0;
+      const sleepMs = Math.min(Math.max(untilExpire + 20, 50), 1000);
+      await new Promise((r) => setTimeout(r, sleepMs));
+    }
+    if (counted) {
+      waiting--;
+      if (onWait) { try { onWait({ waitedMs: Date.now() - t0, queued: opens.length, limit: cap, windowMs: winMs }); } catch {} }
     }
     active++;
+    opens.push(Date.now());
     let released = false;
     return function releaseOnce() {
       if (released) return;
@@ -42,8 +66,9 @@ export function createGate({ limit = 3 } = {}) {
   return {
     run,
     acquire,
-    stats: () => ({ active, queued: waiters.length, limit: cap }),
+    stats: () => ({ active, queued: waiting, limit: cap, opens: opens.length, windowMs: winMs }),
     get active() { return active; },
-    get queued() { return waiters.length; },
+    get queued() { return waiting; },
+    get opens() { return opens.length; },
   };
 }

package/src/providers/codearts/index.js

@@ -32,6 +32,7 @@ export function createCodeartsProvider({
   connectTimeoutMs = envInt("MSLXDFF_CODEARTS_TIMEOUT_MS", 30_000),
   cooldownMs = envInt("MSLXDFF_CODEARTS_COOLDOWN_MS", 30_000),
   maxConcurrent = Number.parseInt(process.env.MSLXDFF_CODEARTS_MAX_CONCURRENT ?? "", 10) || 3,
+  sessionWindowMs = Number.parseInt(process.env.MSLXDFF_CODEARTS_SESSION_WINDOW_MS ?? "", 10) || 90_000,
   autoClaim = process.env.MSLXDFF_CODEARTS_AUTO_CLAIM !== "0",
   fetchImpl,
   file,
@@ -61,8 +62,11 @@ export function createCodeartsProvider({
   };
   const pool = createAuthPool({ keys: allKeys, fetchImpl, stsHost, clock, saveFn });
   const catalog = createCatalog();
-  // 该上游对并发极敏感（实测 >3 即坏号/限流）；超限请求 FIFO 排队，不拒绝。
-  const gate = createGate({ limit: maxConcurrent });
+  // 该上游对并发极敏感（实测 >3 即坏号/限流）；且上游按「账号最近约 90s 内打开过的会话数」判限，
+  // 请求结束**不立即释放**槽（实测 ~80s 才回收）——故闸要同时压「在途」与「窗口内已开会话」。
+  // 上限随账号数放大：上游按「账号」限 3 个，N 个号即 3N 个额度，写死 3 会白白浪费后续号。
+  const accountCount = Math.max(1, ring.size || 1);
+  const gate = createGate({ limit: maxConcurrent * accountCount, sessionWindowMs });
 
   let agent = null; let dispatcher = null;
   try {