mslxdff 0.1.199 → 0.1.200

package/package.json

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

package/src/upstream-engine/index.js

@@ -46,8 +46,10 @@ export function createUpstreamEngine(opts = {}) {
         const via = useResponses ? "@ai-sdk/openai · responses" : "@ai-sdk/openai-compatible · chat";
         try { console.error(`[upstream-engine] sdk 引擎生效（${via}）`); } catch {}
       }
-      // 保留 legacy 的匿名重试语义（仅 !anonFirst 配置下存在）
-      if (res.status === 429 && !anonFirst && isFreeModel(body?.model)) return legacy.chat(body);
+      // 保留 legacy 的匿名重试语义（仅 !anonFirst 配置下存在）；G1a 起 free-429 的**请求内 v6 换出口**
+      // 也走这条委派——重试环在 legacy.chat 里，SDK 通道撞 429 不委派就等于把换出口的额度白白留给下一发。
+      // 无 rotateFor 的 dispatcher（直连/WARP）且 anonFirst 时维持旧行为（不重复打流量）。
+      if (res.status === 429 && isFreeModel(body?.model) && (!anonFirst || typeof dispatcher?.rotateFor === "function")) return legacy.chat(body);
       return res;
     } catch (e) {
       if (e && e._sdkLoadFailed) {

package/src/upstream.js

@@ -33,6 +33,11 @@ function envInt(name, fallback) {
   const v = Number(process.env[name]);
   return Number.isInteger(v) && v > 0 ? v : fallback;
 }
+/** 允许 0 的数值 env（G1a 的逃生阀要认 0=关；envInt 的 `v>0` 会把 0 吞回默认值，那就是个假开关）。 */
+function envIntOrZero(name, fallback) {
+  const v = Number(process.env[name]);
+  return Number.isInteger(v) && v >= 0 ? v : fallback;
+}
 function isPreheatDisabled() {
   const raw = process.env.MSLXDFF_PREHEAT;
   if (raw === undefined || raw === null || raw === "") return false;
@@ -164,11 +169,12 @@ export function createUpstreamClient({
 
      // 首发请求（transport 已处理 network/429 等重试）
     let res;
+    const firstHeaders = buildHeaders(reqBody, { sessionId });
     try {
       res = await transport.request({
         url,
         method: "POST",
-        headers: buildHeaders(reqBody, { sessionId }),
+        headers: firstHeaders,
         body: reqBody,
         stream: reqBody.stream !== false,
         timeoutMs: connectTimeoutMs,
@@ -182,6 +188,52 @@ export function createUpstreamClient({
       try { console.error(`[free-lane] resp model=${body?.model} status=${res.status} ct=${res.headers?.get?.("content-type") || ""}`); } catch {}
     }
 
+    // G1a（ADR-0061）**请求内**榨干 v6 出口池：free 模型撞出口池级 429 时，await dispatcher 换一个新
+    // 源地址、在**同一请求内**重发——额度按出口 IP 计，本节点 v6 池里的其余地址这一发就该用上，
+    // 而不是把 429 退回客户端/组长、留给"下一个请求"。
+    // 边界（探测实证过的硬约束）：① 仅头部即 429 才换（不碰半开的 200 流）；② 429 错误体已被
+    // transport 非流分支读尽，无连接泄漏；③ 每轮换的是 session 粘的那个槽（swap 原地换 addr/e.agent，
+    // 粘性映射不失效）；④ 次数上限防 429 风暴空烧认领地址；⑤ 无 rotateFor 的 dispatcher（直连/WARP）
+    // 条件短路——WARP 换出口=重注册设备 6s~600s，在请求内做只会白等，**设计上排除**。
+    if (freeLane && res.status === 429 && typeof transport.dispatcher?.rotateFor === "function") {
+      const maxRot = envIntOrZero("MSLXDFF_V6_INREQUEST_RETRIES", 3); // 0 = 关掉请求内换出口
+      let rotated = 0;
+      while (res.status === 429 && rotated < maxRot) {
+        let next = null;
+        try {
+          // 用**线上传的那个** session 头定位粘性槽（无 messages 时 buildHeaders 兜底成进程级
+          // FALLBACK_SESSION；传 null 会让 selector 轮转到别的槽，换掉一个没准真没耗尽的健康出口）
+          next = await transport.dispatcher.rotateFor(firstHeaders["x-opencode-session"] || "");
+        } catch { break; }
+        if (!next?.agent) break; // 换不到新出口（空池/全在换址/认领失败）⇒ 正常收场，不黑洞
+        rotated += 1;
+        if (laneDebug) {
+          try { console.error(`[free-lane] v6 in-request rotate #${rotated} ${next.from} -> ${next.addr} model=${body?.model}`); } catch {}
+        }
+        try {
+          res = await transport.request({
+            url,
+            method: "POST",
+            headers: buildHeaders(reqBody, { sessionId }),
+            body: reqBody,
+            stream: reqBody.stream !== false,
+            timeoutMs: connectTimeoutMs,
+            retry,
+            dispatcher: next.agent, // per-call 出口：绕开 extDispatcher 的旧槽选择
+          });
+        } catch (e) {
+          e._t = e._t || { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - t0) };
+          throw e;
+        }
+      }
+      if (rotated) {
+        res._t = { ...(res._t || {}), egressRotations: rotated, egressRecovered: res.status < 400 };
+        try {
+          appendFile(freeAnonLogFile(), `${fmtShanghaiYMDHMS(new Date())} model=${body?.model} v6-in-request-rotations=${rotated} finalStatus=${res.status}\n`).catch(() => {});
+        } catch {}
+      }
+    }
+
     // 匿名兜底：仅非 anonFirst 时，public 429 + free 模型才走 hermes 空头重试
     if (!anonFirst && res.status === 429 && isFreeModel(body?.model) && shouldTryAnonFree()) {
       const anonRetries = envInt("MSLXDFF_FREE_ANON_RETRIES", 3);

package/src/v6pool/rotate.js

@@ -195,6 +195,30 @@ export function createV6Dispatcher({
     /** 手动换某个槽的源地址（供运维/测试；正常路径由配额信号触发）。 */
     swap,
 
+    /**
+     * G1a（ADR-0061）：**请求内**换出口——撞出口池级 429 后由 upstream.js await 这一发，
+     * 把该会话粘的槽换新源地址，返回**换址完成后**的新 Agent 供同一请求立刻重发。
+     * 与 onTap 的 fire-and-forget 换址（只救下一个请求）不同，这里救的是**在飞请求**。
+     * 仅 v6 池提供本方法：换源地址成本≈0（bind/ip addr add）；WARP 的换出口=重注册设备
+     * （6s~600s，会被 CF 限流），绝不允许在请求内做——白等 N 分钟换不来更快收场。
+     * 空池/全槽换址中/该槽被并发占走 ⇒ 返回 null（调用方正常收场，绝不黑洞）。
+     * 粘性安全：swap 是**原地**换 e.addr/e.agent（index 不变），session→slot 映射不失效。
+     * @param {string} sessionKey x-opencode-session 值（无 key 时由轮转游标挑槽）
+     * @returns {Promise<null | {agent: object, addr: string, from: string}>}
+     */
+    async rotateFor(sessionKey = "") {
+      if (!list.length) return null;
+      const avail = availableIndexes();
+      if (!avail.length) return null;
+      const index = selector.pick(avail, strategy === "session" ? sessionKey : "");
+      const e = list[index];
+      if (!e) return null;
+      const r = await swap(index, { kind: "in-request-rotate", status: 429, forced: true });
+      if (r.skipped) return null;
+      const slot = list[index];
+      return { agent: slot.agent, addr: slot.addr, from: r.from };
+    },
+
     /** 只读快照（含已退休出口的最终计数——"换址到底有没有换来新额度"看这里）。 */
     stats() {
       const t = now();