mslxdff 0.1.232 → 0.1.234

package/src/providers/raccoon/index.js

@@ -3,9 +3,10 @@
 import { compatFetch } from "../../compat.js";
 import { envInt } from "../base.js";
 import { createKeyRing } from "../keyring.js";
+import { createStickyPicker } from "./sticky.js";
 import { loadProviderKeys } from "../../state.js";
 import { forwardRaccoonChat } from "./chat.js";
-import { buildRaccoonModelList, listRaccoonModels } from "./models.js";
+import { buildRaccoonModelList, listRaccoonModels, mergeRaccoonCatalogIntoAllowlist } from "./models.js";
 import { applyRaccoonRefresh, listRaccoonAccountDocs, raccoonCredentialFromDoc, readRaccoonAccountDoc, syncRaccoonKeys, writeRaccoonAccountFile } from "./account-store.js";
 import { refreshRaccoonCredential } from "./login.js";
 import { isRaccoonExpiringSoon, raccoonTokenFingerprint } from "./auth.js";
@@ -14,6 +15,14 @@ import { RACCOON_DEFAULT_COOLDOWN_MS, RACCOON_DEFAULT_QUOTA_COOLDOWN_MS } from "
 /** kind → 冷却档位。auth 走短冷（重登指引已由响应体给出）；quota 走长冷（按天回血）。 */
 const COOLDOWN_BY_KIND = { auth: "short", rate_limit: "short", server: "short", quota: "long" };
 
+/** 会话粘号 TTL：允 0（=关，退回每次调用轮转），故不能用只收正数的 envInt。 */
+function stickyMsFromEnv(env = process.env) {
+  const raw = env?.MSLXDFF_RACCOON_STICKY_MS;
+  if (raw === undefined || String(raw).trim() === "") return 1_800_000;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : 1_800_000;
+}
+
 function notLoggedInResponse() {
   return new Response(
     JSON.stringify({ error: { message: "raccoon: 无可用账号 —— 先运行 mslxdff -provider raccoon login", type: "auth_error" } }),
@@ -63,6 +72,17 @@ export function createRaccoonProvider({
   }
   const ring = createKeyRing(keys, { cooldownMs });
 
+  // 会话粘号：同一段对话（opts.sessionId）固定用同一个号，换会话才轮转到下一个号。
+  // 为什么不是每次调用轮转：积分按号均摊靠「会话之间」轮换就够了，而同一会话逐轮换号会丢掉上游
+  // 的 prompt 缓存亲和，也让排障时分不清「这个号到底好不好」。无会话标识时退回 reqId（同请求重试不换号）
+  // 与纯轮转，行为与旧版一致。TTL 内每次命中续期；`MSLXDFF_RACCOON_STICKY_MS=0` 关掉退回逐调用轮转。
+  const pickKey = createStickyPicker({
+    pick: () => ring.next(),
+    // 被 replace() 换掉的旧 token 已不在 ring 里 → 同样视为不可用，会话会前进到新号而不是粘住废 token
+    isCooling: (k) => !ring.keys.includes(k) || ring.isCooling(k),
+    ttlMs: stickyMsFromEnv(),
+  });
+
   // access_token → 账号文档（office_identity / device_id / refresh_token 跟号走，取自 auths/raccoon-<uid>.json）
   // 缓存**可失效**：重登与续期都会换盘上的 token，只建一次会让本进程永远停在旧号（见 healKeyFromDocs）
   let docCache = null;
@@ -103,7 +123,7 @@ export function createRaccoonProvider({
   const inflightRefresh = new Map();
 
   /** 临期即续期；续期成功把新 token 回写账号文档并替换 keyring 里的旧键。失败不阻断（让上游如实报）。 */
-  async function ensureFresh(token) {
+  async function ensureFresh(token, scope) {
     const credential = credentialFor(token);
     if (!credential.refresh_token || !isRaccoonExpiringSoon(credential)) return credential;
     const pending = inflightRefresh.get(token);
@@ -114,6 +134,8 @@ export function createRaccoonProvider({
         if (next.access_token !== token) {
           ring.replace(token, next.access_token);
           docCache?.delete(token);
+          // 粘号表跟着换 token：否则该会话下一轮会认为旧 token 不可用而漂到别的号（同一账号被拆成两半）
+          pickKey.remember(scope, next.access_token);
         }
         // ⚠ 同 token 也必须刷新到期时间：否则 docCache 永远停在旧 expires_at，每个请求都会重复调一次 refresh
         docCache?.set(next.access_token, { ...credential, accessToken: next.access_token, refreshToken: next.refresh_token, expiresAt: next.expires_at || "" });
@@ -153,12 +175,18 @@ export function createRaccoonProvider({
   async function chat(body, opts = {}) {
     const total = ring.keys.length;
     if (!total) return notLoggedInResponse();
+    // 会话优先：一段对话固定一个号（积分按会话轮换均摊）；没有会话标识时才退到「同请求粘号」
+    const scope = opts?.sessionId ? `sess:${opts.sessionId}` : opts?.reqId ? `req:${opts.reqId}` : null;
     let lastRes = null;
     let healed = false; // 一次请求内只自愈一次：防重试风暴，也防「文档里那份同样不可用」时打旋
     for (let hop = 0; hop <= total + 1; hop++) {
-      const key = ring.next();
+      let pick = "rr";
+      const key = pickKey(scope, (d) => { pick = d; });
       if (!key) break;
-      const credential = await ensureFresh(key);
+      if (pick !== "sticky" && pick !== "rr") {
+        console.error(`[raccoon] 会话选号 pick=${pick} account=${raccoonTokenFingerprint(key)} ${scope || ""}`);
+      }
+      const credential = await ensureFresh(key, scope);
       const res = await forwardRaccoonChat({ body, credential, fetchImpl, timeoutMs, effort: opts?.effort ?? effort });
       const kind = res.headers.get("x-mslxdff-raccoon-kind");
       if (!kind) return res; // 成功或未分类：直接交出去
@@ -166,7 +194,11 @@ export function createRaccoonProvider({
       if (kind === "auth" && !healed) {
         healed = true;
         // 自愈成功就换号重试；不给失效号记冷却（ring.replace 也不把冷却带给新号）
-        if (await healKeyFromDocs(key)) continue;
+        const healedKey = await healKeyFromDocs(key);
+        if (healedKey) {
+          pickKey.remember(scope, healedKey); // 本会话钉到救回来的号，别在下一轮又漂走
+          continue;
+        }
       }
       const mode = COOLDOWN_BY_KIND[kind] || "none";
       if (mode === "long") ring.onError(key, quotaCooldownMs);
@@ -178,12 +210,25 @@ export function createRaccoonProvider({
     return allCoolingResponse();
   }
 
+  let catalogMergeTried = false;
   async function listModels() {
     let token = ring.keys[0];
     // 内存号已不在文档里（重登换号）时先对齐，否则目录撞 401 后静默回落内置表，表现为「列表不是最新的」
     if (token && !accountFor(token)) token = (await healKeyFromDocs(token)) || token;
     if (!token) return [];
-    const { models } = await listRaccoonModels({ credential: credentialFor(token), fetchImpl });
+    const { models, source } = await listRaccoonModels({ credential: credentialFor(token), fetchImpl });
+    // 上游目录是这家唯一真相（模型 id 全由上游定义、按账号下发）：每进程首次成功拉到就只增不减
+    // 并入 allowlist，否则 dispatcher 会拿登录时播种的静态白名单把新上架模型（如 …-1017）挡掉。
+    // 只在 source=upstream 时做：回落兜底表时并入的仍是静态 id，没有意义还会白写盘。
+    if (source === "upstream" && !catalogMergeTried) {
+      catalogMergeTried = true;
+      try {
+        const { added } = mergeRaccoonCatalogIntoAllowlist(models, file ? { file } : {});
+        if (added.length) console.error(`[raccoon] 上游目录新模型并入白名单: ${added.join(", ")}`);
+      } catch (e) {
+        console.error(`[raccoon] 目录并入白名单失败（列表照常返回）: ${String(e?.message || e).slice(0, 160)}`);
+      }
+    }
     return buildRaccoonModelList({ id, models });
   }
 

package/src/providers/raccoon/models.js

@@ -41,38 +41,54 @@ export function raccoonFallbackModels() {
   return RACCOON_FALLBACK_MODELS.map((m) => ({ ...m }));
 }
 
-/** 单条目录条目：字段名容错（缺字段即省略，不猜、不填假值）。 */
+/**
+ * 单条目录条目：字段名容错（缺字段即省略，不猜、不填假值）。
+ *
+ * 上游真实字段（2026-10-22 `GET /api/web/llm/v2/model_catalog` 实测）：
+ *   `name`=模型 id（请求体 `model` 用的就是它）、`description`=展示名（如 `DeepSeek-V4.1-Flash`）、
+ *   `visible: false`=上游对自己隐藏的内部模型、`params.context_window` / `params.max_tokens`、
+ *   `billing_multiplier` / `billing_effective_multiplier`。
+ * ⚠ **id 绝不能取 `description`**：旧`pickString(["modelName","name","displayName","description"])`
+ * 把 id 与展示名混在一串里，一旦上游条目的 `name` 缺失就会拿展示名当 id 去发请求（必 404/400）。
+ */
 function parseRaccoonModelEntry(raw) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  // 上游用 visible:false 表示「我这边不展示」，这类内部模型不进目录
+  if (raw.visible === false) return null;
   const id = pickString(raw, ["id", "modelId", "model_id", "modelName", "name"]);
   if (!id) return null;
   const model = { id };
-  const name = pickString(raw, ["modelName", "name", "displayName", "description"]);
-  if (name) model.name = name;
-  const ctx = pickNumber(raw, ["contextWindow", "context_window", "contextLength", "context_length"]);
+  // 展示名单独取，且排除与 id 同值的情况（否则列表会出现「xxx · xxx」）
+  const name = pickString(raw, ["description", "displayName", "modelName", "name"]);
+  if (name && name !== id) model.name = name;
+  const params = raw.params && typeof raw.params === "object" ? raw.params : {};
+  const ctx = pickNumber(raw, ["contextWindow", "context_window", "contextLength", "context_length"]) ?? pickNumber(params, ["context_window", "contextWindow"]);
   if (ctx !== undefined && ctx > 0) model.contextWindow = ctx;
-  const maxTokens = pickNumber(raw, ["maxTokens", "max_tokens", "maxCompletionTokens"]);
+  const maxTokens = pickNumber(raw, ["maxTokens", "max_tokens", "maxCompletionTokens"]) ?? pickNumber(params, ["max_tokens", "maxTokens"]);
   if (maxTokens !== undefined && maxTokens > 0) model.maxTokens = maxTokens;
   const img = pickBool(raw, ["supportsImage", "supports_image", "supportsVision"]);
   if (img !== undefined) model.supportsImage = img;
-  const eff = pickNumber(raw, ["effectiveMultiplier", "effective_multiplier", "multiplier", "costMultiplier"]);
+  const eff = pickNumber(raw, ["effectiveMultiplier", "effective_multiplier", "billing_effective_multiplier", "multiplier", "costMultiplier"]);
   if (eff !== undefined && eff >= 0) model.multiplier = eff;
-  const base = pickNumber(raw, ["baseMultiplier", "base_multiplier"]);
+  const base = pickNumber(raw, ["baseMultiplier", "base_multiplier", "billing_multiplier"]);
   if (base !== undefined && base > 0) model.baseMultiplier = base;
   return model;
 }
 
-/** 目录信封 → 条目数组。兼容 `data` 为数组、`data.models`、`data.list`、`data.items` 四种形状。 */
+/**
+ * 目录信封 → 条目数组。
+ *
+ * ⚠ **主形状是 `data.categories[]`，只有 `type: "chat"` 那组才是可路由模型**（2026-10-22 上游实测）。
+ * 旧实现只认 `data` 为数组 / `data.models` / `data.list` / `data.items` 四种，而真实报文是
+ * `{data:{categories:[...]}}` —— 结果每次都解析出 0 条、静默回落静态兜底表，症状是
+ * 「上游新上架的模型（如 `sn-deepseek-v4-1-flash-1017`）在网关里永远看不见」。
+ * 另外两条判据同样来自实测：`name` 才是模型 id（`description` 是展示名）、`visible: false`
+ * 是上游对自己隐藏的内部模型（`raccoon-*`），不该进目录。
+ *
+ * 四种旧形状继续兼容（上游改版/其他信封时兜底），按顺序取第一个非空的。
+ */
 export function parseRaccoonCatalog(data) {
-  const list = Array.isArray(data)
-    ? data
-    : Array.isArray(data?.models)
-      ? data.models
-      : Array.isArray(data?.list)
-        ? data.list
-        : Array.isArray(data?.items)
-          ? data.items
-          : [];
+  const list = pickCatalogList(data);
   const out = [];
   const seen = new Set();
   for (const raw of list) {
@@ -84,6 +100,19 @@ export function parseRaccoonCatalog(data) {
   return out;
 }
 
+function pickCatalogList(data) {
+  const arr = (v) => (Array.isArray(v) ? v : null);
+  // 真实形状：{ data: { categories: [{ type: "chat", models: [...] }] } }
+  const root = data && typeof data === "object" && !Array.isArray(data) ? data : null;
+  const categories = arr(root?.categories) ?? arr(root?.data?.categories);
+  if (categories) {
+    const chat = categories.find((c) => c && typeof c === "object" && c.type === "chat");
+    const chatModels = arr(chat?.models);
+    if (chatModels) return chatModels;
+  }
+  return arr(data) ?? arr(root?.models) ?? arr(root?.list) ?? arr(root?.items) ?? [];
+}
+
 /** 倍率文案：0 → 免费；促销 → `x基→x实`；其余 → `x实`（含 x1）。 */
 export function raccoonMultiplierLabel(model) {
   const eff = typeof model?.multiplier === "number" ? model.multiplier : undefined;
@@ -143,6 +172,28 @@ export function seedRaccoonAllowlist({ ids, file } = {}) {
   return { allowed: [...cur, ...added], added };
 }
 
+/**
+ * 把**上游目录**的模型 id 只增不减并入 allowlist。
+ *
+ * 为什么需要：白名单此前只在登录时按**静态兜底表**播种一次，上游后来上架的模型
+ * （如 2026-10 的 `sn-deepseek-v4-1-flash-1017`）就永远进不来 —— dispatcher 拿白名单
+ * 过滤 `listModels()`，模型看得见列表却选不到、调用直接被挡。上游目录才是这家唯一真相
+ * （积分制，模型 id 全由上游定义），故每次成功拉到目录就同步一次。
+ *
+ * **为什么只增不减**：目录是**按账号**下发的（套餐不同可见模型数不同），某次拉到一份
+ * 较短的目录不代表模型下架；双向收敛会在换号/降级套餐时把白名单越缩越小、把能用的模型删掉。
+ * 真要下架的模型留着只会 404，代价远小于误删。对齐 cline 的 `planMerge` 保守口径（ADR-0067）。
+ */
+export function mergeRaccoonCatalogIntoAllowlist(models, { file } = {}) {
+  const ids = (Array.isArray(models) ? models : []).map((m) => String(m?.id || "").trim()).filter(Boolean);
+  if (!ids.length) return { added: [] };
+  const opts = file ? { file } : {};
+  const cur = loadProviderAllowedModels("raccoon", opts);
+  const added = ids.filter((m) => !cur.includes(m));
+  if (added.length) saveProviderAllowedModels("raccoon", [...cur, ...added], opts);
+  return { added };
+}
+
 /** 对外目录条目（`/v1/models` 与 CLI models 共用形状）。 */
 export function buildRaccoonModelList({ id = "raccoon", models } = {}) {
   const list = models || raccoonFallbackModels();

package/src/providers/raccoon/sticky.js

@@ -0,0 +1,46 @@
+// raccoon 会话粘号：一段对话（sessionId）固定用一个号，换会话才轮转下一个号 —— 积分按会话均摊。
+// 语义与 qoder 的同请求粘号一致（只有该号进冷却 401/403/429/5xx 才换），差别在多两个能力：
+//   · scope 由会话（opts.sessionId）优先，没有会话标识时退到 reqId，两者都无则退回纯 round-robin；
+//   · remember()：续期换 token / 换号自愈后把本会话重新钉到那个号，避免同一账号被拆成两半。
+// 本文件是独立实现（qoder 只用同请求粘号且无需 remember），不改 qoder 的粘号逻辑。
+export function createStickyPicker({ pick, isCooling = () => false, now = Date.now, ttlMs = 600_000, maxEntries = 200 } = {}) {
+  const seen = new Map(); // scope → { key, at }
+
+  function evict() {
+    const t = now();
+    for (const [scope, hit] of seen) if (t - hit.at >= ttlMs) seen.delete(scope);
+    while (seen.size > maxEntries) seen.delete(seen.keys().next().value);
+  }
+
+  // onDecision（可选）：把"这次为什么选它"回报给调用方 —— 决定必须可观测。
+  // sticky=同会话复用 / new=新会话轮转选中 / switch=上次的号在冷却(或 TTL 过期)故换 / rr=无 scope 退回轮转
+  function pickSticky(scope, onDecision) {
+    if (!scope) {
+      onDecision?.("rr");
+      return pick();
+    }
+    const hit = seen.get(scope);
+    // 粘住：同一会话内复用上次的号，除非它已被冷却（那时必须换）
+    if (hit && now() - hit.at < ttlMs && !isCooling(hit.key)) {
+      hit.at = now();
+      onDecision?.("sticky");
+      return hit.key;
+    }
+    const key = pick();
+    onDecision?.(hit ? "switch" : "new");
+    if (key) {
+      seen.set(scope, { key, at: now() });
+      if (seen.size > maxEntries) evict();
+    }
+    return key;
+  }
+  // forget：丢弃 scope 的粘号记录（令牌刷新换了 key 后必须丢弃，否则同会话还粘旧 key）
+  pickSticky.forget = (scope) => { seen.delete(scope); };
+  // remember：把 scope 的粘号改钉到指定 key（换号自愈 / 续期换 token 后，让同一会话继续留在同一个号上）
+  pickSticky.remember = (scope, key) => {
+    if (!scope || !key) return;
+    seen.set(scope, { key, at: now() });
+    if (seen.size > maxEntries) evict();
+  };
+  return pickSticky;
+}

package/src/providers/registry.js

@@ -1,89 +1,89 @@
-/**
- * 可扩展供应商注册表：新增特殊供应商时，仅在此文件注册 + 新增对应 provider 文件即可
- * 每个条目：{ id, match(id, baseUrl) => bool, load() => Promise<factory> }
- * 匹配优先级：按数组顺序，首个命中即用；未命中走通用 generic
- */
-
-export const customProviders = [
-  {
-    id: "workbuddy",
-    match: (id, baseUrl) => id === "workbuddy" || String(baseUrl).includes("copilot.tencent"),
-    load: () => import("./workbuddy.js").then((m) => m.createWorkbuddyProvider),
-  },
-  {
-    id: "traework",
-    match: (id, baseUrl) => id === "traework" || String(baseUrl).includes("trae"),
-    load: () => import("./traework.js").then((m) => m.createTraeworkProvider),
-  },
-  {
-    id: "cline",
-    match: (id, baseUrl) => id === "cline" || String(baseUrl).includes("cline.bot"),
-    load: () => import("./cline.js").then((m) => m.createClineProvider),
-  },
-  {
-    id: "codearts",
-    match: (id, baseUrl) => id === "codearts" || String(baseUrl).includes("myhuaweicloud.com"),
-    load: () => import("./codearts.js").then((m) => m.createCodeartsProvider),
-  },
-  {
-    id: "qoder",
-    match: (id, baseUrl) => id === "qoder" || String(baseUrl).includes("qoder"),
-    load: () => import("./qoder/index.js").then((m) => m.createQoderProvider),
-  },
-  {
-    // ⚠ 必须排在 qwenwork 之前：qwenwork 的 match 用 `includes("qwenwork")`，
-    // 而 "globalqwenwork" 与 "gateway.qwenwork.ai"/"globalqwenwork://native" 都含该子串，
-    // 若后置会被 cn 条目抢先命中（first-match-wins），把国际站 token 打到 cn 网关。
-    id: "globalqwenwork",
-    match: (id, baseUrl) => id === "globalqwenwork" || String(baseUrl).includes("qwenwork.ai"),
-    load: () => import("./globalqwenwork/index.js").then((m) => m.createGlobalQwenworkProvider),
-  },
-  {
-    id: "qwenwork",
-    match: (id, baseUrl) => id === "qwenwork" || String(baseUrl).includes("qwenwork"),
-    load: () => import("./qwenwork/index.js").then((m) => m.createQwenworkProvider),
-  },
-  {
-    id: "zcode",
-    match: (id, baseUrl) => id === "zcode" || String(baseUrl).includes("zcode.z.ai"),
-    load: () => import("./zcode/index.js").then((m) => m.createZcodeProvider),
-  },
-  {
-    id: "railway",
-    // opencode zen free 层的另一个 IP 出口（Railway 反代），只暴露 free 模型。
-    // 匹配必须排在 generic 之前，且不能与其它条目撞（railway.app 域名足够独特）。
-    match: (id, baseUrl) => id === "railway" || String(baseUrl).includes("railway.app"),
-    load: () => import("./railway.js").then((m) => m.createRailwayProvider),
-  },
-  {
-    id: "raccoon",
-    match: (id, baseUrl) => id === "raccoon" || String(baseUrl).includes("xiaohuanxiong.com"),
-    load: () => import("./raccoon/index.js").then((m) => m.createRaccoonProvider),
-  },
-  // agentrouter 定制工厂已于 2026-10-21 摘除：现网成功率仅 ~48%（502/400/422/500 高发），
-  // 从注册表 + 预热名单移除后网关不再解析 agentrouter/* 模型。工厂文件 src/providers/agentrouter.js
-  // 与其测试保留，日后要重新启用只需在此加回一条 { id:"agentrouter", ... } 并同步 dispatcher 预热名单。
-];
-
-// 供 bench/probe 等需要定制化解析模型列表的场景
-export const customNormalizers = [
-  {
-    id: "cline",
-    match: (baseUrl) => String(baseUrl).includes("cline.bot"),
-    normalize: (json) => Array.isArray(json?.free) ? json.free : null,
-  },
-];
-
-export async function getCustomProviderFactory(id, baseUrl) {
-  for (const entry of customProviders) {
-    try { if (entry.match(id, baseUrl)) return await entry.load(); } catch {}
-  }
-  return null;
-}
-
-export function getCustomNormalizer(baseUrl) {
-  for (const entry of customNormalizers) {
-    try { if (entry.match(baseUrl)) return entry.normalize; } catch {}
-  }
-  return null;
-}
+/**
+ * 可扩展供应商注册表：新增特殊供应商时，仅在此文件注册 + 新增对应 provider 文件即可
+ * 每个条目：{ id, match(id, baseUrl) => bool, load() => Promise<factory> }
+ * 匹配优先级：按数组顺序，首个命中即用；未命中走通用 generic
+ */
+
+export const customProviders = [
+  {
+    id: "workbuddy",
+    match: (id, baseUrl) => id === "workbuddy" || String(baseUrl).includes("copilot.tencent"),
+    load: () => import("./workbuddy.js").then((m) => m.createWorkbuddyProvider),
+  },
+  {
+    id: "traework",
+    match: (id, baseUrl) => id === "traework" || String(baseUrl).includes("trae"),
+    load: () => import("./traework.js").then((m) => m.createTraeworkProvider),
+  },
+  {
+    id: "cline",
+    match: (id, baseUrl) => id === "cline" || String(baseUrl).includes("cline.bot"),
+    load: () => import("./cline.js").then((m) => m.createClineProvider),
+  },
+  {
+    id: "codearts",
+    match: (id, baseUrl) => id === "codearts" || String(baseUrl).includes("myhuaweicloud.com"),
+    load: () => import("./codearts.js").then((m) => m.createCodeartsProvider),
+  },
+  {
+    id: "qoder",
+    match: (id, baseUrl) => id === "qoder" || String(baseUrl).includes("qoder"),
+    load: () => import("./qoder/index.js").then((m) => m.createQoderProvider),
+  },
+  {
+    // ⚠ 必须排在 qwenwork 之前：qwenwork 的 match 用 `includes("qwenwork")`，
+    // 而 "globalqwenwork" 与 "gateway.qwenwork.ai"/"globalqwenwork://native" 都含该子串，
+    // 若后置会被 cn 条目抢先命中（first-match-wins），把国际站 token 打到 cn 网关。
+    id: "globalqwenwork",
+    match: (id, baseUrl) => id === "globalqwenwork" || String(baseUrl).includes("qwenwork.ai"),
+    load: () => import("./globalqwenwork/index.js").then((m) => m.createGlobalQwenworkProvider),
+  },
+  {
+    id: "qwenwork",
+    match: (id, baseUrl) => id === "qwenwork" || String(baseUrl).includes("qwenwork"),
+    load: () => import("./qwenwork/index.js").then((m) => m.createQwenworkProvider),
+  },
+  {
+    id: "zcode",
+    match: (id, baseUrl) => id === "zcode" || String(baseUrl).includes("zcode.z.ai"),
+    load: () => import("./zcode/index.js").then((m) => m.createZcodeProvider),
+  },
+  {
+    id: "railway",
+    // opencode zen free 层的另一个 IP 出口（Railway 反代），只暴露 free 模型。
+    // 匹配必须排在 generic 之前，且不能与其它条目撞（railway.app 域名足够独特）。
+    match: (id, baseUrl) => id === "railway" || String(baseUrl).includes("railway.app"),
+    load: () => import("./railway.js").then((m) => m.createRailwayProvider),
+  },
+  {
+    id: "raccoon",
+    match: (id, baseUrl) => id === "raccoon" || String(baseUrl).includes("xiaohuanxiong.com"),
+    load: () => import("./raccoon/index.js").then((m) => m.createRaccoonProvider),
+  },
+  // agentrouter 定制工厂已于 2026-10-21 摘除：现网成功率仅 ~48%（502/400/422/500 高发），
+  // 从注册表 + 预热名单移除后网关不再解析 agentrouter/* 模型。工厂文件 src/providers/agentrouter.js
+  // 与其测试保留，日后要重新启用只需在此加回一条 { id:"agentrouter", ... } 并同步 dispatcher 预热名单。
+];
+
+// 供 bench/probe 等需要定制化解析模型列表的场景
+export const customNormalizers = [
+  {
+    id: "cline",
+    match: (baseUrl) => String(baseUrl).includes("cline.bot"),
+    normalize: (json) => Array.isArray(json?.free) ? json.free : null,
+  },
+];
+
+export async function getCustomProviderFactory(id, baseUrl) {
+  for (const entry of customProviders) {
+    try { if (entry.match(id, baseUrl)) return await entry.load(); } catch {}
+  }
+  return null;
+}
+
+export function getCustomNormalizer(baseUrl) {
+  for (const entry of customNormalizers) {
+    try { if (entry.match(baseUrl)) return entry.normalize; } catch {}
+  }
+  return null;
+}