mslxdff 0.1.93 → 0.1.94

package/package.json

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

package/src/cli/commands/sync.js

@@ -4,18 +4,65 @@ import { getPreferredModel as getPref } from "../../auto.js";
 import { normalizeModel } from "../../reasoning.js";
 import { syncToWorkbuddy, workbuddyModelsPath } from "../../sync-workbuddy.js";
 import { syncToOpencode, opencodeConfigPath } from "../../sync-opencode.js";
+import { syncToCodex, codexConfigPath } from "../../sync-codex.js";
 import { createModelsService } from "../../models.js";
 import { createUpstreamClient } from "../../upstream.js";
 import { logDir } from "../../logs.js";
 
+// 剪枝口径：picks 非空时，未在 picks 的旧模型视为失效，下次 setto 从第三方配置里摘除；
+// picks 为空（=不筛选）时返回 null，sync 侧一个不动。
+function pruneKeep() {
+  const picks = loadModelPicks();
+  return picks.length ? picks : null;
+}
+
 export async function handleSetto(args) {
   if (!(args.includes("-setto") || args.includes("--setto"))) return false;
   const idx = args.findIndex((x) => x === "-setto" || x === "--setto");
   const target = args[idx + 1];
-  if (!["workbuddy", "opencode"].includes(target)) {
-    console.error("usage: mslxdff -setto workbuddy [modelId] | mslxdff -setto opencode [modelId|--all]");
+  if (!["workbuddy", "opencode", "chatgpt", "codex"].includes(target)) {
+    console.error("usage: mslxdff -setto workbuddy [modelId] | mslxdff -setto opencode [modelId|--all] | mslxdff -setto chatgpt [modelId]");
     process.exit(1);
   }
+  if (target === "chatgpt" || target === "codex") {
+    // Codex/ChatGPT 三端共用 ~/.codex/config.toml：写 model + model_provider + [model_providers.mslxdff]
+    const raw = args[idx + 2] && !String(args[idx + 2]).startsWith("-") ? String(args[idx + 2]).trim() : null;
+    let id;
+    if (raw) {
+      if (raw === "auto" || !raw) {
+        console.error("modelId 不能为 auto 或空");
+        process.exit(1);
+      }
+      const norm = normalizeModel(raw);
+      if (!norm) {
+        console.error("modelId 不能为空");
+        process.exit(1);
+      }
+      savePreferredModel(norm);
+      console.log(`default model set to: ${norm} (daemon hot-reloads on next request)`);
+      id = norm;
+    } else {
+      id = loadPreferredModel() || getPref();
+      if (!id) {
+        console.error("no preferred model set; use: mslxdff -setto chatgpt <modelId>");
+        process.exit(1);
+      }
+    }
+    try {
+      const persisted = getPort();
+      const envPort = Number(process.env.MSLXDFF_PORT);
+      const port = persisted !== null ? persisted : (Number.isInteger(envPort) && envPort > 0 ? envPort : 8989);
+      const file = codexConfigPath();
+      const r = syncToCodex({ id, port, file });
+      console.log(`synced to codex: ${r.action} "${r.id}" @ ${r.file}`);
+      console.log(`  url: http://127.0.0.1:${port}/v1/responses (Responses API)`);
+      console.log(`  鉴权走 mslxdff -showtoken 命令（token 不落盘），直接 codex exec "hi" 验证`);
+    } catch (err) {
+      console.error(`failed to sync to codex: ${String(err?.message || err)}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
   if (target === "opencode") {
     const wantsAll = args.includes("--all") || args.includes("-a") || args[idx + 2] === "all";
     if (wantsAll) {
@@ -31,17 +78,19 @@ export async function handleSetto(args) {
         const envPort = Number(process.env.MSLXDFF_PORT);
         const port = persisted !== null ? persisted : (Number.isInteger(envPort) && envPort > 0 ? envPort : 8989);
         const file = opencodeConfigPath();
-        let inserted = 0, updated = 0;
+        let inserted = 0, updated = 0, prunedTotal = 0;
         for (const rawId of list) {
           const norm = normalizeModel(rawId);
           if (!norm || norm === "auto") continue;
           // 首次循环也同步 preferred（保持 daemon 热重载语义）
           if (rawId === list[0]) savePreferredModel(norm);
-          const r = await syncToOpencode({ id: norm, token, port, file });
+          const r = await syncToOpencode({ id: norm, token, port, file, keep: pruneKeep() });
           if (r.action === "inserted") inserted++; else updated++;
+          prunedTotal += r.pruned || 0;
           console.log(`  ${r.action} "${r.id}" -> ${r.internal} @ ${file}`);
         }
         console.log(`synced to opencode: ${inserted} inserted, ${updated} updated, total ${list.length} @ ${file}`);
+        if (prunedTotal) console.log(`  pruned ${prunedTotal} 个失效模型（未在 picks，不再于 opencode 显示）`);
         console.log(`  url: http://127.0.0.1:${port}/v1`);
         console.log(`  models: ${list.map((x) => normalizeModel(x)).join(", ")}`);
         console.log(`  opencode 选 mslxdff/<model> 直达本地，同名如 mslxdff/deepseek-v4-flash-free 或 mslxdff/bai-deepseek-v4-flash`);
@@ -107,8 +156,9 @@ export async function handleSetto(args) {
       const envPort = Number(process.env.MSLXDFF_PORT);
       const port = persisted !== null ? persisted : (Number.isInteger(envPort) && envPort > 0 ? envPort : 8989);
       const file = opencodeConfigPath();
-      const r = await syncToOpencode({ id, token, port, file });
+      const r = await syncToOpencode({ id, token, port, file, keep: pruneKeep() });
       console.log(`synced to opencode: ${r.action} "${r.id}" @ ${file}`);
+      if (r.pruned) console.log(`  pruned ${r.pruned} 个失效模型（未在 picks，不再于 opencode 显示）`);
       console.log(`  url: http://127.0.0.1:${port}/v1`);
       console.log(`  opencode 选 mslxdff/${r.id} 直达本地 ${r.internal}${r.storageKey !== r.internal ? ` (dash→${r.internal} 自动映射)` : ""}`);
     } catch (err) {
@@ -164,8 +214,9 @@ export async function handleSetto(args) {
     const envPort = Number(process.env.MSLXDFF_PORT);
     const port = persisted !== null ? persisted : (Number.isInteger(envPort) && envPort > 0 ? envPort : 8989);
     const file = workbuddyModelsPath();
-    const r = await syncToWorkbuddy({ id, token, port, file });
+    const r = await syncToWorkbuddy({ id, token, port, file, keep: pruneKeep() });
     console.log(`synced to WorkBuddy: ${r.action} "${id}" @ ${file}`);
+    if (r.pruned) console.log(`  pruned ${r.pruned} 个失效模型（未在 picks，不再于 WorkBuddy 显示）`);
     console.log(`  url: http://127.0.0.1:${port}/v1/chat/completions`);
   } catch (err) {
     console.error(`failed to sync to WorkBuddy: ${String(err?.message || err)}`);

package/src/cli/help.js

@@ -21,6 +21,7 @@ Usage:
   mslxdff -showtoken               print the current auth token
   mslxdff -refresh-token           rotate the auth token (prints the new one)
   mslxdff -setto workbuddy [modelId]  set default model and sync to WorkBuddy models.json (insert or update 127.0.0.1/v1 entry)
+  mslxdff -setto chatgpt [modelId]    set default model and sync to Codex/ChatGPT ~/.codex/config.toml (model_providers.mslxdff → 127.0.0.1/v1/responses, auth via mslxdff -showtoken)
   mslxdff -provider add <id> <baseUrl> <key> [allowedModel...]  add a generic OpenAI-compatible provider (myapi/gpt-4, baseUrl https://api.example.com/v1; extra models = allowlist)
   mslxdff -provider add workbuddy https://copilot.tencent.com <key> [allow...]  add WorkBuddy专用供应商（workbuddy/hy3 前缀路由，auths 与 keys 一一对应）
   mslxdff -provider <id> [key...|add|remove|list|clear|share|set-url]  configure provider API keys/URL (multiple keys = rotating, set-url for generic)

package/src/responses/translate.js

@@ -0,0 +1,220 @@
+/**
+ * Responses ⇄ Chat 翻译层（给 Codex/ChatGPT 桌面端用的 /v1/responses 端点）。
+ * 纯函数，无网络、无副作用。无状态：previous_response_id 不支持（stateless 网关）。
+ */
+let seq = 0;
+export function newResponseId() {
+  return `resp_${Date.now().toString(36)}${(seq++).toString(36)}`;
+}
+
+// 上游块可能是 Buffer/Uint8Array：String() 会变成 "100,97,..." 数字串，必须解码
+const _decoder = new TextDecoder();
+export function chunkToString(c) {
+  if (c == null) return "";
+  if (typeof c === "string") return c;
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(c)) return c.toString("utf8");
+  if (c instanceof Uint8Array) return _decoder.decode(c);
+  return String(c);
+}
+
+function inputTextOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p && (p.type === "input_text" || p.type === "text")).map((p) => p.text || "").join("");
+  }
+  return String(content ?? "");
+}
+
+// POST /v1/responses body → chat completions body（直接喂现有 pipeline）
+export function responsesToChatBody(req = {}) {
+  const model = String(req.model || "").trim();
+  if (!model) throw new Error("responses: 缺少 model");
+  const messages = [];
+  if (req.instructions) messages.push({ role: "system", content: String(req.instructions) });
+  const input = req.input;
+  const items = typeof input === "string" ? [{ type: "message", role: "user", content: input }] : Array.isArray(input) ? input : [];
+  for (const it of items) {
+    if (!it || typeof it !== "object") continue;
+    if (it.type === "message") {
+      messages.push({ role: it.role || "user", content: inputTextOf(it.content) });
+    } else if (it.type === "function_call") {
+      messages.push({
+        role: "assistant", content: "",
+        tool_calls: [{ id: it.call_id || it.id || "", type: "function", function: { name: it.name || "", arguments: it.arguments || "" } }],
+      });
+    } else if (it.type === "function_call_output") {
+      messages.push({ role: "tool", tool_call_id: it.call_id || "", content: typeof it.output === "string" ? it.output : JSON.stringify(it.output ?? "") });
+    }
+  }
+  if (!messages.length) messages.push({ role: "user", content: "hi" });
+  const body = { model, messages, stream: Boolean(req.stream) };
+  if (Array.isArray(req.tools) && req.tools.length) {
+    body.tools = req.tools.map((t) => (t?.type === "function"
+      ? { type: "function", function: { name: t.name, description: t.description || "", parameters: t.parameters || {} } }
+      : t));
+  }
+  if (req.tool_choice) {
+    const tc = req.tool_choice;
+    body.tool_choice = tc?.type === "function" ? { type: "function", function: { name: tc.name } } : tc;
+  }
+  if (req.max_output_tokens != null) body.max_tokens = Number(req.max_output_tokens);
+  if (req.temperature != null) body.temperature = req.temperature;
+  if (req.top_p != null) body.top_p = req.top_p;
+  if (req.parallel_tool_calls != null) body.parallel_tool_calls = req.parallel_tool_calls;
+  return body;
+}
+
+// chat 口径 usage → Responses 口径（codex 解 ResponseCompleted 硬要 input_tokens/output_tokens，缺则整轮作废）
+export function toResponsesUsage(u = {}) {
+  const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+  const src = u && typeof u === "object" ? u : {};
+  const pt = num(src.prompt_tokens ?? src.input_tokens);
+  const ct = num(src.completion_tokens ?? src.output_tokens);
+  return {
+    input_tokens: pt,
+    input_tokens_details: { cached_tokens: num(src.input_tokens_details?.cached_tokens ?? src.prompt_tokens_details?.cached_tokens) },
+    output_tokens: ct,
+    output_tokens_details: { reasoning_tokens: num(src.output_tokens_details?.reasoning_tokens ?? src.completion_tokens_details?.reasoning_tokens) },
+    total_tokens: num(src.total_tokens ?? pt + ct),
+  };
+}
+
+function messageToOutputItems(message = {}) {
+  const out = [];
+  const text = typeof message.content === "string" ? message.content : "";
+  if (text) {
+    out.push({ type: "message", id: `msg_${newResponseId()}`, status: "completed", role: "assistant", content: [{ type: "output_text", text, annotations: [] }] });
+  }
+  for (const tc of message.tool_calls || []) {
+    out.push({ type: "function_call", id: `fc_${newResponseId()}`, call_id: tc.id || "", name: tc.function?.name || "", arguments: tc.function?.arguments || "", status: "completed" });
+  }
+  return out;
+}
+
+// chat JSON → Response 对象（非流式）
+export function chatJsonToResponse(chatJson = {}, model = "") {
+  const choice = chatJson.choices?.[0] || {};
+  const output = messageToOutputItems(choice.message || {});
+  return {
+    id: chatJson.id && String(chatJson.id).startsWith("resp_") ? chatJson.id : newResponseId(),
+    object: "response",
+    created_at: chatJson.created || Math.floor(Date.now() / 1000),
+    status: choice.finish_reason === "length" ? "incomplete" : "completed",
+    model: model || chatJson.model || "",
+    output,
+    usage: toResponsesUsage(chatJson.usage),
+  };
+}
+
+// chat SSE chunk 流 → responses SSE 事件流（逐块翻译，tool_calls 按 index 累积）
+export function createChunkTranslator(model = "") {
+  const id = newResponseId();
+  const createdAt = Math.floor(Date.now() / 1000);
+  let buf = "";
+  let textItemOpen = false;
+  let textLen = 0;
+  let lastFinish = "stop";
+  let lastUsage = null;
+  const tools = new Map(); // index → {id, name, args, announced}
+  const ev = (type, extra = {}) => ({ type, ...extra });
+
+  function begin() {
+    return [ev("response.created", { response: { id, object: "response", created_at: createdAt, status: "in_progress", model, output: [] } })];
+  }
+
+  function ensureTextItem() {
+    if (textItemOpen) return [];
+    textItemOpen = true;
+    const item = { type: "message", id: `msg_${id}`, status: "in_progress", role: "assistant", content: [{ type: "output_text", text: "", annotations: [] }] };
+    return [ev("response.output_item.added", { output_index: 0, item }), ev("response.content_part.added", { item_id: item.id, output_index: 0, content_index: 0, part: { type: "output_text", text: "", annotations: [] } })];
+  }
+
+  let fullText = "";
+  function pushText(delta) {
+    if (!delta) return [];
+    const out = ensureTextItem();
+    textLen += delta.length;
+    fullText += delta;
+    out.push(ev("response.output_text.delta", { item_id: `msg_${id}`, output_index: 0, content_index: 0, delta }));
+    return out;
+  }
+
+  function pushTool(tc) {
+    const idx = Number(tc.index ?? 0);
+    let t = tools.get(idx);
+    if (!t) { t = { id: "", name: "", args: "", announced: false }; tools.set(idx, t); }
+    if (tc.id) t.id = tc.id;
+    if (tc.function?.name) t.name += tc.function.name;
+    const frag = tc.function?.arguments || "";
+    const out = [];
+    if (!t.announced && t.id && t.name) {
+      t.announced = true;
+      out.push(ev("response.output_item.added", { output_index: idx + 1, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: "" } }));
+    }
+    if (frag) {
+      if (!t.announced) { t.args += frag; return out; } // id/name 未到先攒着
+      t.args += frag;
+      out.push(ev("response.function_call_arguments.delta", { item_id: `fc_${id}_${idx}`, output_index: idx + 1, delta: frag }));
+    }
+    return out;
+  }
+
+  const dbg = { chunks: 0, textChars: 0, toolDeltas: 0, skippedLines: 0, jsonFails: 0, reasoningChars: 0 };
+  function push(data) {
+    buf += chunkToString(data);
+    const out = [];
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line || line.startsWith(":")) continue;
+      if (!line.startsWith("data:")) { dbg.skippedLines++; continue; }
+      const payload = line.slice(5).trim();
+      if (payload === "[DONE]") continue;
+      let chunk;
+      try { chunk = JSON.parse(payload); } catch { dbg.jsonFails++; continue; }
+      dbg.chunks++;
+      const delta = chunk.choices?.[0]?.delta || {};
+      const fr = chunk.choices?.[0]?.finish_reason;
+      if (fr) lastFinish = fr;
+      if (chunk.usage) lastUsage = chunk.usage;
+      if (typeof delta.content === "string" && delta.content) { dbg.textChars += delta.content.length; out.push(...pushText(delta.content)); }
+      for (const tc of delta.tool_calls || []) { dbg.toolDeltas++; out.push(...pushTool(tc)); }
+      const rc = typeof delta.reasoning_content === "string" ? delta.reasoning_content : "";
+      if (rc) { dbg.reasoningChars += rc.length; out.push(...pushText(rc)); }
+    }
+    return out;
+  }
+
+  function end({ finish = "stop", usage = null } = {}) {
+    const out = [];
+    if (textItemOpen) {
+      out.push(ev("response.output_text.done", { item_id: `msg_${id}`, output_index: 0, content_index: 0, text: fullText }));
+      out.push(ev("response.content_part.done", { item_id: `msg_${id}`, output_index: 0, content_index: 0, part: { type: "output_text", text: fullText, annotations: [] } }));
+      out.push(ev("response.output_item.done", { output_index: 0, item: { type: "message", id: `msg_${id}`, status: "completed", role: "assistant", content: [{ type: "output_text", text: fullText, annotations: [] }] } }));
+    }
+    let i = 0;
+    for (const [idx, t] of tools) {
+      if (!t.id && !t.name && !t.args) { i++; continue; }
+      if (!t.announced) {
+        out.push(ev("response.output_item.added", { output_index: idx + 1, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: "" } }));
+      }
+      if (t.args) out.push(ev("response.function_call_arguments.done", { item_id: `fc_${id}_${idx}`, output_index: idx + 1, arguments: t.args }));
+      out.push(ev("response.output_item.done", { output_index: idx + 1, item: { type: "function_call", id: `fc_${id}_${idx}`, call_id: t.id, name: t.name, arguments: t.args, status: "completed" } }));
+      i++;
+    }
+    void i; void textLen;
+    out.push(ev("response.completed", { response: { id, object: "response", created_at: createdAt, status: finish === "length" ? "incomplete" : "completed", model, output: [], usage: toResponsesUsage(usage) } }));
+    return out;
+  }
+
+  function getFinal() {
+    return { finish: lastFinish, usage: lastUsage };
+  }
+
+  function stats() {
+    return { ...dbg, outEvents: null, textItemOpen, toolCalls: tools.size };
+  }
+
+  return { id, begin, push, end, getFinal, stats };
+}

package/src/routes/index.js

@@ -6,6 +6,7 @@ import { joinHandler, leaveHandler } from "./groups.js";
 import { heartbeatHandler, pollHandler, resultHandler, forwardHandler, streamHandler } from "./groups-relay.js";
 import { modelsHandler, modelsStatusHandler, providerModelsHandler } from "./models-route.js";
 import { relayHandler } from "./relay.js";
+import { responsesHandler } from "./responses-route.js";
 
 export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus, plugins }) {
   return async function router(req, res) {
@@ -43,6 +44,12 @@ const ROUTES = [
     requiresAuth: true,
     handler: chatHandler,
   },
+  {
+    method: "POST",
+    path: "/v1/responses",
+    requiresAuth: true,
+    handler: responsesHandler,
+  },
   {
     method: "POST",
     path: "/v1/groups/join",

package/src/routes/models-route.js

@@ -2,8 +2,21 @@ import { json, errMsg } from "./helpers.js";
 import { runHook } from "../plugins.js";
 import { isModelAllowed } from "../state.js";
 
-export async function modelsHandler({ res, models, plugins }) {
+// Codex 自定义 provider 拉目录要顶层 `models` 数组（codex-rs endpoint/models.rs 解 ModelsResponse{models}），
+// 给它 OpenAI 标准 {object,data} 会报 missing field `models`。学 OmniRoute：仅 codex 调用者追加空数组
+// （填真目录反而会覆盖 codex 内置 agent prompt，必须空），其他客户端保持字节一致。
+export function isCodexModelsCaller(req) {
+  const h = req?.headers || {};
+  if (/^codex_/i.test(String(h["user-agent"] || ""))) return true;
+  if (/^codex_/i.test(String(h.originator || ""))) return true;
+  const q = String(req?.url || "").split("?")[1] || "";
+  return /(^|&)client_version=/.test(q);
+}
+
+export async function modelsHandler({ req, res, models, plugins }) {
   if (!models) return json(res, 501, { error: "Models service not configured" });
+  const codex = isCodexModelsCaller(req);
+  const withCodex = (out) => (codex && out && typeof out === "object" ? { ...out, models: [] } : out);
   try {
     let data = await models.get();
     // 插件 hook：models:list — 返回数组可替换对外模型列表（{object:"list",data:[...]} 或纯 id 数组）
@@ -15,10 +28,10 @@ export async function modelsHandler({ res, models, plugins }) {
         const out = idsOnly
           ? { object: "list", data: ml.value.map((id) => ({ id, object: "model", owned_by: "plugin" })) }
           : { object: "list", data: ml.value };
-        return json(res, 200, out);
+        return json(res, 200, withCodex(out));
       }
     }
-    json(res, 200, data);
+    json(res, 200, withCodex(data));
   } catch (err) {
     json(res, 502, { error: errMsg(err) });
   }

package/src/routes/responses-route.js

@@ -0,0 +1,162 @@
+import { json, readBody } from "./helpers.js";
+import { createChatPipeline } from "../chat-pipeline/index.js";
+import { responsesToChatBody, chatJsonToResponse, createChunkTranslator, chunkToString } from "../responses/translate.js";
+
+/**
+ * POST /v1/responses — 给 Codex/ChatGPT 桌面端用的 Responses API 薄壳。
+ * 复用 ChatPipeline 全链路（auto/hedge/failover/tool_calls），只做形状翻译。
+ * 非流式：收集 chat JSON → 转 Response 对象；流式：逐块实时翻成 responses SSE。
+ */
+
+function withBody(req, body) {
+  return Object.assign(Object.create(Object.getPrototypeOf(req)), req, { body });
+}
+
+function errorShape(text, status) {
+  let msg = String(text || "").slice(0, 500);
+  try {
+    const j = JSON.parse(String(text || ""));
+    msg = String(j?.error?.message || j?.error || msg);
+  } catch {}
+  return { error: { message: msg || "upstream error", type: "server_error", code: status } };
+}
+
+// 最小事件发射器：pipeline 靠 res.on("close") 感知下游断开，垫片必须有
+function createEmitter() {
+  const map = new Map();
+  const self = {
+    on(ev, fn) { if (typeof fn === "function") { if (!map.has(ev)) map.set(ev, []); map.get(ev).push(fn); } return self; },
+    once(ev, fn) { const w = (...a) => { self.off(ev, w); fn(...a); }; return self.on(ev, w); },
+    off(ev, fn) { const l = map.get(ev); if (l) { const i = l.indexOf(fn); if (i >= 0) l.splice(i, 1); } return self; },
+    removeListener(ev, fn) { return self.off(ev, fn); },
+    emit(ev, ...a) { for (const fn of [...(map.get(ev) || [])]) { try { fn(...a); } catch {} } return true; },
+  };
+  return self;
+}
+
+// 非流式：收集捕获
+export function createCollector() {
+  let status = 200;
+  let text = "";
+  const res = {
+    ...createEmitter(),
+    set statusCode(v) { status = v; },
+    get statusCode() { return status; },
+    headersSent: false,
+    setHeader() {},
+    write(c) { text += chunkToString(c); return true; },
+    end(c) { if (c != null) text += chunkToString(c); res.headersSent = true; },
+  };
+  return { res, get: () => ({ status, text }) };
+}
+
+// 流式：逐 write 实时翻译并转发（head 延迟到首块，避免错误状态码已发送）
+export function createLiveForwarder(realRes, translator) {
+  let status = 200;
+  let headSent = false;
+  let ended = false;
+  const sendHead = () => {
+    if (headSent) return;
+    headSent = true;
+    realRes.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+    for (const e of translator.begin()) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
+  };
+  const res = {
+    ...createEmitter(),
+    set statusCode(v) { status = v; },
+    get statusCode() { return status; },
+    headersSent: false,
+    setHeader() {},
+    write(c) {
+      if (ended) return true;
+      sendHead();
+      for (const e of translator.push(chunkToString(c))) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
+      return true;
+    },
+    end(c) {
+      if (ended) return;
+      ended = true;
+      res.headersSent = true;
+      if (status >= 400 && !headSent) {
+        json(realRes, status, errorShape(c, status));
+        return;
+      }
+      sendHead();
+      if (c != null) for (const e of translator.push(chunkToString(c))) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
+      const fin = translator.getFinal();
+      for (const e of translator.end({ finish: fin.finish, usage: fin.usage })) realRes.write(`data: ${JSON.stringify(e)}\n\n`);
+      realRes.write("data: [DONE]\n\n");
+      try { realRes.end(); } catch {}
+    },
+  };
+  return res;
+}
+
+const RDEBUG = process.env.MSLXDFF_RESPONSES_DEBUG === "1";
+function rlog(...a) {
+  if (RDEBUG) console.log("[responses]", ...a);
+}
+
+export async function responsesHandler(ctx) {
+  const { req, res } = ctx;
+  const t0 = Date.now();
+  let body;
+  try {
+    body = await readBody(req);
+  } catch {
+    return json(res, 400, { error: { message: "Invalid JSON body" } });
+  }
+  rlog("req", JSON.stringify({
+    model: body?.model, stream: body?.stream,
+    inputType: typeof body?.input, inputLen: Array.isArray(body?.input) ? body.input.length : String(body?.input || "").length,
+    inputKinds: Array.isArray(body?.input) ? [...new Set(body.input.map((i) => i?.type))] : null,
+    tools: Array.isArray(body?.tools) ? body.tools.length : 0,
+    instructionsLen: String(body?.instructions || "").length,
+  }));
+  let chatBody;
+  try {
+    chatBody = responsesToChatBody(body);
+  } catch (e) {
+    rlog("translate-req-400", String(e?.message || e));
+    return json(res, 400, { error: { message: String(e?.message || e) } });
+  }
+  rlog("chat", JSON.stringify({ model: chatBody.model, stream: chatBody.stream, msgs: chatBody.messages.map((m) => `${m.role}:${String(m.content || "").length}${m.tool_calls ? `+${m.tool_calls.length}tc` : ""}`) }));
+  const pipeline = createChatPipeline(ctx);
+  const fakeReq = withBody(req, chatBody);
+  // 真连接断开 → 透传给垫片，pipeline 的 abort 链路不断
+  const forwardClose = (shim) => { try { req.on?.("close", () => shim.emit("close")); } catch {} };
+  try {
+    if (chatBody.stream) {
+      const translator = createChunkTranslator(chatBody.model);
+      const live = createLiveForwarder(res, translator);
+      forwardClose(live);
+      await pipeline.execute({ req: fakeReq, res: live });
+      const st = translator.stats();
+      rlog("done-stream", JSON.stringify({ ms: Date.now() - t0, model: chatBody.model, ...st, finish: translator.getFinal().finish, usage: translator.getFinal().usage }));
+    } else {
+      const cap = createCollector();
+      forwardClose(cap.res);
+      await pipeline.execute({ req: fakeReq, res: cap.res });
+      const { status, text } = cap.get();
+      rlog("done-json", JSON.stringify({ ms: Date.now() - t0, model: chatBody.model, status, bytes: text.length, head: text.slice(0, 160) }));
+      if (status >= 400) return json(res, status, errorShape(text, status));
+      let chatJson = null;
+      try { chatJson = JSON.parse(text); } catch {}
+      if (!chatJson || chatJson.object === "error" || chatJson.error) {
+        rlog("translate-resp-502", text.slice(0, 300));
+        return json(res, status >= 400 ? status : 502, errorShape(text, status));
+      }
+      const respObj = chatJsonToResponse(chatJson, chatBody.model);
+      rlog("done-resp", JSON.stringify({ ms: Date.now() - t0, model: chatBody.model, status: respObj.status, items: respObj.output.length, textLen: JSON.stringify(respObj.output).length, usage: respObj.usage }));
+      // 非 JSON 透传（上游偶发）：包成纯文本 Response
+      if (!chatJson.choices) {
+        return json(res, 200, { id: chatJson.id || `resp_${Date.now()}`, object: "response", created_at: Math.floor(Date.now() / 1000), status: "completed", model: chatBody.model, output: [{ type: "message", role: "assistant", content: [{ type: "output_text", text: String(text).slice(0, 8000) }] }], usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } });
+      }
+      return json(res, 200, respObj);
+    }
+  } catch (err) {
+    rlog("execute-throw", String(err?.message || err).slice(0, 300));
+    if (!res.headersSent) return json(res, 502, { error: { message: String(err?.message || err).slice(0, 500) } });
+    try { res.end(); } catch {}
+  }
+}

package/src/sync-codex.js

@@ -0,0 +1,116 @@
+import { readFileSync, writeFileSync, mkdirSync, renameSync, existsSync, unlinkSync } from "node:fs";
+import { dirname, join, resolve, isAbsolute } from "node:path";
+import os from "node:os";
+
+// TOML 字符串：含反斜杠（Windows 路径）时用字面单引号，避免转义被吃
+function tomlStr(s) {
+  const v = String(s);
+  if (v.includes("\\") && !v.includes("'")) return `'${v}'`;
+  return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+// auth 命令解析：Codex 起子进程不保证继承终端 PATH，所以不用裸 `mslxdff`，
+// 而用绝对路径 node + 绝对路径脚本（当前进程即 mslxdff 本体，最可信）。
+export function buildAuthCommand({ execPath = process.execPath, argv1 = process.argv[1], cwd = process.cwd() } = {}) {
+  const script = argv1 ? (isAbsolute(argv1) ? argv1 : resolve(cwd, argv1)) : "";
+  if (execPath && script && /mslxdff(\.js)?$/i.test(script)) {
+    try { if (existsSync(script)) return { command: execPath, args: [script, "-showtoken"] }; } catch {}
+  }
+  return { command: "mslxdff", args: ["-showtoken"] }; // 兜底：走 PATH
+}
+
+// Codex/ChatGPT 三端共用 ~/.codex/config.toml：自定义 provider 指向本地网关。
+export function codexConfigPath() {
+  const home = process.env.CODEX_HOME;
+  if (typeof home === "string" && home.trim()) return join(home.trim(), "config.toml");
+  return join(os.homedir(), ".codex", "config.toml");
+}
+
+// 顶层 key = "value" 行：有则替换，无则追加
+function upsertTopKey(lines, key, value) {
+  const re = new RegExp(`^\\s*${key}\\s*=`);
+  const line = `${key} = "${value}"`;
+  const idx = lines.findIndex((l) => re.test(l) && !l.trim().startsWith("#"));
+  if (idx >= 0) {
+    if (lines[idx].trim() === line) return { lines, changed: false };
+    lines[idx] = line;
+    return { lines, changed: true };
+  }
+  // 插到首个 [section] 之前（顶层区），无 section 则末尾追加
+  const secIdx = lines.findIndex((l) => /^\s*\[/.test(l));
+  if (secIdx >= 0) lines.splice(secIdx, 0, line);
+  else { if (lines.length && lines[lines.length - 1].trim()) lines.push(""); lines.push(line); }
+  return { lines, changed: true };
+}
+
+// [model_providers.mslxdff] 整段替换（段从表头到下个 ^[ 或 EOF），无则追加
+function upsertProviderSection(lines, section) {
+  const head = "[model_providers.mslxdff]";
+  const authHead = "[model_providers.mslxdff.auth]";
+  let start = lines.findIndex((l) => l.trim() === head);
+  const main = [head, ...section.main];
+  const auth = ["[model_providers.mslxdff.auth]", ...section.auth];
+  const full = [...main, "", ...auth];
+  if (start >= 0) {
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+      const t = lines[i].trim();
+      // 自家子段（[model_providers.mslxdff.*]）不算边界，一并替换
+      if (/^\s*\[/.test(lines[i]) && !t.startsWith("[model_providers.mslxdff.")) { end = i; break; }
+    }
+    const old = lines.slice(start, end).join("\n").trim();
+    if (old === full.join("\n").trim()) return { lines, changed: false };
+    lines.splice(start, end - start, ...full);
+    return { lines, changed: true };
+  }
+  if (lines.length && lines[lines.length - 1].trim()) lines.push("");
+  lines.push(...full);
+  return { lines, changed: true };
+}
+
+export function buildCodexProvider({ port, auth } = {}) {
+  const p = Number(port) || 8989;
+  const a = auth || buildAuthCommand();
+  return {
+    main: [
+      'name = "mslxdff local gateway"',
+      `base_url = "http://127.0.0.1:${p}/v1"`,
+      'wire_api = "responses"', // 显式锁定：现行 Codex 自定义 provider 只认 Responses
+    ],
+    // command-backed auth：调 mslxdff -showtoken 取 Bearer，token 永不落盘
+    auth: [
+      `command = ${tomlStr(a.command)}`,
+      `args = [${a.args.map(tomlStr).join(", ")}]`,
+      "timeout_ms = 5000",
+      "refresh_interval_ms = 300000",
+    ],
+  };
+}
+
+export function syncToCodex({ id, port, file, auth } = {}) {
+  const targetFile = file || codexConfigPath();
+  const model = String(id || "").trim();
+  if (!model) throw new Error("model id required");
+  let text = "";
+  try { text = readFileSync(targetFile, "utf8"); } catch { text = ""; }
+  const lines = text ? text.split("\n") : [];
+  let changed = false;
+  let r = upsertTopKey(lines, "model", model);
+  changed = changed || r.changed;
+  r = upsertTopKey(r.lines, "model_provider", "mslxdff");
+  changed = changed || r.changed;
+  r = upsertProviderSection(r.lines, buildCodexProvider({ port, auth }));
+  changed = changed || r.changed;
+  const next = r.lines.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "") + "\n";
+  if (!changed && text === next) return { action: "updated", file: targetFile, id: model };
+  mkdirSync(dirname(targetFile), { recursive: true });
+  const tmp = `${targetFile}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  writeFileSync(tmp, next, "utf8");
+  try {
+    renameSync(tmp, targetFile);
+  } catch {
+    try { writeFileSync(targetFile, next, "utf8"); } catch {}
+  }
+  try { if (existsSync(tmp)) unlinkSync(tmp); } catch {}
+  return { action: text ? "updated" : "inserted", file: targetFile, id: model };
+}

package/src/sync-opencode.js

@@ -30,6 +30,12 @@ export function toStorageKey(canonical) {
   return internal.includes("/") ? internal.replace(/\//g, "-") : internal;
 }
 
+// 剪枝比较键：legacy 前缀剥掉 + / → -（picks 里 slash 形态与存储 dash 形态互认）
+export function normalizeOpencodeKey(k) {
+  const inner = toInternalId(String(k || ""));
+  return inner.includes("/") ? inner.replace(/\//g, "-") : inner;
+}
+
 // 从存储键还原为内部 canonical（需查 alias 表，调用方用 getModelAlias）
 export function storageKeyToCanonical(storageKey) {
   const s = String(storageKey || "").trim();
@@ -61,7 +67,18 @@ export function isOpencodeLocalUrl(url) {
   return u.includes("127.0.0.1") && u.includes("/v1");
 }
 
-export async function syncToOpencode({ id, token, port, file } = {}) {
+// 剪枝：删掉不在 keep（picks 口径）里的旧模型键。keep 为空/非数组时不动（向后兼容）。
+export function pruneOpencodeModels(models, keep, currentKey) {
+  if (!Array.isArray(keep) || !keep.length || !models || typeof models !== "object") return 0;
+  const keepSet = new Set([normalizeOpencodeKey(currentKey), ...keep.map(normalizeOpencodeKey)].filter(Boolean));
+  let pruned = 0;
+  for (const k of Object.keys(models)) {
+    if (!keepSet.has(normalizeOpencodeKey(k))) { delete models[k]; pruned++; }
+  }
+  return pruned;
+}
+
+export async function syncToOpencode({ id, token, port, file, keep } = {}) {
   const targetFile = file || opencodeConfigPath();
   const normalizedRaw = String(id || "").trim();
   if (!normalizedRaw) throw new Error("model id required");
@@ -101,15 +118,13 @@ export async function syncToOpencode({ id, token, port, file } = {}) {
 
   let action;
   let effectiveId = storageKey;
+  let pruned = 0;
   if (oldProvider) {
     const oldModels = oldProvider.models && typeof oldProvider.models === "object" && !Array.isArray(oldProvider.models)
       ? oldProvider.models
       : {};
     // 归一所有旧 key 到 storageKey 维度，判断是否已存在（兼容 mslxdff- 前缀与 / 形态）
-    const normalizeToStorage = (k) => {
-      const inner = toInternalId(String(k));
-      return inner.includes("/") ? inner.replace(/\//g, "-") : inner;
-    };
+    const normalizeToStorage = normalizeOpencodeKey;
     let existingKey = null;
     for (const k of Object.keys(oldModels)) {
       if (normalizeToStorage(k) === storageKey) { existingKey = k; break; }
@@ -143,6 +158,7 @@ export async function syncToOpencode({ id, token, port, file } = {}) {
       effectiveId = storageKey;
       action = "inserted";
     }
+    pruned = pruneOpencodeModels(nextModels, keep, storageKey);
     const nextProvider = {
       ...oldProvider,
       name: oldProvider.name || "mslxdff",
@@ -192,5 +208,5 @@ export async function syncToOpencode({ id, token, port, file } = {}) {
     }
   } catch {}
 
-  return { action, file: targetFile, id: effectiveId, alias: storageKey, internal, corrupted, storageKey };
+  return { action, file: targetFile, id: effectiveId, alias: storageKey, internal, corrupted, storageKey, pruned };
 }

package/src/sync-workbuddy.js

@@ -13,6 +13,27 @@ export function workbuddyModelsPath() {
 // mslxdff 需保留原始 / 格式用于路由，所以同时存原始 id
 const toWorkbuddyId = (id) => String(id).replace(/\//g, "-");
 
+// 剪枝比较键：legacy 前缀剥掉 + / → -（picks 里 slash 形态与存储 dash 形态互认）
+export function normalizeWorkbuddyKey(k) {
+  const s = String(k || "");
+  const inner = s.startsWith("mslxdff-") ? s.slice("mslxdff-".length) : s;
+  return inner.includes("/") ? inner.replace(/\//g, "-") : inner;
+}
+
+// 剪枝：只删我们写的本地条目（127.0.0.1）中不在 keep 里的；非本地条目永不动
+export function pruneWorkbuddyEntries(arr, keep, currentId) {
+  if (!Array.isArray(keep) || !keep.length || !Array.isArray(arr)) return 0;
+  const keepSet = new Set([normalizeWorkbuddyKey(currentId), ...keep.map(normalizeWorkbuddyKey)].filter(Boolean));
+  let pruned = 0;
+  for (let i = arr.length - 1; i >= 0; i--) {
+    const m = arr[i];
+    if (!isLocalUrl(m?.url)) continue;
+    const keys = [normalizeWorkbuddyKey(m.id), normalizeWorkbuddyKey(m._mslxdffOriginalId)];
+    if (!keys.some((k) => k && keepSet.has(k))) { arr.splice(i, 1); pruned++; }
+  }
+  return pruned;
+}
+
 export function buildWorkbuddyEntry({ id, token, port }) {
   const p = Number(port) || 8989;
   const originalId = String(id);
@@ -46,7 +67,7 @@ function isTargetEntry(m, id) {
   return false;
 }
 
-export async function syncToWorkbuddy({ id, token, port, file } = {}) {
+export async function syncToWorkbuddy({ id, token, port, file, keep } = {}) {
   const targetFile = file || workbuddyModelsPath();
   const cleanId = String(id || "").trim();
   if (!cleanId) throw new Error("model id required");
@@ -107,6 +128,7 @@ export async function syncToWorkbuddy({ id, token, port, file } = {}) {
     arr.push(buildWorkbuddyEntry({ id: cleanId, token: cleanToken, port: p }));
     action = "inserted";
   }
+  const pruned = pruneWorkbuddyEntries(arr, keep, cleanId);
 
   // atomic write
   mkdirSync(dirname(targetFile), { recursive: true });
@@ -132,5 +154,5 @@ export async function syncToWorkbuddy({ id, token, port, file } = {}) {
     persistModelAliases();
   }
 
-  return { action, file: targetFile, id: cleanId, corrupted };
+  return { action, file: targetFile, id: cleanId, corrupted, pruned };
 }