mslxdff 0.1.99 → 0.1.101

package/package.json

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

package/src/cli/commands/sync.js

@@ -84,7 +84,7 @@ export async function handleSetto(args) {
           if (!norm || norm === "auto") continue;
           // 首次循环也同步 preferred（保持 daemon 热重载语义）
           if (rawId === list[0]) savePreferredModel(norm);
-          const r = await syncToOpencode({ id: norm, token, port, file, keep: pruneKeep() });
+          const r = await syncToOpencode({ id: norm, token, port, file, keep: pruneKeep(), ensureAll: pruneKeep() });
           if (r.action === "inserted") inserted++; else updated++;
           prunedTotal += r.pruned || 0;
           console.log(`  ${r.action} "${r.id}" -> ${r.internal} @ ${file}`);
@@ -156,8 +156,9 @@ export async function handleSetto(args) {
       const envPort = Number(process.env.MSLXDFF_PORT);
       const port = persisted !== null ? persisted : (Number.isInteger(envPort) && envPort > 0 ? envPort : 8989);
       const file = opencodeConfigPath();
-      const r = await syncToOpencode({ id, token, port, file, keep: pruneKeep() });
+      const r = await syncToOpencode({ id, token, port, file, keep: pruneKeep(), ensureAll: pruneKeep() });
       console.log(`synced to opencode: ${r.action} "${r.id}" @ ${file}`);
+      if (r.backfilled) console.log(`  backfilled ${r.backfilled} 个 picks 模型（此前 pick 了但未同步过，现已补齐）`);
       if (r.pruned) console.log(`  pruned ${r.pruned} 个失效模型（未在 picks，不再于 opencode 显示）`);
       console.log(`  url: http://127.0.0.1:${port}/v1`);
       console.log(`  opencode 选 mslxdff/${r.id} 直达本地 ${r.internal}${r.storageKey !== r.internal ? ` (dash→${r.internal} 自动映射)` : ""}`);

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

package/src/sync-opencode.js

@@ -78,7 +78,43 @@ export function pruneOpencodeModels(models, keep, currentKey) {
   return pruned;
 }
 
-export async function syncToOpencode({ id, token, port, file, keep } = {}) {
+// 补齐：把 ensureAll（picks 口径）里缺失的键写入 models（slash → dash + alias 注册）。
+// 返回 { nextModels, backfilled }；ensureAll 非数组或为空时原样返回（backfilled=0）。
+// 注意：需在剪枝之前调用——先补 picks 缺失，再剪 picks 外旧键，结果集恰为 picks ∪ currentKey。
+export async function ensureAllOpencodeModels(models, ensureAll) {
+  if (!Array.isArray(ensureAll) || !ensureAll.length || !models || typeof models !== "object") {
+    return { nextModels: models, backfilled: 0 };
+  }
+  const existing = new Set(Object.keys(models).map(normalizeOpencodeKey));
+  let backfilled = 0;
+  let aliasDirty = false;
+  for (const raw of ensureAll) {
+    const internal = toInternalId(String(raw || "").trim());
+    if (!internal || internal === "auto") continue;
+    const storageKey = internal.includes("/") ? internal.replace(/\//g, "-") : internal;
+    if (!storageKey || existing.has(storageKey)) continue;
+    models[storageKey] = { name: storageKey };
+    existing.add(storageKey);
+    backfilled++;
+    if (internal.includes("/") && storageKey !== internal) {
+      try {
+        const { loadModelAliases, registerModelAlias } = await import("./providers/model-id.js");
+        loadModelAliases();
+        registerModelAlias(storageKey, internal);
+        aliasDirty = true;
+      } catch {}
+    }
+  }
+  if (aliasDirty) {
+    try {
+      const { persistModelAliases } = await import("./providers/model-id.js");
+      persistModelAliases();
+    } catch {}
+  }
+  return { nextModels: models, backfilled };
+}
+
+export async function syncToOpencode({ id, token, port, file, keep, ensureAll } = {}) {
   const targetFile = file || opencodeConfigPath();
   const normalizedRaw = String(id || "").trim();
   if (!normalizedRaw) throw new Error("model id required");
@@ -119,6 +155,7 @@ export async function syncToOpencode({ id, token, port, file, keep } = {}) {
   let action;
   let effectiveId = storageKey;
   let pruned = 0;
+  let backfilled = 0;
   if (oldProvider) {
     const oldModels = oldProvider.models && typeof oldProvider.models === "object" && !Array.isArray(oldProvider.models)
       ? oldProvider.models
@@ -158,6 +195,8 @@ export async function syncToOpencode({ id, token, port, file, keep } = {}) {
       effectiveId = storageKey;
       action = "inserted";
     }
+    const ensured = await ensureAllOpencodeModels(nextModels, ensureAll);
+    backfilled = ensured.backfilled;
     pruned = pruneOpencodeModels(nextModels, keep, storageKey);
     const nextProvider = {
       ...oldProvider,
@@ -177,6 +216,8 @@ export async function syncToOpencode({ id, token, port, file, keep } = {}) {
     if (!data.provider.mslxdff.models[storageKey]) {
       data.provider.mslxdff.models = { [storageKey]: { name: storageKey } };
     }
+    const ensured = await ensureAllOpencodeModels(data.provider.mslxdff.models, ensureAll);
+    backfilled = ensured.backfilled;
     action = "inserted";
   }
 
@@ -208,5 +249,5 @@ export async function syncToOpencode({ id, token, port, file, keep } = {}) {
     }
   } catch {}
 
-  return { action, file: targetFile, id: effectiveId, alias: storageKey, internal, corrupted, storageKey, pruned };
+  return { action, file: targetFile, id: effectiveId, alias: storageKey, internal, corrupted, storageKey, pruned, backfilled };
 }