mslxdff 0.1.99 → 0.1.100

package/package.json

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

package/src/providers/deepseek/auth.js

@@ -1,6 +1,8 @@
 // DeepSeek 账号池 + 登录（Android 协议）
 // 上游协议参考 iidamie/deepseek2api（GPL-3.0，协议事实）
+// 并发闸门参考 Chat2API-WXS per-account guard：每 token 在途限 1，全忙 FIFO 排队，流结束释放
 import { compatFetch } from "../../compat.js";
+import { envInt } from "../base.js";
 import { androidHeaders } from "./pow.js";
 import { DEEPSEEK_DEFAULT_BASE, DEEPSEEK_API_PREFIX } from "./pow.js";
 import { dsDebug } from "./debug.js";
@@ -56,7 +58,7 @@ export async function loginDeepseek({ loginValue, password, areaCode = "+86", fe
 }
 
 // 多账号轮换池：空闲最久优先 + 冷却 + onError；轮换语义对齐 NIyueeE/ds-free-api（选空闲最久者，最大化每次使用间隔）
-export function createAuthPool({ tokens = [], cooldownMs = DEFAULT_COOLDOWN_MS, clock = Date.now } = {}) {
+export function createAuthPool({ tokens = [], cooldownMs = DEFAULT_COOLDOWN_MS, clock = Date.now, maxConcurrentPerToken: maxConcParam } = {}) {
   const list = [...new Set((tokens || []).map((t) => String(t).trim()).filter(Boolean))];
   const until = new Map(); // token → 冷却到期时刻
   const lastUsedAt = new Map(); // token → 最近一次被取用时刻（空闲最久排序依据）
@@ -107,5 +109,86 @@ export function createAuthPool({ tokens = [], cooldownMs = DEFAULT_COOLDOWN_MS,
     return token;
   }
 
-  return { next, onError, available, requireToken, size: list.length, cooldownMs, keys: [...list] };
+  // ---------------------------------------------------------------------------
+  // 并发闸门：每 token 最多 maxConcurrentPerToken 个在途请求（默认 1 = 禁止并发）
+  // acquireSlot → { token, release } | null(超时)；release 幂等，流式在 cleanup 链释放
+  // ---------------------------------------------------------------------------
+  const maxConcurrentPerToken = Math.max(1, Number(maxConcParam) > 0 ? Number(maxConcParam) : envInt("MSLXDFF_DEEPSEEK_MAX_CONCURRENT", 1));
+  const inFlight = new Map(); // token → 在途数
+  const waiters = []; // FIFO 等待队列：{ resolve, timer }
+
+  function inflightOf(token) {
+    return inFlight.get(token) || 0;
+  }
+
+  // 空闲（未冷却且在途未满）的号里选空闲最久者；无 → null
+  function nextIdle() {
+    let best = null;
+    let bestIdle = -1;
+    for (const token of list) {
+      if (isCooling(token) || inflightOf(token) >= maxConcurrentPerToken) continue;
+      const idle = clock() - (lastUsedAt.get(token) || 0);
+      if (idle > bestIdle) {
+        bestIdle = idle;
+        best = token;
+      }
+    }
+    return best;
+  }
+
+  function makeRelease(token) {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      inFlight.set(token, Math.max(0, inflightOf(token) - 1));
+      dsDebug("gate", { event: "release", tokenTail: String(token).slice(-6), inFlight: inflightOf(token) });
+      wakeNext();
+    };
+  }
+
+  // 有槽位释放 → 唤醒队首等待者重新竞争（重新走 nextIdle，天然跳过冷却/满载号）
+  function wakeNext() {
+    while (waiters.length) {
+      const w = waiters.shift();
+      clearTimeout(w.timer);
+      const token = nextIdle();
+      if (!token) { waiters.unshift(w); break; } // 没有可用槽位，塞回队首等下次 release
+      lastUsedAt.set(token, clock());
+      inFlight.set(token, inflightOf(token) + 1);
+      dsDebug("gate", { event: "wakeup", tokenTail: String(token).slice(-6), queue: waiters.length });
+      w.resolve({ token, release: makeRelease(token) });
+    }
+  }
+
+  async function acquireSlot({ timeoutMs } = {}) {
+    const timeout = Number(timeoutMs) > 0 ? Number(timeoutMs) : envInt("MSLXDFF_DEEPSEEK_QUEUE_TIMEOUT_MS", 30_000);
+    const token = nextIdle();
+    if (token) {
+      lastUsedAt.set(token, clock());
+      inFlight.set(token, inflightOf(token) + 1);
+      dsDebug("gate", { event: "acquire-direct", tokenTail: String(token).slice(-6), inFlight: inflightOf(token) });
+      return { token, release: makeRelease(token) };
+    }
+    if (!list.length) {
+      const err = new Error("缺少 DeepSeek 凭据，请先 -provider deepseek login 或设置 providerConfigs.deepseek.keys");
+      err._deepseekNoAuth = true;
+      throw err;
+    }
+    // 全忙：入 FIFO 队列等待 release 唤醒；超时返回 null。
+    // 定时器不 unref：有请求在排队 = 有未完成工作，事件循环必须等它（unref 会让进程提前退出）
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        const i = waiters.indexOf(w);
+        if (i >= 0) waiters.splice(i, 1);
+        dsDebug("gate", { event: "acquire-timeout", queue: waiters.length });
+        resolve(null);
+      }, timeout);
+      const w = { resolve, timer };
+      waiters.push(w);
+      dsDebug("gate", { event: "enqueue", queue: waiters.length, timeoutMs: timeout });
+    });
+  }
+
+  return { next, onError, available, requireToken, acquireSlot, maxConcurrentPerToken, size: list.length, cooldownMs, keys: [...list] };
 }

package/src/providers/deepseek/chat.js

@@ -183,17 +183,26 @@ export async function runDeepseekChat({ body, authPool, fetchImpl, dispatcher, b
 
   const maxAttempts = maxAuthRetries ?? Math.max(1, authPool.size);
   for (let attempt = 0; attempt <= maxAttempts; attempt++) {
-    const token = authPool.requireToken();
+    // 并发闸门：每 token 在途限 1（MSLXDFF_DEEPSEEK_MAX_CONCURRENT），全忙排队，超时人话 429
+    const slot = await authPool.acquireSlot({});
+    if (!slot) {
+      throw upstreamError("DeepSeek: 所有账号都在忙（并发闸门排队超时），稍后重试或调大 MSLXDFF_DEEPSEEK_QUEUE_TIMEOUT_MS / MSLXDFF_DEEPSEEK_MAX_CONCURRENT", { status: 429 });
+    }
+    const { token, release } = slot;
     try {
       const out = prompt.length > threshold
         ? await runChunked({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs, threshold })
         : await runOnce({ token, flags, prompt, isStream, fetchImpl, dispatcher, baseUrl, connectTimeoutMs });
       if (out.kind === "stream") {
+        // 流式：槽位由 cleanup 链释放（buildOpenAiSseStream 的 done/error/cancel），此处不放
+        const prevCleanup = out.cleanup;
         return {
           kind: "stream",
           res: out.res,
           token,
-          cleanup: () => deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl }),
+          cleanup: async () => {
+            try { await prevCleanup?.(); } finally { release(); }
+          },
         };
       }
       const sseText = await readBodyText(out.res);
@@ -209,11 +218,15 @@ export async function runDeepseekChat({ body, authPool, fetchImpl, dispatcher, b
         dsDump("aggregate", "EMPTY aggregate content! full sseText", sseText, 8000);
       }
       await deleteChatSession({ token: out.token, sessionId: out.sessionId, fetchImpl, dispatcher, baseUrl });
+      release(); // 聚合成功：槽位随会话删除一并释放
       return { kind: "json", data };
     } catch (err) {
+      release(); // 失败（含 rotateAuth 重试）：立即释放，避免槽位泄漏
       dsError(`chat attempt=${attempt}`, err);
       if (err?._rotateAuth) authPool.onError(token, { cooldownMs: err._cooldownMs });
-      if (!err?._rotateAuth || attempt >= maxAttempts - 1) throw err;
+      // 会话创建/删除阶段的 401/403 也属凭据被拒（session.js 带 status），与 completion 阶段对齐
+      else if (err?.status === 401 || err?.status === 403) authPool.onError(token, { cooldownMs: COOLDOWN_PRESETS.default });
+      if (!(err?._rotateAuth || err?.status === 401 || err?.status === 403) || attempt >= maxAttempts - 1) throw err;
     }
   }
   throw upstreamError("DeepSeek: 所有账号均不可用", {});

package/src/providers/deepseek/session.js

@@ -30,7 +30,10 @@ export async function createChatSession({ token, fetchImpl, dispatcher, baseUrl
   const id = data?.data?.biz_data?.chat_session?.id ?? data?.data?.biz_data?.id;
   if (!res.ok || data?.data?.biz_code !== 0 || !id) {
     const msg = data?.data?.biz_msg || data?.msg || "响应缺少会话 id";
-    throw new Error(`DeepSeek 会话创建失败: ${msg}${res.ok ? "" : ` (http ${res.status})`}`);
+    const err = new Error(`DeepSeek 会话创建失败: ${msg}${res.ok ? "" : ` (http ${res.status})`}`);
+    // 401/403 = 凭据被拒：带 status 供上层 rotateAuth（与 completion 阶段 classifyFailure 对齐）
+    if (res.status === 401 || res.status === 403) err.status = res.status;
+    throw err;
   }
   return id;
 }