mslxdff 0.1.155 → 0.1.158

package/src/providers/qwenwork/sse.js

@@ -0,0 +1,268 @@
+// vendor 自 _shared/sse.js 的解帧/清洗/聚合段（逐字搬），另并入上游 completions.js 的额度措辞判定。
+// 关键：qwenwork 上游的内层 body **本身就是 OpenAI chunk**（不像 qoder 需要转译），
+// 外层是 `{"headers":{},"body":"<内层JSON字符串>","statusCodeValue":200}` 的信封。
+import { cleanErrorText } from "./http.js";
+
+function fmtBodyText(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") return JSON.stringify(value);
+  return "";
+}
+
+function bodyCodeMessage(raw, status) {
+  let inner;
+  try {
+    inner = JSON.parse(raw);
+  } catch {
+    return status >= 400 ? `upstream ${status}: ${String(raw).slice(0, 200)}` : "";
+  }
+  if (!inner || typeof inner !== "object") return "";
+  const code = inner.code;
+  if (code === "400" || code === "401" || code === "403") {
+    return inner.message ? String(inner.message) : `upstream ${code}`;
+  }
+  if (status >= 400) {
+    return inner.message ? String(inner.message) : `upstream ${status}: ${String(raw).slice(0, 200)}`;
+  }
+  return "";
+}
+
+export function unwrapFrame(payload) {
+  if (typeof payload !== "string") return { ok: false };
+  const text = String(payload).trim();
+  if (!text || text === "[DONE]" || text === "{}") return { ok: false };
+  let outer;
+  try {
+    outer = JSON.parse(text);
+  } catch {
+    return { ok: true, body: text };
+  }
+  if (!outer || typeof outer !== "object") return { ok: false };
+  if (Object.prototype.hasOwnProperty.call(outer, "choices")) return { ok: true, body: text };
+  if (outer.object === "chat.completion.chunk" || outer.object === "chat.completion") return { ok: true, body: text };
+  if (typeof outer.statusCodeValue === "number" && outer.statusCodeValue >= 400) {
+    return { ok: false, error: bodyCodeMessage(fmtBodyText(outer.body), outer.statusCodeValue) };
+  }
+  if (!Object.prototype.hasOwnProperty.call(outer, "body")) return { ok: false };
+  const inner = outer.body;
+  if (typeof inner === "string") {
+    if (!inner || inner === "[DONE]" || inner === "{}" || inner === "null") return { ok: false };
+    const msg = bodyCodeMessage(inner, 0);
+    if (msg) return { ok: false, error: msg };
+    return { ok: true, body: inner };
+  }
+  if (inner && typeof inner === "object") {
+    const s = JSON.stringify(inner);
+    if (s === "{}" || s === "[]") return { ok: false };
+    return { ok: true, body: s };
+  }
+  return { ok: false };
+}
+
+function isEmptyValue(v) {
+  if (v === null || v === undefined) return true;
+  if (typeof v === "string") return v === "";
+  if (Array.isArray(v)) return v.length === 0;
+  if (typeof v === "object") {
+    for (const key of Object.keys(v)) {
+      if (!isEmptyValue(v[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+export function cleanChunk(text) {
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    return text;
+  }
+  if (!obj || typeof obj !== "object") return text;
+
+  if (obj.usage && typeof obj.usage === "object") {
+    let changed = false;
+    for (const noise of ["raw_usage", "sub_usages"]) {
+      if (Object.prototype.hasOwnProperty.call(obj.usage, noise)) {
+        delete obj.usage[noise];
+        changed = true;
+      }
+      if (Object.prototype.hasOwnProperty.call(obj, noise)) {
+        delete obj[noise];
+        changed = true;
+      }
+    }
+    return changed ? JSON.stringify(obj) : text;
+  }
+
+  let changed = false;
+  if (Array.isArray(obj.choices)) {
+    for (const choice of obj.choices) {
+      if (!choice || typeof choice !== "object") continue;
+      const delta = choice.delta;
+      if (!delta || typeof delta !== "object") continue;
+      if (Array.isArray(delta.tool_calls) && delta.tool_calls.length === 0) {
+        delete delta.tool_calls;
+        changed = true;
+      }
+      for (const noise of ["content", "reasoning_content", "function_call", "refusal", "extra_fields"]) {
+        if (Object.prototype.hasOwnProperty.call(delta, noise) && isEmptyValue(delta[noise])) {
+          delete delta[noise];
+          changed = true;
+        }
+      }
+      if (Object.keys(delta).length === 0 && !choice.finish_reason) return "";
+    }
+  }
+  return changed ? JSON.stringify(obj) : text;
+}
+
+function mergeToolCallDelta(merged, delta) {
+  for (const key of ["id", "type"]) {
+    if (merged[key] === undefined && typeof delta[key] === "string" && delta[key] !== "") merged[key] = delta[key];
+  }
+  const dfn = delta.function;
+  if (!dfn || typeof dfn !== "object") return;
+  if (!merged.function || typeof merged.function !== "object") merged.function = {};
+  if (typeof dfn.name === "string" && dfn.name !== "") merged.function.name = (merged.function.name || "") + dfn.name;
+  if (typeof dfn.arguments === "string" && dfn.arguments !== "") {
+    merged.function.arguments = (merged.function.arguments || "") + dfn.arguments;
+  }
+}
+
+export function aggregate(chunks, model) {
+  let content = "";
+  let reasoning = "";
+  let role = "";
+  let respModel = "";
+  let respID = "";
+  let finish = "";
+  let created = 0;
+  let usage = null;
+  const toolCalls = new Map();
+  const toolOrder = [];
+
+  for (const text of chunks) {
+    let chunk;
+    try {
+      chunk = JSON.parse(text);
+    } catch {
+      continue;
+    }
+    if (!chunk || typeof chunk !== "object") continue;
+    if (typeof chunk.id === "string" && chunk.id !== "") respID = chunk.id;
+    if (typeof chunk.model === "string" && chunk.model !== "") respModel = chunk.model;
+    if (typeof chunk.created === "number") created = chunk.created;
+    if (chunk.usage && typeof chunk.usage === "object") usage = chunk.usage;
+    if (!Array.isArray(chunk.choices)) continue;
+    for (const choice of chunk.choices) {
+      if (!choice || typeof choice !== "object") continue;
+      const delta = choice.delta;
+      if (delta && typeof delta === "object") {
+        if (typeof delta.role === "string" && delta.role !== "") role = delta.role;
+        if (typeof delta.content === "string") content += delta.content;
+        if (typeof delta.reasoning_content === "string") reasoning += delta.reasoning_content;
+        if (Array.isArray(delta.tool_calls)) {
+          for (const call of delta.tool_calls) {
+            if (!call || typeof call !== "object") continue;
+            const idx = typeof call.index === "number" ? call.index : 0;
+            if (!toolCalls.has(idx)) {
+              toolCalls.set(idx, { index: idx });
+              toolOrder.push(idx);
+            }
+            mergeToolCallDelta(toolCalls.get(idx), call);
+          }
+        }
+      }
+      if (typeof choice.finish_reason === "string" && choice.finish_reason !== "") finish = choice.finish_reason;
+    }
+  }
+
+  const message = { role: role || "assistant", content };
+  if (reasoning !== "") message.reasoning_content = reasoning;
+  if (toolOrder.length > 0) {
+    toolOrder.sort((a, b) => a - b);
+    message.tool_calls = toolOrder.map((idx) => toolCalls.get(idx));
+  }
+  const result = {
+    id: respID || "chatcmpl-qwenwork",
+    object: "chat.completion",
+    created: created || Math.floor(Date.now() / 1000),
+    model: respModel || model,
+    choices: [{ index: 0, message, finish_reason: finish || "stop" }],
+  };
+  if (usage) result.usage = usage;
+  return result;
+}
+
+/** 单行 SSE → OpenAI chunk 文本（null = 跳过）；错误写进 state.error。 */
+export function handleLine(line, state) {
+  if (!line.startsWith("data:")) return null;
+  const frame = unwrapFrame(line.slice(5));
+  if (frame.error) {
+    state.error = frame.error;
+    return null;
+  }
+  if (!frame.ok) return null;
+  try {
+    const parsed = JSON.parse(frame.body);
+    if (parsed && typeof parsed === "object" && parsed.usage && typeof parsed.usage === "object") state.usage = parsed.usage;
+  } catch {
+    /* keep raw chunk */
+  }
+  const cleaned = cleanChunk(frame.body);
+  if (!cleaned) return null;
+  return `data: ${cleaned}\n\n`;
+}
+
+export async function collectSync(upstreamBody, model) {
+  const reader = upstreamBody.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const chunks = [];
+  const state = { usage: null, error: null };
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const out = handleLine(line, state);
+        if (out) chunks.push(out.slice(6).trim());
+      }
+    }
+    if (buffer) {
+      const out = handleLine(buffer, state);
+      if (out) chunks.push(out.slice(6).trim());
+    }
+  } catch (err) {
+    state.error = `upstream stream read error: ${err && err.message ? err.message : err}`;
+  }
+
+  if (state.error) return { error: cleanErrorText(state.error) };
+  return { completion: aggregate(chunks, model), usage: state.usage };
+}
+
+// ---- 额度耗尽识别（上游措辞表逐字搬自原作者 completions.js，含 code 14018）----
+const CREDIT_EXHAUSTED_MARKERS = [
+  "credits exhausted", "insufficient credit", "no credit", "credit exhausted", "out of credit",
+  "quota exceeded", "quota exhaust", "credit not enough", "not enough credit", "payment required",
+  "积分不足", "额度不足", "余额不足", "积分用完", "额度用尽", "没有积分",
+];
+
+export function creditsExhaustedText(value) {
+  const s = String(value === undefined || value === null ? "" : value);
+  if (/\bcode["'\s:=]*14018\b/.test(s)) return true;
+  const lower = s.toLowerCase();
+  return CREDIT_EXHAUSTED_MARKERS.some((m) => lower.includes(m.toLowerCase()));
+}
+
+export function isCreditsExhausted(status, text) {
+  if (status !== 429 && status !== 402) return false;
+  if (status === 402) return true;
+  return creditsExhaustedText(text);
+}

package/src/providers/qwenwork/stream.js

@@ -0,0 +1,130 @@
+// vendor 自 _shared/sse.js 的 transform（真流式：上游 SSE → OpenAI chunk，边收边吐）。
+// 唯一一处**有意偏离**原作者实现：把 chunk 里的 `model` 回写成客户端请求的模型名。
+// 上游实际返回的是池名（实测 `qwork-openai-chat-mode-pool`），直接透传会让客户端按模型名匹配失败，
+// 违反本仓契约 1「model 原样透传」。原作者的非流式路径同样做了 `completion.model = wantModel`。
+import { handleLine } from "./sse.js";
+
+function rewriteModel(frameText, model) {
+  if (!model) return frameText;
+  const body = frameText.slice(6, -2);
+  let obj;
+  try {
+    obj = JSON.parse(body);
+  } catch {
+    return frameText;
+  }
+  if (!obj || typeof obj !== "object") return frameText;
+  obj.model = model;
+  return `data: ${JSON.stringify(obj)}\n\n`;
+}
+
+export function transformStream(upstreamBody, model, onUsage, { heartbeatMs = 15000 } = {}) {
+  const reader = upstreamBody.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  let notified = false;
+  let heartbeat = null;
+  const state = { usage: null, error: null };
+
+  const notify = () => {
+    if (notified) return;
+    notified = true;
+    if (onUsage) onUsage(state.usage);
+  };
+
+  const emitError = (controller, message) => {
+    try {
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: { message, type: "upstream_error" } })}\n\n`));
+      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.close();
+    } catch {
+      /* 客户端已断开 */
+    }
+  };
+
+  const stopHeartbeat = () => {
+    if (heartbeat) {
+      clearInterval(heartbeat);
+      heartbeat = null;
+    }
+  };
+
+  const finish = () => {
+    stopHeartbeat();
+    notify();
+  };
+
+  return new ReadableStream({
+    start(controller) {
+      if (heartbeatMs > 0) {
+        heartbeat = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(": ping\n\n"));
+          } catch {
+            /* 已关闭 */
+          }
+        }, heartbeatMs);
+        if (heartbeat.unref) heartbeat.unref();
+      }
+    },
+    async pull(controller) {
+      try {
+        for (;;) {
+          let read;
+          try {
+            read = await reader.read();
+          } catch (err) {
+            const message = `upstream stream read error: ${err && err.message ? err.message : err}`;
+            stopHeartbeat();
+            emitError(controller, message);
+            notify();
+            return;
+          }
+          if (read.done) {
+            stopHeartbeat();
+            if (buffer) {
+              const out = handleLine(buffer, state);
+              if (out) controller.enqueue(encoder.encode(rewriteModel(out, model)));
+              buffer = "";
+            }
+            if (state.error) emitError(controller, state.error);
+            else {
+              try {
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+              } catch {
+                /* 客户端已断开 */
+              }
+            }
+            finish();
+            return;
+          }
+          buffer += decoder.decode(read.value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          let out = "";
+          for (const line of lines) {
+            const frame = handleLine(line, state);
+            if (frame) out += rewriteModel(frame, model);
+          }
+          if (out) {
+            controller.enqueue(encoder.encode(out));
+            return;
+          }
+        }
+      } catch (err) {
+        finish();
+        try {
+          emitError(controller, `stream error: ${err && err.message ? err.message : err}`);
+        } catch {
+          /* 已关闭 */
+        }
+      }
+    },
+    cancel(reason) {
+      finish();
+      if (reader.cancel) reader.cancel(reason);
+    },
+  });
+}

package/src/providers/qwenwork/upstream.js

@@ -0,0 +1,120 @@
+// vendor 自 _shared/upstream.js（签名请求装配 + OAuth 设备流），逐字搬；
+// 唯一改动：fetch 实现改为注入（默认本仓统一的 compatFetch，走 undici 连接池，勿混用 globalThis.fetch）。
+import { compatFetch } from "../../compat.js";
+import { uuid, b64url, utf8 } from "./crypto.js";
+import { signHeaders } from "./cosy.js";
+import {
+  UA, CLIENT_ID, REDIRECT_URI, DEVICE_AUTH_URL, CHAT_URL, MODELS_URL,
+  USERINFO_URL, ACCOUNT_CONTEXT_URL, POLL_URL, REFRESH_URL, MODEL_SLICE,
+} from "./constants.js";
+
+function plainHeaders() {
+  return {
+    accept: "application/json, text/plain, */*",
+    "content-type": "application/json",
+    "user-agent": UA,
+  };
+}
+
+export function chatRequest(account, modelKey, bodyStr, signal, fetchImpl = compatFetch) {
+  const headers = signHeaders(account, bodyStr, CHAT_URL, modelKey, "text/event-stream");
+  return fetchImpl(CHAT_URL, { method: "POST", headers, body: bodyStr, signal });
+}
+
+export async function modelList(account, fetchImpl = compatFetch) {
+  const headers = signHeaders(account, "", MODELS_URL, "", "application/json");
+  const res = await fetchImpl(MODELS_URL, { headers });
+  if (!res.ok) throw new Error(`models http ${res.status}`);
+  const data = await res.json();
+  // 实测 11 个根切片只有 `qwork` 非空（其余 n=0）；切片名见 constants.MODEL_SLICE
+  const list = Array.isArray(data && data[MODEL_SLICE]) ? data[MODEL_SLICE] : [];
+  return list
+    .filter((m) => m && m.enable !== false && m.key)
+    .map((m) => ({
+      key: m.key,
+      name: m.display_name || m.key,
+      isReasoning: !!m.is_reasoning,
+      isVL: !!m.is_vl,
+      maxInputTokens: m.max_input_tokens || 0,
+      maxOutputTokens: m.max_output_tokens || 0,
+      priceFactor: typeof m.price_factor === "number" ? m.price_factor : 0,
+      description: typeof m.description === "string" ? m.description : "",
+    }));
+}
+
+export async function userInfo(accessToken, fetchImpl = compatFetch) {
+  const res = await fetchImpl(USERINFO_URL, {
+    headers: { ...plainHeaders(), authorization: `Bearer ${accessToken}` },
+  });
+  if (!res.ok) throw new Error(`userinfo http ${res.status}`);
+  return res.json();
+}
+
+/** 额度/套餐：data.{user,plan,quota}；quota.remaining 即积分余量。 */
+export async function accountContext(accessToken, fetchImpl = compatFetch) {
+  const res = await fetchImpl(ACCOUNT_CONTEXT_URL, {
+    headers: { ...plainHeaders(), authorization: `Bearer ${accessToken}` },
+  });
+  if (!res.ok) throw new Error(`account-context http ${res.status}`);
+  const body = await res.json();
+  if (!body || (body.code && body.code !== "ok")) throw new Error(`account-context code=${body && body.code}`);
+  return (body && body.data) || {};
+}
+
+export async function refreshDeviceToken(refreshToken, fetchImpl = compatFetch) {
+  const res = await fetchImpl(REFRESH_URL, {
+    method: "POST",
+    headers: plainHeaders(),
+    body: JSON.stringify({ refresh_token: refreshToken }),
+  });
+  if (!res.ok) throw new Error(`refresh http ${res.status}`);
+  const data = await res.json();
+  const access = data && (data.token || data.device_token);
+  if (!access || !data.refresh_token) throw new Error("refresh: incomplete token pair");
+  return data;
+}
+
+export async function pollGrant(nonce, verifier, fetchImpl = compatFetch) {
+  const q = new URLSearchParams({ nonce, verifier, challenge_method: "S256" });
+  const res = await fetchImpl(`${POLL_URL}?${q.toString()}`, {
+    headers: { accept: "application/json", "user-agent": UA },
+  });
+  if (res.status === 404 || res.status === 202) return { pending: true };
+  if (!res.ok) throw new Error(`poll http ${res.status}`);
+  const data = await res.json();
+  if (!data || !(data.token || data.device_token)) return { pending: true };
+  return { pending: false, grant: data };
+}
+
+export async function newDeviceFlow() {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const raw = new Uint8Array(64);
+  crypto.getRandomValues(raw);
+  let verifier = "";
+  for (let i = 0; i < raw.length; i++) verifier += alphabet[raw[i] % alphabet.length];
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", utf8(verifier)));
+  const challenge = b64url(digest);
+  const nonce = uuid();
+  const machineID = uuid();
+  const q = new URLSearchParams({
+    challenge,
+    challenge_method: "S256",
+    nonce,
+    machine_id: machineID,
+    client_id: CLIENT_ID,
+    redirect_uri: REDIRECT_URI,
+  });
+  return { verifier, nonce, url: `${DEVICE_AUTH_URL}?${q.toString()}` };
+}
+
+export function expiryUnix(grant) {
+  if (grant && grant.expires_at) {
+    const t = Date.parse(grant.expires_at);
+    if (!Number.isNaN(t)) return Math.floor(t / 1000);
+  }
+  if (grant && grant.expires_in > 0) {
+    const ms = grant.expires_in > 10000000 ? grant.expires_in : grant.expires_in * 1000;
+    return Math.floor((Date.now() + ms) / 1000);
+  }
+  return Math.floor((Date.now() + 30 * 24 * 3600 * 1000) / 1000);
+}

package/src/providers/qwenwork.js

@@ -0,0 +1 @@
+export * from "./qwenwork/index.js";

package/src/providers/registry.js

@@ -1,56 +1,66 @@
-/**
- * 可扩展供应商注册表：新增特殊供应商时，仅在此文件注册 + 新增对应 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),
-  },
-];
-
-// 供 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),
+  },
+  {
+    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),
+  },
+];
+
+// 供 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;
+}

package/src/providers/share-keys.js

@@ -9,8 +9,8 @@ export const SHARE_KEYS_HEADER = "x-mslxdff-share-keys";
 
 // 硬排除：refresh-token 型凭据（对端刷新会轮换 token，与本机互相踢下线）——正确性问题。
 // 二层保护：① 按 id 硬排除（cline 恒 local-only）；② 按凭据形状兜底（见 shareableProviderIds）。
-// traework 与 workbuddy 同为本机账号绑定型（auths/*.json + uid），恒不借出。
-const NEVER_SHARE_IDS = new Set(["cline", "codearts", "traework", "qoder"]);
+// traework/workbuddy/zcode 同为本机账号绑定型（auths/*.json + uid；zcode 还带 per-account deviceMid），恒不借出。
+const NEVER_SHARE_IDS = new Set(["cline", "codearts", "traework", "qoder", "zcode"]);
 // 本节点应 cast key 到出站转发的供应商 id 集合 = 所有「本机有 key」的供应商，
 // 减去：opencode（无 key 且恒排除）、local-only（workbuddy/cline系，本就不走组员）、刷新型凭据。
 export function shareableProviderIds({ file } = {}) {