mslxdff 0.1.56 → 0.1.60

package/src/routes/chat/index.js

@@ -1,6 +1,7 @@
 import { performance } from "node:perf_hooks";
 import { injectReasoningContent, normalizeModel } from "../../reasoning.js";
 import { isAutoModel } from "../../auto.js";
+import { toInternalId as aliasToInternal } from "../../sync-opencode.js";
 import { clientIp, json, readBody, parseHops, summarizePrompt, errMsg } from "../helpers.js";
 import { hedgeDelayMs, shouldHedge } from "../hedge.js";
 import { runHook } from "../../plugins.js";
@@ -10,6 +11,7 @@ import { handleLocalRelay } from "./local-handler.js";
 import { handlePeerRelay } from "./peer-handler.js";
 import { handleBroadbandRelay } from "./broadband-handler.js";
 import { handleExhaustedLocal, handleExhaustedAll } from "./exhausted-handler.js";
+import { normalizeFullId, getModelAlias } from "../../providers/model-id.js";
 
 export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHops, groups, bus, token, plugins }) {
   let body;
@@ -39,9 +41,48 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
   const workbuddyUid = (req.headers["x-mslxdff-workbuddy-uid"] || req.headers["x-workbuddy-uid"] || "").toString().trim();
   const lockModel = req.headers["x-mslxdff-model-lock"] || "";
   const rawModel = body.model || "";
-  const requested = normalizeModel(lockModel || rawModel || "");
+  let normalizedRequested = normalizeModel(lockModel || rawModel || "");
+  // WorkBuddy 别名还原：clinebot-z-ai-glm-5.3-flash → clinebot/z-ai/glm-5.3-flash
+  const aliasResolved = getModelAlias(normalizedRequested);
+  if (aliasResolved) {
+    normalizedRequested = aliasResolved;
+    body = { ...body, model: aliasResolved };
+  }
+  // alias 还原：mslxdff-deepseek -> deepseek（原名仍兼容，双向支持 mslxdff/mslxdff-deepseek 与裸 mslxdff-deepseek/裸 deepseek）
+  let requested = normalizedRequested;
+  let aliasInfo = null;
+  if (requested.startsWith("mslxdff-")) {
+    const internal = aliasToInternal(requested);
+    if (internal) {
+      aliasInfo = `${requested} -> ${internal}`;
+      requested = internal;
+    }
+  } else if (requested.includes("/")) {
+    const slashIdx = requested.indexOf("/");
+    const rawPart = requested.slice(slashIdx + 1);
+    const providerPart = requested.slice(0, slashIdx);
+    if (rawPart.startsWith("mslxdff-")) {
+      const internal = aliasToInternal(rawPart);
+      if (internal) {
+        aliasInfo = `${requested} -> ${providerPart}/${internal} (alias stripped)`;
+        requested = `${providerPart}/${internal}`;
+        if (providerPart === "mslxdff") {
+          requested = internal;
+          aliasInfo = `${rawModel} -> ${internal} (mslxdff alias stripped)`;
+        }
+      }
+    } else if (providerPart === "mslxdff") {
+      // mslxdff/deepseek 原名直用 -> deepseek（原名兼容，provider 前缀剥离）
+      aliasInfo = `${requested} -> ${rawPart} (mslxdff provider stripped, 原名兼容)`;
+      requested = rawPart;
+    }
+  }
   const useAuto = isAutoModel(requested);
   mark("parsed");
+  if (aliasInfo) {
+    // 供日志与 header 透传
+    try { res.setHeader("x-mslxdff-alias", aliasInfo); } catch {}
+  }
 
   let order;
   if (lockModel) {
@@ -70,6 +111,7 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
     runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body.stream), durationMs: Date.now() - startedAt, ...info }).catch(() => {});
   };
   evt("request", { reqId, hops, ip: clientIp(req), stream: Boolean(body.stream), prompt: summarizePrompt(body), rawModel, requested, lockModel: lockModel || null });
+  if (aliasInfo) evt("alias", { reqId, alias: aliasInfo, rawModel, requested });
   if (Object.keys(shareKeys).length) evt("share-keys", { reqId, providers: Object.keys(shareKeys) });
   evt("ordered", { reqId, order, canFallback, canForwardPeers, useAuto, statuses: auto?.statuses?.() ?? null });
 
@@ -83,7 +125,7 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
     for (const e of sel.errors) evt("plugin-hook-error", { reqId, hook: "model:select", plugin: e.plugin, error: e.error });
   }
 
-  const handlerCtx = { reqId, model: null, body, hops, peers, plugins, evt, logError, logCall };
+  const handlerCtx = { reqId, model: null, body, hops, peers, plugins, evt, logError, logCall, logs };
 
   let lastErr = null;
   for (let idx = 0; idx < order.length; idx++) {

package/src/routes/stream.js

@@ -61,6 +61,8 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
     exitReason: null,
     upstreamError: null,
     downstreamClosed: false,
+    usage: null,
+    chars: 0,
   };
   let prevChunkAt = t0;
   const onClose = () => {
@@ -125,6 +127,43 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
             if (txt.includes("[DONE]")) detail.sawDone = true;
             const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);
             if (m) detail.sawFinishReason = m[1];
+            // 尝试提取 usage（流式末帧）
+            if (txt.includes("\"usage\"") || txt.includes("prompt_tokens")) {
+              try {
+                const lines = txt.split("\n");
+                for (const line of lines) {
+                  const t = line.trim();
+                  if (!t.startsWith("data:")) continue;
+                  const d = t.slice(5).trim();
+                  if (d === "[DONE]" || !d) continue;
+                  const j = JSON.parse(d);
+                  if (j && j.usage && typeof j.usage === "object") {
+                    const u = j.usage;
+                    const pt = Number(u.prompt_tokens ?? u.promptTokens ?? u.input_tokens);
+                    const ct = Number(u.completion_tokens ?? u.completionTokens ?? u.output_tokens);
+                    const tt = Number(u.total_tokens ?? u.totalTokens);
+                    const cur = {};
+                    if (Number.isFinite(pt)) cur.prompt_tokens = pt;
+                    if (Number.isFinite(ct)) cur.completion_tokens = ct;
+                    if (Number.isFinite(tt)) cur.total_tokens = tt;
+                    if (Object.keys(cur).length) detail.usage = cur;
+                    // 兜底 chars：从 choices 文本长度累加
+                    const delta = j.choices?.[0]?.delta?.content || j.choices?.[0]?.message?.content || "";
+                    if (delta) detail.chars += String(delta).length;
+                  }
+                }
+              } catch {}
+            } else {
+              // 非 usage 的普通 delta 也累 chars
+              try {
+                const txt2 = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+                const ms = txt2.match(/"content"\s*:\s*"([^"]*)"/g);
+                if (ms) for (const mm of ms) {
+                  const c = JSON.parse(`{${mm}}`);
+                  if (c.content) detail.chars += String(c.content).length;
+                }
+              } catch {}
+            }
           } catch { /* ignore */ }
           if (timedOut || stalled || tooLong) break;
           if (first) {
@@ -190,14 +229,32 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
   const text = await upRes.text();
   detail.receivedBytes = Buffer.byteLength(text);
   detail.exitReason = "normal-non-stream";
+  // 非流式 usage 与 chars 提取
   try {
     const parsed = JSON.parse(text);
+    const u = parsed.usage;
+    if (u && typeof u === "object") {
+      const pt = Number(u.prompt_tokens ?? u.promptTokens ?? u.input_tokens);
+      const ct = Number(u.completion_tokens ?? u.completionTokens ?? u.output_tokens);
+      const tt = Number(u.total_tokens ?? u.totalTokens);
+      const cur = {};
+      if (Number.isFinite(pt)) cur.prompt_tokens = pt;
+      if (Number.isFinite(ct)) cur.completion_tokens = ct;
+      if (Number.isFinite(tt)) cur.total_tokens = tt;
+      if (Object.keys(cur).length) detail.usage = cur;
+      if (parsed.choices?.[0]?.message?.content) detail.chars = String(parsed.choices[0].message.content).length;
+      else if (parsed.choices?.[0]?.text) detail.chars = String(parsed.choices[0].text).length;
+    }
     const enriched = enrichNonStreamJson(parsed, fallback);
     json(res, upRes.status, enriched);
   } catch {
     res.statusCode = upRes.status;
     res.setHeader("Content-Type", contentType || "text/plain");
     res.end(text);
+    // 纯文本时按长度估 chars
+    try { detail.chars = text.length; } catch {}
   }
-  return { status: upRes.status, ttfMs: null, totalMs: Math.round(performance.now() - t0), aborted: false, interrupted: false, detail };
+  // 非流式 ttf 视为 total（一次性返回）
+  const totalMs = Math.round(performance.now() - t0);
+  return { status: upRes.status, ttfMs: totalMs, totalMs, aborted: false, interrupted: false, detail };
 }

package/src/state.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync, statSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync, statSync, renameSync, unlinkSync, existsSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import os from "node:os";
@@ -7,8 +7,30 @@ import os from "node:os";
 export const DEFAULT_PORT = 8989;
 
 export function defaultStateFile() {
-  return process.env.MSLXDFF_STATE_FILE ||
-    join(os.homedir(), ".config", "mslxdff", "state.json");
+  if (process.env.MSLXDFF_STATE_FILE) return process.env.MSLXDFF_STATE_FILE;
+  if (process.argv.includes("--test") || process.env.NODE_ENV === "test") {
+    return join(os.tmpdir(), "mslxdff-test-state.json");
+  }
+  return join(os.homedir(), ".config", "mslxdff", "state.json");
+}
+
+export function tokenFile(file) {
+  if (process.env.MSLXDFF_TOKEN_FILE) return process.env.MSLXDFF_TOKEN_FILE;
+  const sf = file || defaultStateFile();
+  const realDefault = join(os.homedir(), ".config", "mslxdff", "state.json");
+  if (sf !== realDefault) return join(dirname(sf), "token");
+  if (process.argv.includes("--test") || process.env.NODE_ENV === "test") {
+    return join(os.tmpdir(), "mslxdff-test-token");
+  }
+  return join(os.homedir(), ".config", "mslxdff", "token");
+}
+
+function syncTokenFile(token, file) {
+  try {
+    const tf = tokenFile(file);
+    mkdirSync(dirname(tf), { recursive: true });
+    writeFileSync(tf, String(token || "").trim() + "\n", "utf8");
+  } catch {}
 }
 
 export function generateToken() {
@@ -93,7 +115,14 @@ function writeStateImmediate(file, patch) {
     e.timer = null;
   }
   mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, JSON.stringify(merged, null, 2), { mode: 0o600 });
+  const tmp = `${file}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  writeFileSync(tmp, JSON.stringify(merged, null, 2), { mode: 0o600 });
+  try {
+    renameSync(tmp, file);
+  } catch {
+    try { writeFileSync(file, JSON.stringify(merged, null, 2), { mode: 0o600 }); } catch {}
+    try { unlinkSync(tmp); } catch {}
+  }
   try {
     e.mtimeMs = statSync(file).mtimeMs;
   } catch {
@@ -174,13 +203,31 @@ export function clearStateCache(file) {
 export async function loadToken({ file = defaultStateFile() } = {}) {
   const state = readState(file);
   if (typeof state.token === "string" && state.token.length > 0) {
+    syncTokenFile(state.token, file);
     return { token: state.token, created: false };
   }
-  return { token: writeStateImmediate(file, { token: generateToken(), createdAt: new Date().toISOString() }).token, created: true };
+  if (existsSync(file)) {
+    try {
+      const raw = JSON.parse(readFileSync(file, "utf8"));
+      if (typeof raw.token === "string" && raw.token.length > 0) {
+        syncTokenFile(raw.token, file);
+        const e = getEntry(file);
+        e.data = raw;
+        try { e.mtimeMs = statSync(file).mtimeMs; } catch {}
+        return { token: raw.token, created: false };
+      }
+    } catch {}
+  }
+  const tok = generateToken();
+  const saved = writeStateImmediate(file, { token: tok, createdAt: new Date().toISOString() }).token;
+  syncTokenFile(saved, file);
+  return { token: saved, created: true };
 }
 
 export async function refreshToken({ file = defaultStateFile() } = {}) {
-  return writeStateImmediate(file, { token: generateToken(), createdAt: new Date().toISOString() }).token;
+  const tok = writeStateImmediate(file, { token: generateToken(), createdAt: new Date().toISOString() }).token;
+  syncTokenFile(tok, file);
+  return tok;
 }
 
 export function setPort(port, { file = defaultStateFile() } = {}) {
@@ -212,6 +259,16 @@ export function saveModelLatencies(latencies, { file = defaultStateFile() } = {}
   return latencies;
 }
 
+export function loadModelStats({ file = defaultStateFile() } = {}) {
+  const s = readState(file).modelStats;
+  return s && typeof s === "object" && !Array.isArray(s) ? s : {};
+}
+
+export function saveModelStats(stats, { file = defaultStateFile() } = {}) {
+  writeStateDeferred(file, { modelStats: stats });
+  return stats;
+}
+
 export function loadPreferredModel({ file = defaultStateFile() } = {}) {
   const v = readState(file).preferredModel;
   return typeof v === "string" && v.trim() ? v.trim() : null;
@@ -487,11 +544,30 @@ export function removeProviderAllowedModels(id, targets = [], opts = {}) {
   return saveProviderAllowedModels(id, next, opts);
 }
 
+function normalizeAllowAny(v, id) {
+  if (typeof v === "boolean") return v;
+  if (String(id || "").toLowerCase() === "opencode") return true;
+  return false;
+}
+export function loadProviderAllowAnyModels(id, { file = defaultStateFile() } = {}) {
+  const cfg = readState(file).providerConfigs?.[id];
+  if (cfg && typeof cfg.allowAnyModels === "boolean") return cfg.allowAnyModels;
+  return normalizeAllowAny(undefined, id);
+}
+export function saveProviderAllowAnyModels(id, allowAny, { file = defaultStateFile() } = {}) {
+  const state = readState(file);
+  const cfgs = { ...(state.providerConfigs || {}) };
+  const cur = cfgs[id] || {};
+  cfgs[id] = { ...cur, allowAnyModels: normalizeAllowAny(allowAny, id) };
+  writeStateImmediate(file, { providerConfigs: cfgs });
+  return cfgs[id].allowAnyModels;
+}
 export function isModelAllowed(id, rawModel, { file = defaultStateFile() } = {}) {
   const raw = String(rawModel || "").trim();
   if (!raw) return true;
   const allowed = loadProviderAllowedModels(id, { file });
-  if (!allowed.length) return true;
+  const allowAny = loadProviderAllowAnyModels(id, { file });
+  if (!allowed.length) return allowAny;
   const norm = normalizeAllowedModel(raw, id);
   return allowed.includes(norm);
 }

package/src/sync-opencode.js

@@ -0,0 +1,152 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+import os from "node:os";
+
+export function opencodeConfigPath() {
+  const env = process.env.OPENCODE_CONFIG || process.env.OPENCODE_CONFIG_PATH;
+  if (typeof env === "string" && env.trim()) return env.trim();
+  return join(os.homedir(), ".config", "opencode", "opencode.json");
+}
+
+export function toExternalAlias(id) {
+  const s = String(id || "").trim();
+  if (!s) return "";
+  return s.startsWith("mslxdff-") ? s : `mslxdff-${s}`;
+}
+
+export function toInternalId(aliasOrRaw) {
+  const s = String(aliasOrRaw || "").trim();
+  if (!s) return "";
+  return s.startsWith("mslxdff-") ? s.slice("mslxdff-".length) : s;
+}
+
+export function buildOpencodeProvider({ id, token, port }) {
+  const p = Number(port) || 8989;
+  const alias = toExternalAlias(id);
+  return {
+    name: "mslxdff",
+    npm: "@ai-sdk/openai-compatible",
+    options: {
+      apiKey: String(token || ""),
+      baseURL: `http://127.0.0.1:${p}/v1`,
+    },
+    models: {
+      [alias]: { name: alias },
+    },
+  };
+}
+
+export function isOpencodeLocalUrl(url) {
+  const u = String(url || "");
+  return u.includes("127.0.0.1") && u.includes("/v1");
+}
+
+export async function syncToOpencode({ id, token, port, file } = {}) {
+  const targetFile = file || opencodeConfigPath();
+  // id 可能是 alias 或原名，统一以 internal 去重、以 external 入库（原名兼容）
+  const normalizedRaw = String(id || "").trim();
+  if (!normalizedRaw) throw new Error("model id required");
+  const internal = toInternalId(normalizedRaw);
+  if (!internal) throw new Error("model id required");
+  const external = toExternalAlias(internal);
+  const cleanToken = String(token || "");
+  const p = Number(port) || 8989;
+
+  let data = null;
+  let corrupted = false;
+  let rawText = null;
+  try {
+    rawText = readFileSync(targetFile, "utf8");
+    const parsed = JSON.parse(rawText);
+    data = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (err) {
+    if (rawText !== null) {
+      corrupted = true;
+      try {
+        mkdirSync(dirname(targetFile), { recursive: true });
+        writeFileSync(targetFile + ".bak", rawText ?? "", "utf8");
+      } catch {}
+      data = {};
+    } else {
+      data = {};
+    }
+  }
+
+  if (!data.provider || typeof data.provider !== "object" || Array.isArray(data.provider)) {
+    data.provider = {};
+  }
+
+  const oldProvider = data.provider.mslxdff && typeof data.provider.mslxdff === "object" && !Array.isArray(data.provider.mslxdff)
+    ? data.provider.mslxdff
+    : null;
+
+  let action;
+  let effectiveId = external;
+  if (oldProvider) {
+    const oldModels = oldProvider.models && typeof oldProvider.models === "object" && !Array.isArray(oldProvider.models)
+      ? oldProvider.models
+      : {};
+    // 去重：internal 或 external 任一已存在即视为已存在（原名兼容，以 internal 为基准）
+    const hasExternal = Object.prototype.hasOwnProperty.call(oldModels, external);
+    const hasInternal = Object.prototype.hasOwnProperty.call(oldModels, internal);
+    const exists = hasExternal || hasInternal;
+    const nextModels = { ...oldModels };
+    if (exists) {
+      if (hasExternal) {
+        nextModels[external] = { name: external, ...(oldModels[external] && typeof oldModels[external] === "object" ? oldModels[external] : {}), name: external };
+        effectiveId = external;
+      } else if (hasInternal) {
+        // 仅原名存在：保留原名不强制迁移为 alias，视为 updated（原名兼容）
+        nextModels[internal] = { name: internal, ...(oldModels[internal] && typeof oldModels[internal] === "object" ? oldModels[internal] : {}), name: internal };
+        effectiveId = internal;
+      }
+      action = "updated";
+    } else {
+      nextModels[external] = { name: external };
+      effectiveId = external;
+      action = "inserted";
+    }
+    // 合并 provider：保留 name/npm，覆盖 options.baseURL/apiKey，合并 models
+    const nextProvider = {
+      ...oldProvider,
+      name: oldProvider.name || "mslxdff",
+      npm: oldProvider.npm || "@ai-sdk/openai-compatible",
+      options: {
+        ...(oldProvider.options && typeof oldProvider.options === "object" ? oldProvider.options : {}),
+        baseURL: `http://127.0.0.1:${p}/v1`,
+        apiKey: cleanToken,
+      },
+      models: nextModels,
+    };
+    // 若插入的是 alias 但原名已存在，上面已处理为不新增；否则正常
+    data.provider.mslxdff = nextProvider;
+    // 若是新插入且 external 不等于 internal，且 internal 已存在时，需避免双键，上面已处理
+    // 若是新插入 external 且 internal 不存在，正常插入
+    if (!exists) {
+      data.provider.mslxdff.models = nextModels;
+    }
+  } else {
+    data.provider.mslxdff = buildOpencodeProvider({ id: external, token: cleanToken, port: p });
+    action = "inserted";
+  }
+
+  // 原子写
+  mkdirSync(dirname(targetFile), { recursive: true });
+  const tmp = `${targetFile}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+  try {
+    renameSync(tmp, targetFile);
+  } catch {
+    try {
+      writeFileSync(targetFile, readFileSync(tmp, "utf8"), "utf8");
+    } catch {}
+  }
+  try {
+    if (existsSync(tmp)) {
+      const { unlinkSync } = await import("node:fs");
+      unlinkSync(tmp);
+    }
+  } catch {}
+
+  return { action, file: targetFile, id: effectiveId, alias: external, internal, corrupted };
+}

package/src/sync-workbuddy.js

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from "node:fs";
 import { dirname, join } from "node:path";
 import os from "node:os";
+import { loadModelAliases, registerModelAlias, persistModelAliases } from "./providers/model-id.js";
 
 export function workbuddyModelsPath() {
   const env = process.env.WORKBUDDY_MODELS_FILE || process.env.WORKBUDDY_MODELS_PATH;
@@ -8,11 +9,17 @@ export function workbuddyModelsPath() {
   return join(os.homedir(), ".workbuddy", "models.json");
 }
 
+// WorkBuddy 不支持模型 ID 中的 /，写入时替换为 -
+// mslxdff 需保留原始 / 格式用于路由，所以同时存原始 id
+const toWorkbuddyId = (id) => String(id).replace(/\//g, "-");
+
 export function buildWorkbuddyEntry({ id, token, port }) {
   const p = Number(port) || 8989;
+  const originalId = String(id);
+  const wbId = toWorkbuddyId(originalId);
   return {
-    id: String(id),
-    name: String(id),
+    id: wbId,
+    name: wbId,
     vendor: "Custom",
     url: `http://127.0.0.1:${p}/v1/chat/completions`,
     apiKey: String(token || ""),
@@ -30,8 +37,13 @@ export function isLocalUrl(url) {
 
 function isTargetEntry(m, id) {
   if (!m || typeof m !== "object") return false;
-  if (m.id !== id) return false;
-  return isLocalUrl(m.url);
+  if (!isLocalUrl(m.url)) return false;
+  // 匹配原始 id（/ 格式）和 WorkBuddy id（- 格式）
+  if (m.id === id) return true;
+  if (m.id === toWorkbuddyId(id)) return true;
+  // 兜底：匹配 _mslxdffOriginalId 字段
+  if (m._mslxdffOriginalId === id) return true;
+  return false;
 }
 
 export async function syncToWorkbuddy({ id, token, port, file } = {}) {
@@ -66,11 +78,19 @@ export async function syncToWorkbuddy({ id, token, port, file } = {}) {
 
   // find exact target (id + local url, any port -> will update port)
   let idx = arr.findIndex((m) => isTargetEntry(m, cleanId));
+  const wbId = toWorkbuddyId(cleanId);
   let action;
   if (idx >= 0) {
     // update token/url/name, preserve other fields
     const old = arr[idx];
-    arr[idx] = { ...old, id: cleanId, name: cleanId, url: `http://127.0.0.1:${p}/v1/chat/completions`, apiKey: cleanToken };
+    const { _mslxdffOriginalId, ...oldClean } = old;
+    arr[idx] = {
+      ...oldClean,
+      id: wbId,
+      name: wbId,
+      url: `http://127.0.0.1:${p}/v1/chat/completions`,
+      apiKey: cleanToken,
+    };
     if (!arr[idx].vendor) arr[idx].vendor = "Custom";
     if (arr[idx].supportsToolCall === undefined) arr[idx].supportsToolCall = true;
     if (arr[idx].supportsImages === undefined) arr[idx].supportsImages = true;
@@ -78,7 +98,12 @@ export async function syncToWorkbuddy({ id, token, port, file } = {}) {
     if (arr[idx].useCustomProtocol === undefined) arr[idx].useCustomProtocol = false;
     action = "updated";
   } else {
-    // ensure existence: no reuse, always insert new entry (preserves other local entries like x-preview)
+    // 检查归一化 id 是否与已有条目冲突（如已存在 clinebot-z-ai-glm-5.3-flash 但不是本地 URL）
+    const conflict = arr.findIndex((m) => m && m.id === wbId);
+    if (conflict >= 0) {
+      // 已有同名条目且非我们写的，跳过不覆盖
+      return { action: "skipped-conflict", file: targetFile, id: cleanId, conflictId: arr[conflict].id, corrupted: false };
+    }
     arr.push(buildWorkbuddyEntry({ id: cleanId, token: cleanToken, port: p }));
     action = "inserted";
   }
@@ -100,5 +125,12 @@ export async function syncToWorkbuddy({ id, token, port, file } = {}) {
   // cleanup tmp if still exists
   try { if (existsSync(tmp)) { const { unlinkSync } = await import("node:fs"); unlinkSync(tmp); } } catch {}
 
+  // 注册 WorkBuddy 别名：/ → -（仅原始 id 含 / 时）
+  if (cleanId.includes("/")) {
+    loadModelAliases();
+    registerModelAlias(wbId, cleanId);
+    persistModelAliases();
+  }
+
   return { action, file: targetFile, id: cleanId, corrupted };
 }