mslxdff 0.1.230 → 0.1.232

package/package.json

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

package/src/providers/agentrouter.js

@@ -1,16 +1,20 @@
-// AgentRouter 定制供应商：OpenAI 兼容聚合网关，有三道硬门槛（2026-10-21 现网 curl 实测）：
+// AgentRouter 定制供应商：OpenAI 兼容聚合网关，有四道硬门槛（2026-10-21 现网 curl 实测）：
 //   ① 客户端身份白名单 —— UA 为 `mslxdff`/`curl`/浏览器一律 401 `unauthorized client detected`，
 //      只放行 `opencode/*` 与 `claude-cli/<ver> (external…)`；
 //   ② 模型分端点 —— `deepseek-v4-flash` 吃 /v1/chat/completions，`gpt-6.1-sol`/`gpt-6-astra`
 //      对该端点回 400「请改用 /v1/responses」，只在 responses 通道可用；
 //   ③ 内容闸 —— 正文含 `x-anthropic` 字样稳定 500 `sensitive words detected`（连 user 消息也拦，
-//      与 workbuddy 只扫 system/assistant 不同），见 stripAgentRouterSensitive。
+//      与 workbuddy 只扫 system/assistant 不同），见 stripAgentRouterSensitive；
+//   ④ 传输层 —— 上游对 Node/undici 的**新建 TCP 连接**选择性丢包（现网对照：undici 0/4~0/6
+//      全 connect 超时，curl 同刻 100% 200，走系统代理亦不稳）⇒ 本家 fetchImpl 缺省换
+//      curl-fetch 子进程通道（`MSLXDFF_AGENTROUTER_FETCH=undici` 可切回）。
 // 故不复用 generic（其 UA 写死 `mslxdff`、responses 判定只认 models.dev npm 索引），这里自组装，
 // 底层仍复用 base.js 的 runner 与 responses-channel 的协议互转。
 import { createKeyRing } from "./keyring.js";
 import { loadProviderBaseUrl, loadProviderKeys } from "../state.js";
 import { createChatRunner, createAgent, envInt, getUndici, joinUrl, collectApiKeysGeneric } from "./base.js";
 import { createResponsesChannel, resolveResponsesPath } from "./responses-channel.js";
+import { createCurlFetch } from "./curl-fetch.js";
 import { compatFetch } from "../compat.js";
 import { opencodeUa } from "../opencode-identity.js";
 import { joinModelId } from "./model-id.js";
@@ -80,7 +84,10 @@ export function createAgentRouterProvider({
 } = {}) {
   if (id !== "agentrouter") throw new Error(`agentrouter provider id mismatch: ${id}`);
   const resolvedBase = resolveAgentRouterBase(baseUrl);
-  if (!fetchImpl) fetchImpl = UndiciFetch || compatFetch;
+  // 传输层缺省走 curl 子进程（见文件头门槛④）：上游对 undici 新建连接选择性丢包，
+  // 实测 curl 同刻稳定。`MSLXDFF_AGENTROUTER_FETCH=undici` 切回 undici（配好上游修复后或对照排查用）。
+  const useCurl = !fetchImpl && String(process.env.MSLXDFF_AGENTROUTER_FETCH || "curl").toLowerCase() !== "undici";
+  if (!fetchImpl) fetchImpl = useCurl ? createCurlFetch() : (UndiciFetch || compatFetch);
 
   const ring = createKeyRing(
     collectApiKeysGeneric(id, apiKeys, apiKey, (pid) => loadProviderKeys(pid, file ? { file } : {})),

package/src/providers/curl-fetch.js

@@ -0,0 +1,155 @@
+// curl-fetch 适配器：fetch(url, init) → curl.exe 子进程 → 标准 Response
+// 背景（ADR-0066 门槛④，2026-10-21 现网取证）：agentrouter 对 Node/undici 新建 TCP 连接
+// 选择性丢包（undici 0/4~0/6 全 connect 超时、curl 同刻 100% 200），供应商传输层整体换 curl。
+// 契约：只消费 init 的 method/headers/body(string)/signal；其余字段（如 undici dispatcher）忽略。
+// 失败语义：拿不到响应头即抛 Error（交上层 runner 的 network 重试/冷却，与 fetch 抛错同语义）。
+// ⚠ 流式关键教训（2026-10-21 本机踩坑）：stdout 必须**立即挂 data 监听进流式（flowing）模式**
+//   ——等消费者 pull 才读会让 curl 写满管道后卡住/退出，res.text() 永不返回；
+//   统一 chunk 队列：header 阶段从队列文本判就绪，body 阶段同一队列续吐，零丢字节。
+// ⚠ 弹窗教训（2026-10-21 用户机实测）：daemon 是无控制台后台进程，spawn 不加 `windowsHide`
+//   时 Windows 会给每个 console 子进程（curl.exe）新开一个控制台窗口——流式+重试+预热
+//   叠加就是窗口轰炸。
+// ⚠ 100-continue 教训（2026-10-21 同批，Claude Code 大 body 实锤）：body 超 ~1KB 时 curl 自动
+//   带 `Expect: 100-continue`，`-D` 头文件先落 `HTTP/1.1 100 Continue` 伪段；若把它当终局
+//   交卷，`new Response(status=100)` 直接 RangeError → 上层 502 → key 冷却 30s 连锁。
+//   双保险：请求侧 `-H "Expect:"` 关掉该机制 + 头解析侧跳过所有 1xx/CONNECT 伪段。
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_CURL = process.env.MSLXDFF_CURL_PATH || "curl.exe";
+const HEAD_WAIT_MS = Number(process.env.MSLXDFF_CURL_HEAD_WAIT_MS) || 15_000; // 等响应头的上限（连接失败由 curl 退出/EOF 提前揭穿）
+// curl 侧整请求硬闸（防无 signal 调用方遗留僵尸进程；runner 的 connectTimeoutMs 通常先到期掐进程）
+const FALLBACK_MAX_TIME_S = Number(process.env.MSLXDFF_CURL_MAX_TIME_S) || 600;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const safeRead = (fp) => { try { return readFileSync(fp, "latin1"); } catch { return ""; } };
+
+/** 1xx 中间应答段（含代理 CONNECT 的 `200 Connection established` 伪应答——curl 虽按 RFC 记
+ *  它为 1xx 语义，现网写出的是 `HTTP/1.1 200 Connection established`，两者都不算终局）。 */
+const INTERMEDIATE_SEGMENT = /^HTTP\/[\d.]+[ \t]+(?:1\d{2}|200[ \t]+Connection established)/i;
+
+/** 解析 curl -D 头文件（代理 CONNECT / 1xx 中间应答都是前置伪段，取最后一个非伪段）。 */
+export function parseHeaderBlob(blob) {
+  const segs = String(blob || "").split(/\r?\n\r?\n/).filter((s) => /^HTTP\//i.test(s.trim()));
+  // 从后往前找第一个「终局」段（非 1xx / 非 CONNECT 伪应答）；全是伪段则回退最后一段
+  let last = segs.length ? segs[segs.length - 1] : String(blob || "");
+  for (let i = segs.length - 1; i >= 0; i--) {
+    if (!INTERMEDIATE_SEGMENT.test(segs[i].trim())) { last = segs[i]; break; }
+  }
+  const m = last.match(/HTTP\/[\d.]+[ \t]+(\d{3})/i);
+  // 伪段状态（1xx）绝不能外泄给 new Response（RangeError → 上层假 502）；归 0 按无头失败处理
+  let status = m ? Number(m[1]) : 0;
+  if (status && status < 200) status = 0;
+  const headers = new Headers();
+  for (const line of last.split(/\r?\n/).slice(1)) {
+    const i = line.indexOf(":");
+    if (i > 0) headers.set(line.slice(0, i).trim(), line.slice(i + 1).trim());
+  }
+  return { status, headers };
+}
+
+/**
+ * 头块是否已完整可交卷：存在至少一个以空行收尾的 HTTP 段，且**最后一个完整段不是**
+ * 1xx 中间应答/代理 CONNECT 伪应答（`-H "Expect:"` 之外的第二道保险：防上游无视 Expect
+ * 仍回 100，或代理链回 CONNECT）。
+ */
+export function headerBlobReady(blob) {
+  const segs = String(blob || "").split(/\r?\n\r?\n/);
+  if (segs.length < 2) return false;
+  const lastFull = segs[segs.length - 2];
+  if (!/^HTTP\//i.test(String(lastFull || "").trim())) return false;
+  if (INTERMEDIATE_SEGMENT.test(String(lastFull).trim())) return false;
+  return true;
+}
+
+/**
+ * 建 fetch 兼容函数。
+ * @param {{curlPath?: string, headWaitMs?: number}} [opts]
+ */
+export function createCurlFetch({ curlPath = DEFAULT_CURL, headWaitMs = HEAD_WAIT_MS } = {}) {
+  const tmpRoot = mkdtempSync(join(tmpdir(), "mslxdff-curl-"));
+  return async function curlFetch(url, init = {}) {
+    const dir = mkdtempSync(join(tmpRoot, "r"));
+    const headerFile = join(dir, "hdr.txt");
+    // `-H "Expect:"`：显式移除 curl 对大 body（>1KB）自动附加的 Expect 头，杜绝 100-continue 往返
+    const args = ["-sS", "-N", "--http1.1", "--max-time", String(FALLBACK_MAX_TIME_S), "-H", "Expect:", "-D", headerFile];
+    const body = init.body != null ? String(init.body) : null;
+    if (body !== null) {
+      const method = init.method && init.method !== "GET" ? init.method : "POST";
+      args.push("-X", method, "--data-binary", "@-");
+    } else if (init.method && init.method !== "GET") {
+      args.push("-X", init.method);
+    }
+    const headers = init.headers || {};
+    for (const k of Object.keys(headers)) {
+      const v = headers[k];
+      if (typeof v === "string" && v) args.push("-H", `${k}: ${v}`);
+    }
+    args.push(String(url));
+
+    // windowsHide：daemon（无控制台后台进程）下不加这项，Windows 会**每次 spawn 弹一个 curl 控制台窗口**
+    const child = spawn(curlPath, args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    child.stdin.on("error", () => {}); // EPIPE：curl 启动即败时写 body 不崩主流程
+    let stderr = "";
+    child.stderr.on("data", (c) => { stderr += c.toString(); });
+    if (body !== null) child.stdin.end(body);
+
+    // ① spawn 即流式：stdout 全部进队列（header 就绪前的 body 字节也在其中，不丢）
+    const chunks = [];
+    let eof = false;
+    let streamErr = null;
+    let waiters = [];
+    child.stdout.on("data", (c) => {
+      chunks.push(c);
+      if (waiters.length) waiters.shift()({ value: chunks.shift(), done: false });
+    });
+    child.stdout.on("error", (e) => { streamErr = e; eof = true; wakeAll(); });
+    child.stdout.on("end", () => { eof = true; wakeAll(); });
+    child.on("error", (e) => { streamErr = e; eof = true; wakeAll(); });
+    function wakeAll() { const ws = waiters; waiters = []; for (const w of ws) w({ value: undefined, done: true }); }
+    const kill = () => { try { child.kill(); } catch {} };
+
+    // ② 等响应头（-D 文件出现完整非-CONNECT 段；curl 退出/EOF 提前结束等待）
+    const deadline = Date.now() + headWaitMs;
+    let blob = "";
+    for (;;) {
+      blob = safeRead(headerFile);
+      if (headerBlobReady(blob)) break;
+      if (eof || streamErr) break; // 无头 EOF：下面按失败处理
+      if (Date.now() >= deadline) { kill(); break; }
+      await sleep(20);
+    }
+    const { status, headers: resHeaders } = parseHeaderBlob(blob);
+    if (!status) {
+      kill();
+      try { rmSync(dir, { recursive: true, force: true }); } catch {}
+      const err = new Error(`curl-fetch: 无响应头（${String(url)}）${streamErr ? ` err=${streamErr.message}` : ""}${stderr ? ` stderr=${stderr.slice(0, 160)}` : ""}`);
+      err._curlNoHeader = true;
+      throw err; // 交上层 network 重试/冷却（等价 fetch 的连接类抛错）
+    }
+
+    // ③ Response.body：先吐队列积压、再随 data 事件续吐；signal/cancel 杀进程
+    const cleanup = () => { try { rmSync(dir, { recursive: true, force: true }); } catch {} };
+    const stream = new ReadableStream({
+      async pull(controller) {
+        if (chunks.length) { controller.enqueue(new Uint8Array(chunks.shift())); return; }
+        if (streamErr) { cleanup(); controller.error(streamErr); return; }
+        if (eof) { cleanup(); controller.close(); return; }
+        const r = await new Promise((res) => waiters.push(res));
+        if (r.done) {
+          if (streamErr) { cleanup(); controller.error(streamErr); return; }
+          cleanup(); controller.close(); return;
+        }
+        controller.enqueue(new Uint8Array(r.value));
+      },
+      cancel() { kill(); cleanup(); },
+    });
+    const onAbort = () => kill();
+    if (init.signal) {
+      if (init.signal.aborted) kill();
+      else init.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    return new Response(stream, { status, statusText: "", headers: resHeaders });
+  };
+}

package/src/providers/dispatcher.js

@@ -1,8 +1,9 @@
  import { appendEvent } from "../logs.js";
  import { splitModelId, DEFAULT_PROVIDER, joinModelId } from "./model-id.js";
  import { isModelAllowed as stateIsAllowed, loadProviderAllowedModels as stateLoadAllowed, loadProviderAllowAnyModels as stateLoadAllowAny } from "../state.js";
-// 定制预热名单：registry customProviders 9 家 + 默认 opencode；openrouter/自配 generic 不预热（按需自拉）
-const CUSTOM_PREHEAT_IDS = new Set(["opencode", "workbuddy", "traework", "cline", "codearts", "qoder", "globalqwenwork", "qwenwork", "zcode", "raccoon", "agentrouter"]);
+// 定制预热名单：registry customProviders + 默认 opencode；openrouter/自配 generic 不预热（按需自拉）
+// agentrouter 已于 2026-10-21 随 registry 一并摘除（见 src/providers/registry.js 注释）。
+const CUSTOM_PREHEAT_IDS = new Set(["opencode", "workbuddy", "traework", "cline", "codearts", "qoder", "globalqwenwork", "qwenwork", "zcode", "raccoon"]);
  function isPreheatDisabled() {
    const raw = process.env.MSLXDFF_PREHEAT;
    if (raw === undefined || raw === null || raw === "") return false;

package/src/providers/registry.js

@@ -60,13 +60,9 @@ export const customProviders = [
     match: (id, baseUrl) => id === "raccoon" || String(baseUrl).includes("xiaohuanxiong.com"),
     load: () => import("./raccoon/index.js").then((m) => m.createRaccoonProvider),
   },
-  {
-    id: "agentrouter",
-    // 客户端身份白名单（UA 非 opencode/claude-cli 恒 401）+ gpt-6* 只吃 /v1/responses，
-    // generic 的写死 UA 与 models.dev 判定都覆盖不到，故走定制工厂。
-    match: (id, baseUrl) => id === "agentrouter" || String(baseUrl).includes("agentrouter"),
-    load: () => import("./agentrouter.js").then((m) => m.createAgentRouterProvider),
-  },
+  // agentrouter 定制工厂已于 2026-10-21 摘除：现网成功率仅 ~48%（502/400/422/500 高发），
+  // 从注册表 + 预热名单移除后网关不再解析 agentrouter/* 模型。工厂文件 src/providers/agentrouter.js
+  // 与其测试保留，日后要重新启用只需在此加回一条 { id:"agentrouter", ... } 并同步 dispatcher 预热名单。
 ];
 
 // 供 bench/probe 等需要定制化解析模型列表的场景

package/src/providers/workbuddy/auth.js

@@ -53,6 +53,18 @@ export function parseRateLimitResetMs(bodyText, clock = Date.now) {
   return ms > 0 ? ms : 0;
 }
 
+// 账号级风控封禁：腾讯 workbuddy `403 {"code":11140,"msg":"request illegal",displayMsg:"…restricted due to unusual activity/账号存在异常行为…"}`。
+// 与 auth 失败、额度耗尽、限流都不同：**刷新 token 无效**（2026-10-21 实测：refresh 成功换发新 token 后照样 11140，
+// 且换新 UA/完整客户端头集合同样 11140——判的是账号本体，不是凭据或请求指纹）。
+// 命中即应长冷却该号并如实把 403 透回，绝不进 refresh→重打 的连锁（旧链每个用户请求白烧 号数×2 次上游调用 + 号数 次 refresh）。
+export function isAccountRestricted(status, bodyText) {
+  if (status !== 403) return false;
+  const t = String(bodyText || "");
+  if (/"code"\s*:\s*11140\b/.test(t)) return true;
+  const lower = t.toLowerCase();
+  return lower.includes("request illegal") || lower.includes("restricted due to unusual activity") || t.includes("账号存在异常行为");
+}
+
 export function isAuthError(status, bodyText) {
   if (status === 401 || status === 403) return true;
   const t = String(bodyText || "").toLowerCase();
@@ -86,10 +98,14 @@ export function createAuthService({
     }
     const p = (async () => {
       const url = joinUrl(resolvedBase, "/v2/plugin/auth/token/refresh");
+      // 回退到 2026-10-21 17:09 实测**可用**的旧头形（refresh 成功换发过新 token）：refresh 无活体抓包，
+      // 不赌未验证口径；11140 只打 chat、refresh 不在风控画像主战场。X-Refresh-Token 是 refresh 特有凭据头。
+      // X-Auth-Refresh-Source: "plugin" 是 CLI bundle 三条 refreshSession 逐字共有的真值（@7064132/@7126898/@7144850），补上无副作用。
       const headers = {
         "Content-Type": "application/json",
         Authorization: `Bearer ${key}`,
         "X-Refresh-Token": rt,
+        "X-Auth-Refresh-Source": "plugin",
         "X-User-Id": uid,
         "X-Domain": auth.domain || "www.codebuddy.cn",
         "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",

package/src/providers/workbuddy/chat.js

@@ -1,5 +1,5 @@
-import { joinUrl } from "../base.js";
-import { isAuthError, isInsufficientStatus, isRateLimitedStatus, parseRateLimitResetMs } from "./auth.js";
+import { joinUrl, envInt } from "../base.js";
+import { isAuthError, isInsufficientStatus, isRateLimitedStatus, parseRateLimitResetMs, isAccountRestricted } from "./auth.js";
 import { appendRotationLog as defaultAppend } from "./rotation-log.js";
 import { createTransport } from "../../transport/index.js";
 import { dispatcherFetch } from "../../upstream-engine/sdk/attempt.js";
@@ -8,21 +8,12 @@ import { attemptOnceSdk } from "./sdk-chat.js";
 import { sanitizeToolSequence } from "./sanitize-tools.js";
 import { rewriteWorkbuddyPayload } from "./payload.js";
 import { resolveEngineMode } from "../../upstream-engine/mode.js";
+import { buildWorkbuddyHeaders } from "./client-headers.js";
 
+// 出站指纹单一真值：官方桌面端口径见 client-headers.js（含每请求随机 conversation/trace id）。
+// 真机 chat 的 Accept 是 application/json（SSE 由 body.stream 协商、非 Accept），故不传 accept 用默认值。
 function buildAuthHeaders(key, auth) {
-  const h = {
-    "Content-Type": "application/json",
-    Accept: "text/event-stream",
-    "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
-    Origin: "https://www.codebuddy.cn",
-    Referer: "https://www.codebuddy.cn/",
-    "X-Product": "SaaS",
-  };
-  if (key) h["Authorization"] = `Bearer ${key}`;
-  if (auth?.uid) h["X-User-Id"] = auth.uid;
-  h["X-Domain"] = auth?.domain || "www.codebuddy.cn";
-  if (auth?.enterpriseId) { h["X-Enterprise-Id"] = auth.enterpriseId; h["X-Tenant-Id"] = auth.enterpriseId; }
-  return h;
+  return buildWorkbuddyHeaders(key, auth);
 }
 
 function withUidHeader(res, uid) {
@@ -81,6 +72,12 @@ export function createChatService({
   clock = Date.now,
   cooldownMs = 30_000,
 } = {}) {
+  // 封号 11140 冷却时长（env MSLXDFF_WORKBUDDY_RESTRICTED_COOLDOWN_MS，缺省 15min）：
+  // 腾讯"异常行为"限制可长可短，30s 档太短会反复白烧；15min 内人工申诉/自动解封后再回来。
+  const restrictedCooldownMs = envInt("MSLXDFF_WORKBUDDY_RESTRICTED_COOLDOWN_MS", 900_000);
+  // 最近一次「账号封禁 11140」记账 { at, uids, message }——让冷却期内到达的请求如实回 403
+  // （旧表现：keyring 全冷却 → 笼统 "all API keys are in cooldown" 冒 502，用户/客户端看不出是封号）。
+  let lastRestricted = null;
   const getBalance = balanceCache?.getCachedBalance || (() => null);
   const setBalance = balanceCache?.setCachedBalance || (() => {});
   const doLog = (opts) => {
@@ -132,6 +129,11 @@ export function createChatService({
     if (res.status < 400) return reshapeWorkbuddySse(res);
     let txt = "";
     try { txt = await res.text(); } catch {}
+    // 账号封禁 11140：判账号本体，refresh 无效（2026-10-21 实测刷出新 token 照样 11140），
+    // 原样上抛让 runChat 走「长冷却 + 换号」，绝不进 refresh 连锁白烧上游。
+    if (isAccountRestricted(res.status, txt)) {
+      throw failErr(`workbuddy account restricted (11140) for ${auth?.uid || ""}: ${txt.slice(0, 160)}`, _t0(), clock, { restricted: true, status: res.status });
+    }
     if (!isAuthError(res.status, txt)) return rewrapBody(res, txt);
     const newKey = await authService?.refreshTokenFor?.(key, auth);
     if (!newKey) throw failErr(`workbuddy refresh failed for ${auth?.uid || ""}: ${txt.slice(0, 120)}`, _t0(), clock);
@@ -141,6 +143,10 @@ export function createChatService({
     catch (e2) { throw e2; }
     let stillTxt = "";
     if (res2.status >= 400) { try { stillTxt = await res2.text(); } catch {} }
+    // 刷新后仍被封：同属账号级限制，标记 restricted 供上层长冷却。
+    if (isAccountRestricted(res2.status, stillTxt)) {
+      throw failErr(`workbuddy account restricted (11140) for ${auth?.uid || ""}: ${stillTxt.slice(0, 160)}`, _t0(), clock, { restricted: true, status: res2.status });
+    }
     if (stillTxt) res2 = rewrapBody(res2, stillTxt);
     const stillAuth = isAuthError(res2.status, stillTxt);
     const uid2 = auth2.uid || auth.uid;
@@ -186,6 +192,12 @@ export function createChatService({
         return res;
       } catch (e) {
         e._t = e._t || { attempts: [], waitMs: 0, totalMs: Math.round(nowMs(clock) - t0) };
+        // pin 模式撞封号：长冷却 + 把 403 原文透回（refresh 无效，别冒 502 让客户端以为网关坏了）。
+        if (e?._t?.restricted || e?.restricted) {
+          try { activeRing.onError(key, restrictedCooldownMs); } catch {}
+          doLog({ uid: auth.uid, model: _modelVal, totalMs: Math.round(nowMs(clock) - t0), balanceHit: false, error: String(e.message).slice(0, 160) });
+          return errRes(403, String(e.message), "account-restricted", auth.uid, t0, clock);
+        }
         if (!(e instanceof Error) || !String(e.message).includes("refresh failed")) try { activeRing.onError(key); } catch {}
         throw e;
       }
@@ -197,7 +209,13 @@ export function createChatService({
     for (let triedCount = 0; triedCount < maxTries; triedCount++) {
       const key = activeRing.next();
       if (!key) {
-        if (triedCount === 0) throw failErr(`${id}: all API keys are in cooldown (last error < ${cooldownMs}ms ago) — provider temporarily unavailable`, t0, clock, { cooldownMs });
+        if (triedCount === 0) {
+          // 封号冷却窗口内的重复请求：如实回 403（账号问题），别抛笼统 cooldown 冒成 502。
+          if (lastRestricted && clock() - lastRestricted.at < restrictedCooldownMs) {
+            return errRes(403, `workbuddy: all account(s) restricted (11140): ${String(lastRestricted.message).slice(0, 160)}`, "account-restricted", "", t0, clock);
+          }
+          throw failErr(`${id}: all API keys are in cooldown (last error < ${cooldownMs}ms ago) — provider temporarily unavailable`, t0, clock, { cooldownMs });
+        }
         break;
       }
       const auth = authForKey(key);
@@ -218,7 +236,12 @@ export function createChatService({
       try { res = await withRefresh(url, body, key, auth); }
       catch (e) {
         e._t = e._t || { attempts: [], waitMs: 0, totalMs: Math.round(nowMs(clock) - t0) };
-        try { activeRing.onError(key); } catch {}
+        // 封号 11140：长冷却本号换下一个；冷却档走 restrictedCooldownMs（缺省 15min），别用 30s 短档反复白烧。
+        // restricted 标记挂在 failErr 的 _t 上；SDK 通道对 4xx 抛的 AI_APICallError 带 statusCode/responseBody，一并识别。
+        if (e?._t?.restricted || e?.restricted || isAccountRestricted(e?.statusCode, e?.responseBody)) {
+          lastRestricted = { at: clock(), uid, message: String(e.responseBody || e.message || "").slice(0, 200) };
+          try { activeRing.onError(key, restrictedCooldownMs); } catch {}
+        } else try { activeRing.onError(key); } catch {}
         lastErr = e;
         continue;
       }
@@ -256,7 +279,18 @@ export function createChatService({
       doLog({ uid, model: _modelVal, totalMs: Math.round(nowMs(clock) - t0), balanceHit: false });
       return res;
     }
-    if (lastErr) throw lastErr;
+    if (lastErr) {
+      // 全号皆被封 11140：上游报文带可申诉的 displayMsg/displayTips，透回原文比模糊包装更利于用户自查；
+      // 状态码用上游的 403（旧链是 502，客户端侧像网关坏了，实为账号问题）。
+      if (lastErr._t?.restricted || lastErr.restricted) {
+        lastRestricted = { at: clock(), uid: "", message: String(lastErr.message || "") };
+        const uids = [...tried].filter((x) => x && x.includes("-")).join(",");
+        const reason = `workbuddy all account(s) restricted (11140): ${uids || "n/a"} — ${String(lastErr.message).slice(0, 200)}`;
+        const r = errRes(403, reason, "account-restricted", uids, t0, clock);
+        return r;
+      }
+      throw lastErr;
+    }
     throw failErr(`${id}: all workbuddy accounts exhausted or unavailable`, t0, clock);
   }
 

package/src/providers/workbuddy/client-headers.js

@@ -0,0 +1,148 @@
+// WorkBuddy 出站请求头——照抄本机官方桌面端 5.8.3 的组装真值（buildVlmGatewayHeaders +
+// applyGatewayHeaders + applyTraceHeaders 三函数，逆向自 app.asar @89622109，见 .scratch/wb-chat-headers.txt）。
+// 为什么要它：2026-10-21 三号集体撞 `403 11140 账号存在异常行为` 封号，且换 UA 到官方完整口径也照样 11140
+//   ——判的是账号本体，但旧出站指纹是**自造杂交串**：UA `CLI/2.115.0 WorkBuddy/2.115.0`（真机是
+//   `WorkBuddy/5.8.3 WorkBuddy/5.8.3`）、缺 X-IDE-*/X-Private-Data/x-codebuddy-request/X-Conversation-*/
+//   traceparent 全链追踪头、还多带真机 chat 明确排除的 Origin/Referer。裸指纹 + 桌面登录号 = 风控画像。
+//   对齐口径降低「登新号又被带进沟」的概率。⚠ 对齐是降风险非保命，封号是账号级、refresh 已证实无效。
+// 版本随客户端自动更新会漂移：MSLXDFF_WORKBUDDY_APP_VERSION 覆盖（缺省 5.8.3）；
+//   MSLXDFF_WORKBUDDY_CLI_VERSION 非空才追加 ` CLI/<v>` 段（真机 buildVlmGatewayHeaders 的 i 参数可为空）。
+// 一键回退旧口径：MSLXDFF_WORKBUDDY_LEGACY_HEADERS=1。
+import { randomBytes } from "node:crypto";
+
+const APP_VERSION = () => (process.env.MSLXDFF_WORKBUDDY_APP_VERSION || "5.8.3").trim();
+// CLI 段版本取自本机活体日志（a06ef5f8 实时 chat 请求 UA `WorkBuddy/5.8.3 WorkBuddy/5.8.3 CLI/2.161.0`）。
+const CLI_VERSION = () => {
+  const v = (process.env.MSLXDFF_WORKBUDDY_CLI_VERSION ?? "").trim();
+  return v === "" ? "2.161.0" : v; // 缺省跟本机真值；显式空串仍可关掉该段
+};
+const isLegacy = () => process.env.MSLXDFF_WORKBUDDY_LEGACY_HEADERS === "1";
+
+function hex(n) { return randomBytes(n).toString("hex"); }
+
+// 真机 X-Request-ID 家族是 UUIDv7（毫秒时间戳打头 48bit + 版本位 7 + 变体位 10xx），
+// 活体日志证实：`01a15dcaf9a97a86a215ac50f6bcdfff` 第 13 位恒为 '7'。裸 hex 版本位 15/16 概率错、
+// 时间戳前缀是乱码——风控一眼假。按 https://www.rfc-editor.org/rfc/rfc9562 组真 v7。
+function uuidv7hex() {
+  const b = Buffer.from(randomBytes(16));
+  const ts = Date.now();
+  b[0] = Math.floor(ts / 2 ** 40) & 0xff;
+  b[1] = Math.floor(ts / 2 ** 32) & 0xff;
+  b[2] = Math.floor(ts / 2 ** 24) & 0xff;
+  b[3] = Math.floor(ts / 2 ** 16) & 0xff;
+  b[4] = Math.floor(ts / 2 ** 8) & 0xff;
+  b[5] = ts & 0xff;
+  b[6] = (b[6] & 0x0f) | 0x70; // version 7
+  b[8] = (b[8] & 0x3f) | 0x80; // variant 10xx
+  return b.toString("hex");
+}
+// 真机 X-Conversation-ID 家族是 UUIDv4（带横线，版本位 4 / 变体位 8~b），活体：`b84c6a36-bd21-461a-b9be-…`。
+function uuidv4dashed() {
+  const b = Buffer.from(randomBytes(16));
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  const h = b.toString("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+
+// 真机 CLI trace 头（bundle @4733511 trace_start_hook，**不是** Electron 代理链的 applyTraceHeaders）：
+// 只设 X-Trace-ID/X-B3-TraceId(=同 traceId 32hex)/X-B3-SpanId(16hex)/X-B3-Sampled=1/b3(<trace32>-<span16>-1 三段)。
+// 无 traceparent、无 X-B3-ParentSpanId——那两个是 Electron web 转发链的形状，chat 实发者是 CLI 子进程，别抄错链路。
+function traceHeaders() {
+  const n = hex(16), r = hex(8);
+  return {
+    "X-Trace-ID": n,
+    "X-B3-TraceId": n,
+    "X-B3-SpanId": r,
+    "X-B3-Sampled": "1",
+    b3: `${n}-${r}-1`,
+  };
+}
+
+// 网关态：每次调用是一条新逻辑会话。id 形状取自活体日志（2026-10-21 a06ef5f8 正常发 200 的 CLI 请求）：
+// 会话 id = **UUIDv4 带横线**（`b84c6a36-bd21-461a-b9be-…`）；请求 id = **UUIDv7 去横线**（第 13 位恒 '7'）。
+// bundle 逐字（@5997642 buildConversationHeaders）：X-Conversation-ID=会话 id；X-Request-ID=X-Conversation-Message-ID
+// =同一 uuidv7 双写；X-Conversation-Request-ID=**另一个** uuidv7（turn 级生成器）。网关一调用=新会话=新 turn，
+// 两值各生成一份即可（真机一 turn 多请求时才复用 Conversation-Request-ID）。
+// ⚠ X-Root-Request-ID / X-Parent-Conversation-ID 真机是**条件头**（meta 有值才设——sub-agent/续聊轮才带）。
+//   网关永远首请求，带上=把每条请求伪造成续聊，画像反常 → 不带。X-Session-ID 保留（活体 config/日志有同值头）。
+function conversationHeaders() {
+  const conv = uuidv4dashed();
+  const req = uuidv7hex();
+  const turn = uuidv7hex();
+  return {
+    "X-Conversation-ID": conv,
+    "X-Session-ID": conv,
+    "X-Request-ID": req,
+    "X-Conversation-Request-ID": turn,
+    "X-Conversation-Message-ID": req,
+    "X-Agent-Type": "main",
+    "acp-connection-id": req,
+  };
+}
+
+function legacyHeaders(key, auth, accept) {
+  const h = {
+    "Content-Type": "application/json",
+    Accept: accept,
+    "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
+    Origin: "https://www.codebuddy.cn",
+    Referer: "https://www.codebuddy.cn/",
+    "X-Product": "SaaS",
+  };
+  if (key) h["Authorization"] = `Bearer ${key}`;
+  if (auth?.uid) h["X-User-Id"] = auth.uid;
+  h["X-Domain"] = auth?.domain || "www.codebuddy.cn";
+  if (auth?.enterpriseId) { h["X-Enterprise-Id"] = auth.enterpriseId; h["X-Tenant-Id"] = auth.enterpriseId; }
+  return h;
+}
+
+// 官方桌面端完整口径。三处出口（chat / refresh / config）共用，保证**一个号一张脸**：
+//   chat 带每请求 conversation/trace id；refresh、config 无会话 → withConversation:false。
+//   真机 buildVlmGatewayHeaders 的 Accept 是 application/json（SSE 靠 body.stream 协商），故 accept 默认即此。
+export function buildWorkbuddyHeaders(key, auth, { accept = "application/json", withConversation = true } = {}) {
+  if (isLegacy()) return legacyHeaders(key, auth, accept);
+  const app = APP_VERSION(), cli = CLI_VERSION();
+  const ua = [`WorkBuddy/${app}`, `WorkBuddy/${app}`, ...(cli ? [`CLI/${cli}`] : [])].join(" ");
+  const h = {
+    "Content-Type": "application/json",
+    Accept: accept,
+    "Accept-Encoding": "identity",
+    "User-Agent": ua,
+    "X-IDE-Type": "WorkBuddy",
+    "X-IDE-Name": "WorkBuddy",
+    "X-IDE-Version": app,
+    "X-Private-Data": process.env.MSLXDFF_WORKBUDDY_PRIVATE_DATA || "false",
+    "X-Product": "SaaS",
+    "x-requested-with": "XMLHttpRequest",
+    "x-codebuddy-request": "1",
+    "X-Agent-Intent": "craft",
+    "X-Agent-Purpose": "conversation",
+    ...(withConversation ? conversationHeaders() : {}),
+    ...(withConversation ? traceHeaders() : {}),
+  };
+  if (key) h["Authorization"] = `Bearer ${key}`;
+  if (auth?.uid) h["X-User-Id"] = auth.uid;
+  h["X-Domain"] = auth?.domain || "www.codebuddy.cn";
+  if (auth?.enterpriseId) { h["X-Enterprise-Id"] = auth.enterpriseId; h["X-Tenant-Id"] = auth.enterpriseId; }
+  return h;
+}
+
+// GET /v3/config 专用：活体真值＝本机 CLI 子进程（好号 a06ef5f8 正常工作中）2026-10-21 17:29 实发的 6 头集
+//（客户端日志逐字：authorization/user-agent(WorkBuddy/5.8.3 WorkBuddy/5.8.3 CLI/2.161.0)/x-domain/x-product/x-request-id/x-user-id）。
+// ⚠ config 的 x-request-id=`b1f4cb939a57486d86d16b74bec13511` 第13位='4'、第17位='8' → 是**去横线 UUIDv4**，
+//   与 chat 的 UUIDv7 生成器不同（两条链路各自的 id 策略）。**无 Content-Type（GET）、无 X-IDE-*、无 trace、无 Origin/Referer**——
+//   别拿 chat 全量头套它（2026-10-21 曾 over-align，按活体回退）。
+export function buildWorkbuddyConfigHeaders(key, auth) {
+  const app = APP_VERSION(), cli = CLI_VERSION();
+  const ua = [`WorkBuddy/${app}`, `WorkBuddy/${app}`, ...(cli ? [`CLI/${cli}`] : [])].join(" ");
+  const h = {
+    "User-Agent": ua,
+    "X-Domain": auth?.domain || "www.codebuddy.cn",
+    "X-Product": "SaaS",
+    "X-Request-ID": uuidv4dashed().replace(/-/g, ""),
+  };
+  if (key) h["Authorization"] = `Bearer ${key}`;
+  if (auth?.uid) h["X-User-Id"] = auth.uid;
+  return h;
+}

package/src/providers/workbuddy/desktop-info.js

@@ -73,6 +73,22 @@ export function readDesktopAccount(fp) {
     accessToken: j.auth.accessToken,
     refreshToken: j.auth.refreshToken || "",
     expiresAt: exp,
-    domain: j.auth.domain || "www.codebuddy.cn",
+    // domain 以 token 的 iss realm 为准（比 auth.domain 更贴近 cop 网关鉴权域）；auth.domain 兜底。
+    // 注：从桌面 info 导入不等于能对话——2026-10-21 一台桌面态 token 对网关直连仍 401（疑似内嵌 CLI 与
+    // 桌面 Electron 双鉴权）；入池正解是设备授权流 `-provider workbuddy login`，本函数只负责解析登录态字段。
+    domain: issDomain(j.auth.accessToken) || j.auth.domain || "www.codebuddy.cn",
   };
 }
+
+// 从 JWT payload.iss（如 https://www.codebuddy.cn/auth/realms/copilot）提取主机名；解析失败返回 ""。
+export function issDomain(token) {
+  try {
+    const payload = String(token || "").split(".")[1];
+    if (!payload) return "";
+    let b = payload.replace(/-/g, "+").replace(/_/g, "/");
+    while (b.length % 4) b += "=";
+    const iss = JSON.parse(Buffer.from(b, "base64").toString("utf8"))?.iss;
+    if (typeof iss !== "string") return "";
+    return new URL(iss).host || "";
+  } catch { return ""; }
+}

package/src/providers/workbuddy/models.js

@@ -1,5 +1,7 @@
 import { joinModelId } from "../model-id.js";
 import { joinUrl } from "../base.js";
+import { isAccountRestricted } from "./auth.js";
+import { buildWorkbuddyConfigHeaders } from "./client-headers.js";
 
 function creditsValue(c) {
   if (!c || !String(c).trim()) return 0;
@@ -28,16 +30,8 @@ export function createModelsService({
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error(`${id} models timed out`)), 15_000);
     try {
-      const headers = {
-        Accept: "application/json",
-        "X-User-Id": useAuth?.uid || "",
-        "X-Domain": useAuth?.domain || "www.codebuddy.cn",
-        "X-Product": "SaaS",
-        "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
-        Origin: "https://www.codebuddy.cn",
-        Referer: "https://www.codebuddy.cn/",
-      };
-      if (useKey) headers["Authorization"] = `Bearer ${useKey}`;
+      // config 端点按活体真值只发 6 头（GET 简头通道，勿套 chat 全量头——2026-10-21 实测回退）。
+      const headers = buildWorkbuddyConfigHeaders(useKey, useAuth);
       const opts = { headers, signal: controller.signal };
       if (dispatcher) opts.dispatcher = dispatcher;
       return await fetchImpl(`${joinUrl(baseUrl, modelsPath)}`, opts);
@@ -65,6 +59,8 @@ export function createModelsService({
         if (!r.ok) {
           let t = "";
           try { t = await r.clone().text(); } catch {}
+          // 封号 11140：refresh 无效（判账号本体），跳过刷新直接换下一个 key，别白烧 refresh 端点。
+          if (isAccountRestricted(r.status, t)) continue;
           if (isAuthError?.(r.status, t)) {
             const newKey = await refreshTokenFor?.(key, auth);
             if (newKey && !tried.has(newKey)) {
@@ -98,16 +94,8 @@ export function createModelsService({
     try {
       const key = getKey ? getKey() : "";
       const auth = getAuth ? getAuth(key) : null;
-      const headers = {
-        Accept: "application/json",
-        "X-User-Id": auth?.uid || "",
-        "X-Domain": auth?.domain || "www.codebuddy.cn",
-        "X-Product": "SaaS",
-        "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
-        Origin: "https://www.codebuddy.cn",
-        Referer: "https://www.codebuddy.cn/",
-      };
-      if (key) headers["Authorization"] = `Bearer ${key}`;
+      // 与 listModels 同一口径：config 简头集（活体真值）。
+      const headers = buildWorkbuddyConfigHeaders(key, auth);
       const opts = { headers };
       if (dispatcher) opts.dispatcher = dispatcher;
       const res = await fetchImpl(joinUrl(baseUrl, modelsPath), opts);