mslxdff 0.1.217 → 0.1.218

package/package.json

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

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 {