mslxdff 0.1.214 → 0.1.216

package/package.json

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

package/src/cli/format.js

@@ -70,6 +70,8 @@ export function fmtEvent(e) {
       return `${head} peer win      选中 peer=${e.winPeer} model=${m(e.winTarget)} latency=${e.latencyMs}ms`;
     case "peer-race-lose":
       return `${head} peer lose     组员全部失败 model=${m(e.model)}`;
+    case "peer-skip-slow":
+      return `${head} peer skip     跳过过慢组员 peer=${e.peer} 历史延迟=${e.latencyMs ?? "-"}ms > ${e.capMs ?? "-"}ms`;
     case "fallback":
       return `${head} fallback      ${m(e.from)} -> ${m(e.to)} reason=${m(e.reason)}`;
     case "fallback-notice":

package/src/groups.js

@@ -202,7 +202,10 @@ export function syncPeersFromMembers({ peers, members, myUrl, group, skipIds = [
     if (kind === "broadband" || String(m?.url || "").startsWith("relay://")) continue;
     const url = normalizePeerUrl(m?.url);
     if (!url || url === self) continue;
-    if (peers.add({ name: id, url, token: m?.token || "", group })) added++;
+    // heartbeatLatencyMs：组长在**心跳**里量的成员延迟（成员上报 rttMs）。选路 `ordered()` 在没有
+    // 真实请求 EMA 时回落到它——这就是「组员定时上报的过程中就知道谁延迟更低」。
+    const hbLat = Number.isFinite(Number(m?.latencyMs)) && Number(m.latencyMs) >= 0 ? Number(m.latencyMs) : null;
+    if (peers.add({ name: id, url, token: m?.token || "", group, ...(hbLat != null ? { heartbeatLatencyMs: hbLat } : {}) })) added++;
   }
   return { removed, added, total: Object.keys(members || {}).length };
 }

package/src/model-trace.js

@@ -161,6 +161,8 @@ export function formatModelTrace({ type, reqId, model, data = {}, request = null
     detail = `组员竞速开始 peers=${data.peers ?? "-"}`;
   } else if (type === "peer-budget-out") {
     detail = `组员竞速预算用尽 reason=${safeText(data.reason || "", 80)} budgetMs=${data.budgetMs ?? "-"} remaining=${data.remaining ?? "-"}`;
+  } else if (type === "peer-skip-slow") {
+    detail = `跳过过慢组员 peer=${data.peer || "?"} 历史延迟=${data.latencyMs ?? "-"}ms > 上限=${data.capMs ?? "-"}ms`;
   } else detail = safeText(`${decisionKv(data)} ${data.message || data.error || ""}`, 200);
   return `[${base.time}] [req=${base.req}] [model=${base.model}] [stage=${base.stage}] ${detail}`;
 }

package/src/peers.js

@@ -138,22 +138,32 @@ export function createPeersService({
     return hot * 1_000_000_000 + latency * 1_000 + fails;
   }
 
-  // Available peers ordered for failover: hot peers (recent success) first —
-  // the winner of the last race is reused next. Everyone else is ordered by
-  // when they last failed, earliest first: a peer that failed longer ago has
-  // had more time to recover, so it is tried before a more recent failure.
-  // Peers with no recorded error go after any that failed.
+  // 可用组员排序（用户 2026-10-19 决定）：**延迟最小优先**，不再「热优先」。
+  // 语义 = 「组员的额度用完后，用跟组长延迟最小的组员」——延迟是首要判据。
+  // 延迟来源（优先级从高到低）：
+  //   ① stats 里的真实请求 EMA（recordResult 记的 latencyMs）——最可信；
+  //   ② peer.heartbeatLatencyMs —— 组员**定时心跳**上报的 rtt（没跑过真实请求时也能排序）；
+  // 未测过延迟的排在有数据之后；同延迟按「最早失败优先」；都没失败过的排最后。
+  function peerLatency(p) {
+    const s = stats[p.url]?.latencyMs;
+    if (s != null) return s;
+    const hb = list.find((x) => x.url === p.url)?.heartbeatLatencyMs;
+    return Number.isFinite(Number(hb)) ? Number(hb) : null;
+  }
+
   function ordered(t = now()) {
     return available().sort((a, b) => {
-      const hotA = stats[a.url]?.okAt && t - stats[a.url].okAt < heatMs ? 0 : 1;
-      const hotB = stats[b.url]?.okAt && t - stats[b.url].okAt < heatMs ? 0 : 1;
-      if (hotA !== hotB) return hotA - hotB;
+      const la = peerLatency(a);
+      const lb = peerLatency(b);
+      const ha = la != null, hb = lb != null;
+      if (ha !== hb) return ha ? -1 : 1;          // 有延迟数据的优先
+      if (ha && hb && la !== lb) return la - lb;  // 延迟小的先上
       const ea = lastErrorAt[a.url];
       const eb = lastErrorAt[b.url];
       if (ea == null && eb == null) return 0;
-      if (ea == null) return 1; // never-failed peers go after any that failed
+      if (ea == null) return 1;
       if (eb == null) return -1;
-      return ea - eb; // earliest failure first
+      return ea - eb;
     });
   }
 

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 判定按账号隔离）

package/src/routes/groups-relay.js

@@ -18,6 +18,7 @@ function snippet(v, n = 300) {
 }
 
 export async function heartbeatHandler({ req, res, groups, bus, logs }) {
+  const tRecv = Date.now();
   const auth = /^Bearer (.+)$/.exec(req.headers["authorization"] || "");
   if (!auth) return json(res, 401, { error: "bearer token required" });
   let body;
@@ -36,9 +37,19 @@ export async function heartbeatHandler({ req, res, groups, bus, logs }) {
       if (m) {
         m.publicIp = ip;
         m.lastSeen = Date.now();
-        try { groups.upsertMember(groupName, { memberName: targetId, url: m.url, token: m.token, kind: "broadband", publicIp: ip, lastSeen: m.lastSeen }); } catch {}
+        // 延迟采样（心跳即可得，无需真实请求）：
+        //   rttMs  = 成员自己量的「上一轮心跳往返」（它到组长的网络路径）
+        //   serverMs = 组长这一侧从收到到处理完的耗时
+        // 两者取有值的那个写进成员记录，供选路按「延迟最小优先」排序（routes/peers.js ordered）。
+        const reportedRtt = Number(body?.rttMs);
+        const memberRtt = Number.isFinite(reportedRtt) && reportedRtt >= 0 ? Math.round(reportedRtt) : null;
+        if (memberRtt != null) m.latencyMs = memberRtt;
+        try {
+          groups.upsertMember(groupName, { memberName: targetId, url: m.url, token: m.token, kind: "broadband", publicIp: ip, lastSeen: m.lastSeen, ...(memberRtt != null ? { latencyMs: memberRtt } : {}) });
+        } catch {}
       }
-      const evtData = { ts: Date.now(), type: "relay-heartbeat", member: targetId, ip, lastSeen: m?.lastSeen, group: groupName };
+      const serverMs = Date.now() - tRecv;
+      const evtData = { ts: Date.now(), type: "relay-heartbeat", member: targetId, ip, lastSeen: m?.lastSeen, rttMs: Number.isFinite(Number(body?.rttMs)) ? Number(body.rttMs) : null, serverMs, group: groupName };
       if (bus) bus.emit(evtData);
       logs?.appendEvent?.(evtData);
     }

package/src/routes/peer-serial.js

@@ -0,0 +1,99 @@
+// 组员串行选路（用户 2026-10-19 决定：不竞速）。
+//
+// 为什么改：并发赛跑会同时占用多个组员的额度/连接，慢节点还会拖住整批；而用户要的语义是
+// 「本机额度用完 → 用延迟最小的组员」，延迟小的先上、不行再下一个。串行让这条优先级真正生效。
+//
+// 本模块只做「按序试」这件事，其余（画目标、转发、记账、事件名）从 peers.js 注入，避免循环依赖。
+export const PEER_SERIAL = true;
+
+/**
+ * 串行试候选：一次只打一个，成功即返回；失败顺位试下一个。
+ *
+ * @param {object} p
+ * @param {Array}  p.candidates        已按「延迟最小优先」排好的组员
+ * @param {object} p.ctx               请求上下文（evt/peers/body/hops/plugins/peerErrors/triedUrls…）
+ * @param {Set}    p.tried             已试过的 url 集合
+ * @param {object} p.deps              { resolvePeerTarget, forwardToPeer, peerName, recordLater,
+ *                                       summarizeRequest, runHook, errMsg, perAttemptCap, deadline, budgetMs }
+ * @returns {Promise<null | {peer, target, res, latencyMs}>}
+ */
+export async function serialTryPeers({ candidates, ctx, tried, deps }) {
+  const {
+    resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
+    perAttemptCap, deadline, budgetMs,
+  } = deps;
+  const failed = [];
+  // 延迟上限过滤：历史延迟超过「单次尝试上限」的组员直接跳过（它大概率又超时）。
+  // 只在**还有别的候选**时才跳过，避免把唯一可用的节点也跳没了。
+  const ranked = candidates.filter((p) => {
+    let lat = null;
+    try {
+      // 与 ordered() 同源：先看真实请求 EMA，再回落到心跳上报的 rtt
+      lat = ctx.peers?.stat?.(p.url)?.latencyMs ?? p.heartbeatLatencyMs ?? null;
+      if (lat != null) lat = Number(lat);
+    } catch { lat = null; }
+    if (lat == null || !Number.isFinite(lat) || lat <= perAttemptCap) return true;
+    if (candidates.length <= 1) return true; // 只剩它 → 仍然试
+    ctx.evt("peer-skip-slow", { peer: p.url, name: peerName(p), latencyMs: lat, capMs: perAttemptCap });
+    return false;
+  });
+
+  for (let i = 0; i < ranked.length; i++) {
+    if (deadline > 0 && Date.now() >= deadline) {
+      ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽`, budgetMs, remaining: ranked.length - i });
+      break;
+    }
+    const prepared = await resolvePeerTarget(ctx, ranked[i]);
+    if (!prepared) continue;
+    const { peer, target } = prepared;
+    tried.add(peer.url);
+    const ctrl = new AbortController();
+    const name = peerName(peer);
+    ctx.evt("peer-request", { peer: peer.url, name, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body), serial: i + 1 });
+    if (ctx.plugins?.length) {
+      runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});
+    }
+    const remainingMs = deadline > 0 ? deadline - Date.now() : 0;
+    // 单个组员的等待上限 = min(阶段剩余预算, 单次尝试上限)。单次上限保证黑洞节点
+    // 不会吃掉整个阶段（否则延迟最小的好组员轮不到）。
+    const waitMs = deadline > 0 ? Math.max(1, Math.min(perAttemptCap, remainingMs)) : perAttemptCap;
+    const t0 = performance.now();
+    const res = await forwardToPeer(peer, ctx.body, target, ctx.hops, ctrl, waitMs);
+    const latencyMs = Math.round(performance.now() - t0);
+    const isErr = res instanceof Error;
+    const status = isErr ? 502 : res.status;
+    if (ctx.plugins?.length) {
+      runHook(ctx.plugins, "peer:result", { reqId: ctx.reqId, peer: peer.url, model: target, ok: !(isErr || status >= 400), status, latencyMs }).catch(() => {});
+    }
+    if (isErr || status >= 400) {
+      const msg = isErr ? errMsg(res).slice(0, 200) : null;
+      if (Array.isArray(ctx.peerErrors)) ctx.peerErrors.push({ peer: peer.url, status, message: msg });
+      ctx.evt("peer-attempt", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: false, status, message: msg });
+      ctx.evt("peer-error", { peer: peer.url, name, model: target, status, message: msg });
+      failed.push({ ok: false, peer, target, res, status });
+      recordLater(() => ctx.peers.recordError(peer.url, { status, message: msg }));
+      recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
+      continue; // 串行：试下一个
+    }
+    ctx.evt("peer-forward", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: true, status });
+    return { peer, target, res, latencyMs };
+  }
+
+  // 全败：补读失败响应体（诊断 + 调用者详情）
+  await Promise.all(failed.map(async (o) => {
+    if (!o.res || typeof o.res !== "object" || o.res instanceof Error) return;
+    try {
+      const snip = String(await Promise.race([
+        o.res.clone().text(),
+        new Promise((r) => { const t = setTimeout(() => r(""), 600); t.unref?.(); }),
+      ])).replace(/\s+/g, " ").slice(0, 300);
+      if (!snip) return;
+      if (Array.isArray(ctx.peerErrors)) {
+        const rec = ctx.peerErrors.find((x) => x.peer === o.peer.url && x.status === o.status && !x.message);
+        if (rec) rec.message = snip;
+      }
+      ctx.evt("peer-error", { peer: o.peer.url, name: peerName(o.peer), model: o.target, status: o.status, message: `body=${snip}` });
+    } catch {}
+  }));
+  return null;
+}

package/src/routes/peers.js

@@ -4,6 +4,7 @@ import { errMsg } from "./helpers.js";
 import { runHook } from "../plugins.js";
 import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
 import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
+import { serialTryPeers, PEER_SERIAL } from "./peer-serial.js";
 
 // peer 阶段总预算：三批候选（ordered / orderedByLastError / coolingByLastError）共享同一个
 // 截止时间，而不是每批各吃满一次等头超时。实测最坏路径是三批串行各 30s（≈90s），
@@ -34,6 +35,15 @@ function peerConnectTimeoutMs() {
   return Number.isInteger(n) && n > 0 ? n : DEFAULT_PEER_CONNECT_TIMEOUT_MS;
 }
 
+// 单组员等待上限（串行模式下逐个体生效，MSLXDFF_PEER_ATTEMPT_TIMEOUT_MS，缺省 20s）。
+// 为什么必须限：串行是「一个失败才试下一个」，若一个黑洞节点吃满 120s（bodyTimeout），
+// 后面延迟更小的好组员根本轮不到——实测 172.93.221.187 常 38~44s 才回/被 abort。
+// 20s 足以覆盖正常首包，又不会让一个坏节点吃掉整个阶段预算；可用 env 调。
+function peerAttemptTimeoutMs() {
+  const n = Number(process.env.MSLXDFF_PEER_ATTEMPT_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : 20_000;
+}
+
 // peer 阶段总预算（MSLXDFF_PEER_RACE_BUDGET_MS，0=不限）：一次 peer 阶段（同批或若干批候选）
 // 共享同一个截止时刻。调用方用 peerStageCtx() 起一个阶段，别把 deadline 挂在整个请求上下文上——
 // 否则前一个候选把预算吃光，后一个候选一进 peer 阶段就直接放弃。
@@ -249,6 +259,10 @@ function peerName(peer) {
   return String(peer?.name || "").trim() || null;
 }
 
+// 组员试法：**串行**（用户 2026-10-19 决定：不竞速）。实现在 ./peer-serial.js，
+// 本文件只保留调度与并发版（PEER_SERIAL=false 时的旧路径）。
+export { PEER_SERIAL };
+
 export async function racePeerCandidates(candidates, ctx) {
   const tried = (ctx.triedUrls ??= new Set());
   const fresh = candidates.filter((p) => !tried.has(p.url));
@@ -256,6 +270,15 @@ export async function racePeerCandidates(candidates, ctx) {
   // 没传的阶段（单批调用）不带预算——保持旧行为，不外溢到整条请求。
   const budgetMs = ctx.peerRaceBudgetMs ?? 0;
   const deadline = Number(ctx.peerRaceDeadline) || 0;
+
+  // 串行：按 candidates 的既有次序（调用方已按「延迟最小优先」排好）逐个试。
+  if (PEER_SERIAL) {
+    return serialTryPeers({
+      candidates: fresh, ctx, tried,
+      deps: { resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg, perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs },
+    });
+  }
+
   for (let i = 0; i < fresh.length; i += PEER_RACE_LIMIT) {
     if (deadline > 0 && Date.now() >= deadline) {
       ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽`, budgetMs, remaining: fresh.length - i });

package/src/runtime/broadband.js

@@ -97,20 +97,30 @@ export function startBroadband({ token, upstream, logs, log = console.log }) {
     return true;
   })();
   const execAndPost = createBroadbandExec({ token, upstream, logs, log });
+  // 心跳往返延迟：成员侧自己量「上一轮 heartbeat 的 RTT」，随下一次心跳上报给组长。
+  // 组长侧据此排序「谁的延迟更低」（选路=延迟最小优先，见 routes/peers.js 的 ordered）。
+  // 用上一轮而不是本轮的原因：本轮 RTT 要等响应回来才知道，来不及带在这次请求里。
+  const hbRtt = new Map(); // group name -> ms
   const doHeartbeat = async () => {
     for (const g of broadbandGroups()) {
       try {
+        const t0 = Date.now();
         const res = await compatFetch(`${g.leaderUrl}/v1/groups/relay/heartbeat`, {
           method: "POST",
           headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
-          body: JSON.stringify({ name: g.name, group: g.name }),
+          body: JSON.stringify({ name: g.name, group: g.name, rttMs: hbRtt.get(g.name) ?? null }),
           signal: timeoutSignal(5000),
         });
+        const rtt = Date.now() - t0;
+        hbRtt.set(g.name, rtt);
         if (!res.ok) {
           const txt = await res.text().catch(() => "");
           log(`broadband heartbeat ${g.name}: ${res.status} ${txt.slice(0, 100)}`);
+        } else {
+          log(`broadband heartbeat ${g.name}: ok rtt=${rtt}ms`);
         }
       } catch (err) {
+        hbRtt.delete(g.name);
         log(`broadband heartbeat ${g.name}: failed — ${errMsg(err)}`);
       }
     }

package/src/upstream-engine/index.js

@@ -46,10 +46,22 @@ 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 配置下存在）；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);
+      // 保留 legacy 的匿名重试语义（仅 !anonFirst 配置下存在）；free-429 的**请求内 v6 换出口**
+      // 也走这条委派——重试环在 legacy.chat 里。
+      // ⚠ 顺序契约（用户 2026-10-19）：先借人（组员/组长，用对方 IPv4 出口），全都用完才换出口。
+      //   故 v6 换出口**默认关**，只有显式 MSLXDFF_V6_INREQUEST_ROTATE=1 才委派；
+      //   默认把 429 原样返回，交给 chat-pipeline 去试组员/组长。
+      const v6RotateOn = (() => {
+        const raw = process.env.MSLXDFF_V6_INREQUEST_ROTATE;
+        if (raw === undefined || raw === null || raw === "") return false;
+        const s = String(raw).trim().toLowerCase();
+        return !(s === "0" || s === "false" || s === "off" || s === "no");
+      })();
+      const canRotate = v6RotateOn && typeof dispatcher?.rotateFor === "function";
+      // 原语义：撞 429 且是 free 模型，且（非匿名首试 或 有 v6 池可换址）⇒ 委派 legacy 重试环。
+      // 新语义：**只有显式开启 v6 请求内换址时才委派**；默认 429 原样返回，交给上层去借人
+      // （组员/组长，用对方 IPv4 出口），符合用户 2026-10-19 的「先借人再换出口」顺序。
+      if (res.status === 429 && isFreeModel(body?.model) && (anonFirst ? canRotate : v6RotateOn)) return legacy.chat(body);
       return res;
     } catch (e) {
       if (e && e._sdkLoadFailed) {

package/src/upstream.js

@@ -188,14 +188,24 @@ 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 退回客户端/组长、留给"下一个请求"。
+    // 请求内换出口（v6 池）：撞 429 时在同一请求里换源地址重发。
+    //
+    // ⚠ 顺序契约（用户 2026-10-19 明确）：**先借人，再换出口**。
+    //   429 ⇒ ① 先走组员/组长接力（用**对方的 IPv4 出口**）；② 全都没得用/都失败，
+    //   才轮到 WARP / IPv6 换出口拿"新的自然额度"。WARP/IPv6 是另一层兜底，不该抢在借人之前。
+    //   故本功能**默认关闭**，需要时才显式开：MSLXDFF_V6_INREQUEST_ROTATE=1（原 ADR-0061 行为）。
+    //   关闭时 429 原样交回上层 → chat-pipeline 去试组员/组长，符合用户要的顺序。
     // 边界（探测实证过的硬约束）：① 仅头部即 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 inRequestRotateOn = (() => {
+      const raw = process.env.MSLXDFF_V6_INREQUEST_ROTATE;
+      if (raw === undefined || raw === null || raw === "") return false; // 缺省关：先借人
+      const s = String(raw).trim().toLowerCase();
+      return !(s === "0" || s === "false" || s === "off" || s === "no");
+    })();
+    if (inRequestRotateOn && 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) {