mslxdff 0.1.215 → 0.1.217

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.215",
+  "version": "0.1.217",
   "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

@@ -10,7 +10,11 @@ export function createGate({ limit = 3 } = {}) {
     if (w) w();
   }
 
-  async function run(fn, onWait) {
+  // 取得一个槽位，返回「释放一次」的幂等函数。超限时 FIFO 排队（并回调 onWait）。
+  // 关键：释放的时机交给调用方——流式请求必须**等流真正读完/取消**才释放，
+  // 否则 runChat 一返回（流还没消费）就放行，上游其实仍占着会话 ⇒ 第 4 路被上游拒
+  // （TM.00001041 并发会话数已达上限）。见 index.js 的 chat 接线。
+  async function acquire(onWait) {
     if (active >= cap) {
       const t0 = Date.now();
       const queued = waiters.length + 1;
@@ -18,15 +22,26 @@ export function createGate({ limit = 3 } = {}) {
       if (onWait) { try { onWait({ waitedMs: Date.now() - t0, queued, limit: cap }); } catch {} }
     }
     active++;
+    let released = false;
+    return function releaseOnce() {
+      if (released) return;
+      released = true;
+      release();
+    };
+  }
+
+  async function run(fn, onWait) {
+    const rel = await acquire(onWait);
     try {
       return await fn();
     } finally {
-      release();
+      rel();
     }
   }
 
   return {
     run,
+    acquire,
     stats: () => ({ active, queued: waiters.length, limit: cap }),
     get active() { return active; },
     get queued() { return waiters.length; },

package/src/providers/codearts/index.js

@@ -82,9 +82,48 @@ export function createCodeartsProvider({
   const onWait = (info) => {
     try { appendEvent({ type: "codearts-queue", ...info }); } catch {}
   };
+  // 流式请求必须在**流真正读完/取消后**才释放并发槽——否则 runChat 一返回（body 还没消费）
+  // 就 release，上游其实仍占着会话 ⇒ 第 4 路被上游拒（TM.00001041 并发会话数已达上限）。
+  // 非流式（JSON）在 runChat 内部已聚合完，可立即释放。返回的 Response 保持原 body 引用，
+  // 只包一层 tee 触发 release；出错也保证释放一次（releaseOnce 幂等）。
+  function holdUntilBodyDone(res, releaseOnce) {
+    const ct = res?.headers?.get?.("content-type") || "";
+    if (!ct.includes("text/event-stream") || !res.body) {
+      releaseOnce();
+      return res;
+    }
+    let done = false;
+    const fin = () => { if (!done) { done = true; releaseOnce(); } };
+    const onErr = () => fin();
+    try {
+      const reader = res.body.getReader();
+      const stream = new ReadableStream({
+        async pull(controller) {
+          try {
+            const { done: d, value } = await reader.read();
+            if (d) { fin(); controller.close(); return; }
+            controller.enqueue(value);
+          } catch (e) { onErr(); controller.error(e); }
+        },
+        cancel(reason) { fin(); try { return reader.cancel(reason); } catch { /* ignore */ } },
+      });
+      return new Response(stream, { status: res.status, statusText: res.statusText, headers: res.headers });
+    } catch {
+      fin();
+      return res;
+    }
+  }
   async function chat(body, opts = {}) {
     if (!ring.size) throw new Error("codearts: missing credential — run: mslxdff -provider codearts login");
-    return gate.run(() => chatSvc.runChat(body, ring, opts), onWait);
+    const rel = await gate.acquire(onWait);
+    let res;
+    try {
+      res = await chatSvc.runChat(body, ring, opts);
+    } catch (err) {
+      rel();
+      throw err;
+    }
+    return holdUntilBodyDone(res, rel);
   }
   async function chatWithKeys(body, keys, opts = {}) {
     const blobs = (keys || []).filter((k) => typeof k === "string" && k.trim().startsWith("{"));
@@ -92,7 +131,15 @@ export function createCodeartsProvider({
     const tmpRing = createKeyRing(blobs, { cooldownMs });
     const tmpPool = createAuthPool({ keys: blobs, fetchImpl, stsHost, clock }); // 借用凭据不写回本节点
     const tmpSvc = createChatService({ id, baseUrl: chatSvcBase, chatPath, fetchImpl, dispatcher: null, authPool: tmpPool, catalog, connectTimeoutMs, clock });
-    return gate.run(() => tmpSvc.runChat(body, tmpRing, opts), onWait);
+    const rel = await gate.acquire(onWait);
+    let res;
+    try {
+      res = await tmpSvc.runChat(body, tmpRing, opts);
+    } catch (err) {
+      rel();
+      throw err;
+    }
+    return holdUntilBodyDone(res, rel);
   }
 
   // 三路发现（主账号）；结果写目录（benefit 判定按账号隔离）