mslxdff 0.1.89 → 0.1.91

package/src/runtime/group-sync.js

@@ -0,0 +1,28 @@
+import { groupSyncIntervalMs } from "../cli/policy.js";
+import { errMsg } from "../cli/util.js";
+
+/**
+ * 群组成员同步 — 首拉 + 定时器（fire-and-forget，原语义）。
+ */
+export async function startGroupSync({ peers, groups }) {
+  const { syncAllJoinedGroups } = await import("../cli/group-helpers.js");
+  syncAllJoinedGroups({ peers, groups })
+    .then((results) => {
+      for (const r of results) {
+        if (r.error) console.log(`group sync ${r.name}: failed — ${r.error}`);
+        else console.log(`group sync ${r.name}: ${r.total} member(s), ${r.added} peer(s)`);
+      }
+    })
+    .catch((err) => console.log(`group sync: ${errMsg(err)}`));
+  const groupSyncTimer = setInterval(() => {
+    syncAllJoinedGroups({ peers, groups })
+      .then((results) => {
+        for (const r of results) {
+          if (r.error) console.log(`group sync ${r.name}: failed — ${r.error}`);
+          else if (r.added) console.log(`group sync ${r.name}: ${r.total} member(s), ${r.added} peer(s)`);
+        }
+      })
+      .catch((err) => console.log(`group sync: ${errMsg(err)}`));
+  }, groupSyncIntervalMs());
+  groupSyncTimer.unref();
+}

package/src/runtime/providers-setup.js

@@ -0,0 +1,147 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defaultStateFile, loadToken } from "../state.js";
+import { createUpstreamClient } from "../upstream.js";
+import { createModelsService } from "../models.js";
+import { createAutoSelector } from "../auto.js";
+import { createPeersService } from "../peers.js";
+import { createGroupsService, createBansService } from "../groups.js";
+import { logDir, appendEvent } from "../logs.js";
+import { loadPlugins, runHook, resolvePluginDirs } from "../plugins.js";
+import { createOpenCodeProvider } from "../providers/opencode.js";
+import { loadProviderKeys, loadProviderAuths, loadProviderConfigs } from "../state.js";
+import { refreshIntervalMs, modelCooldownMs, slowCooldownMs, peerCooldownMs, peerHeatMs, banWindowMs, banThreshold } from "../cli/policy.js";
+import { errMsg } from "../cli/util.js";
+
+/**
+ * 世界组装 — 插件加载 → providers → models/auto/peers/groups/bans。
+ * 无参（读 env/state 自身），返回 ctx 由门面接力 server-lifecycle。
+ */
+export async function setupProviders() {
+  const { token, created } = await loadToken();
+  const pkgRoot2 = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+  const pluginDirs = resolvePluginDirs({ pkgRoot: pkgRoot2 });
+  const { plugins: loadedPlugins, errors: pluginErrors } = await loadPlugins({ dirs: pluginDirs });
+  for (const e of pluginErrors) {
+    console.log(`plugin load failed: ${e.file} — ${e.error}`);
+    appendEvent({ ts: Date.now(), type: "plugin-load-error", file: e.file, error: e.error });
+  }
+  if (loadedPlugins.length) {
+    console.log(`plugins loaded (${loadedPlugins.length}): ${loadedPlugins.map((p) => `${p.name}${p.version ? `@${p.version}` : ""}`).join(", ")}`);
+    appendEvent({ ts: Date.now(), type: "plugins-loaded", plugins: loadedPlugins.map((p) => ({ name: p.name, version: p.version })) });
+  }
+  const upstreamHooks = loadedPlugins.length
+    ? (name, ctx) => runHook(loadedPlugins, name, ctx)
+    : null;
+  const providerPlugin = loadedPlugins.find((p) => typeof p.createUpstream === "function");
+  let upstream;
+  const baseUrl = process.env.UPSTREAM_BASE_URL || "https://opencode.ai";
+  let providers = [];
+  if (providerPlugin) {
+    if (!upstream) {
+      try {
+        upstream = await providerPlugin.createUpstream({ baseUrl, authToken: process.env.UPSTREAM_AUTH_TOKEN || "public", env: process.env });
+        console.log(`upstream provider replaced by plugin: ${providerPlugin.name}`);
+        appendEvent({ ts: Date.now(), type: "plugin-upstream-active", plugin: providerPlugin.name });
+      } catch (err) {
+        console.log(`plugin upstream (${providerPlugin.name}) failed: ${errMsg(err)} — falling back to default`);
+        appendEvent({ ts: Date.now(), type: "plugin-upstream-error", plugin: providerPlugin.name, error: errMsg(err) });
+      }
+    }
+    if (!upstream) upstream = createUpstreamClient({ hooks: upstreamHooks });
+  } else {
+    const opencodeClient = createUpstreamClient({ hooks: upstreamHooks });
+    const opencodeModels = createModelsService({
+      baseUrl,
+      headers: opencodeClient.headers,
+      refreshMs: refreshIntervalMs(),
+      cacheFile: join(logDir(), "models.json"),
+    });
+    providers.push(createOpenCodeProvider({ upstream: opencodeClient, modelsService: opencodeModels }));
+    const orKeys = loadProviderKeys("openrouter");
+    if (orKeys.length) {
+      const { createOpenRouterProvider } = await import("../providers/openrouter.js");
+      providers.push(createOpenRouterProvider({ apiKeys: orKeys }));
+      console.log(`provider enabled: openrouter (${orKeys.length} key${orKeys.length > 1 ? "s" : ""})`);
+      appendEvent({ ts: Date.now(), type: "provider-enabled", provider: "openrouter", keys: orKeys.length });
+    }
+    const genericConfigs = loadProviderConfigs();
+    for (const [gid, cfg] of Object.entries(genericConfigs)) {
+      if (gid === "opencode" || gid === "openrouter") continue;
+      const base = String(cfg?.baseUrl || "").trim();
+      const keys = Array.isArray(cfg?.keys) ? cfg.keys.filter((k) => typeof k === "string" && k.trim()) : [];
+      const auths = Array.isArray(cfg?.auths) ? cfg.auths : [];
+      // 可扩展：优先走注册表定制 provider（如 workbuddy、cline），新增供应商仅需在 registry.js 注册
+      const { getCustomProviderFactory } = await import("../providers/registry.js");
+      const customFactory = await getCustomProviderFactory(gid, base);
+      if (customFactory) {
+        if (gid === "workbuddy" && !keys.length) continue;
+        if (gid !== "workbuddy" && (!base || !keys.length)) continue;
+        try {
+          const provider = gid === "workbuddy"
+            ? await customFactory({ baseUrl: base || "https://copilot.tencent.com", apiKeys: keys, auths })
+            : await customFactory({ id: gid, baseUrl: base, apiKeys: keys });
+          providers.push(provider);
+          console.log(`provider enabled: ${gid} (${keys.length} key${keys.length > 1 ? "s" : ""}) baseUrl=${base || provider.baseUrl} [custom]`);
+          appendEvent({ ts: Date.now(), type: "provider-enabled", provider: gid, keys: keys.length, baseUrl: base || provider.baseUrl });
+        } catch (err) {
+          console.log(`provider ${gid} failed: ${err?.message || err}`);
+          appendEvent({ ts: Date.now(), type: "provider-error", provider: gid, error: String(err?.message || err) });
+        }
+        continue;
+      }
+      if (!base || !keys.length) continue;
+      try {
+        const { createGenericProvider } = await import("../providers/generic.js");
+        providers.push(createGenericProvider({ id: gid, baseUrl: base, apiKeys: keys }));
+        console.log(`provider enabled: ${gid} (${keys.length} key${keys.length > 1 ? "s" : ""}) baseUrl=${base}`);
+        appendEvent({ ts: Date.now(), type: "provider-enabled", provider: gid, keys: keys.length, baseUrl: base });
+      } catch (err) {
+        console.log(`provider ${gid} failed: ${err?.message || err}`);
+        appendEvent({ ts: Date.now(), type: "provider-error", provider: gid, error: String(err?.message || err) });
+      }
+    }
+    if (!genericConfigs["workbuddy"]) {
+      const wbKeys = loadProviderKeys("workbuddy");
+      if (wbKeys.length) {
+        try {
+          const { createWorkbuddyProvider } = await import("../providers/workbuddy.js");
+          const wbAuths = loadProviderAuths("workbuddy");
+          providers.push(createWorkbuddyProvider({ apiKeys: wbKeys, auths: wbAuths }));
+          console.log(`provider enabled: workbuddy (${wbKeys.length} key${wbKeys.length > 1 ? "s" : ""}) baseUrl=https://copilot.tencent.com (env)`);
+          appendEvent({ ts: Date.now(), type: "provider-enabled", provider: "workbuddy", keys: wbKeys.length, baseUrl: "https://copilot.tencent.com" });
+        } catch (err) {
+          console.log(`provider workbuddy failed: ${err?.message || err}`);
+        }
+      }
+    }
+    const { createProviderDispatcher } = await import("../providers/dispatcher.js");
+    upstream = createProviderDispatcher(providers);
+    appendEvent({ ts: Date.now(), type: "providers", providers: providers.map((p) => p.id) });
+  }
+  const opencodeProvider = providers.find((p) => p.id === "opencode");
+  const models = createModelsService({
+    providers: providers.length > 1 ? providers : undefined,
+    baseUrl,
+    headers: upstream.headers || opencodeProvider?.upstream?.headers,
+    refreshMs: refreshIntervalMs(),
+    cacheFile: join(logDir(), "models.json"),
+  });
+  const auto = createAutoSelector({
+    cooldownMs: modelCooldownMs(),
+    slowCooldownMs: slowCooldownMs(),
+    file: defaultStateFile(),
+    loadCandidates: async () => {
+      try {
+        return (await models.get()).data.map((m) => m.id);
+      } catch {
+        return null;
+      }
+    },
+  });
+  const peers = createPeersService({ cooldownMs: peerCooldownMs(), heatMs: peerHeatMs() });
+  const groups = createGroupsService({});
+  const bans = createBansService({ windowMs: banWindowMs(), threshold: banThreshold() });
+
+  return { token, created, loadedPlugins, upstreamHooks, providerPlugin, upstream, providers, baseUrl, opencodeProvider, models, auto, peers, groups, bans };
+}

package/src/runtime/server-lifecycle.js

@@ -0,0 +1,156 @@
+import { startServer, resolvePort } from "../server.js";
+import { createRouter } from "../routes.js";
+import { createEventBus } from "../events.js";
+import { runHook } from "../plugins.js";
+import { effectiveHost, maxHopsValue } from "../cli/policy.js";
+import { fmtEvent } from "../cli/format.js";
+import { writePid } from "../daemon.js";
+
+/**
+ * 服务生命周期 — router 装配 → server 创建/ready-EADDRINUSE 自愈 →
+ * plugin 事件 → preheat → pid/监听日志 → autostart。返回 { srv, bus, router }。
+ */
+export async function startServerLifecycle({ VERSION, token, created, upstream, models, auto, peers, groups, bans, loadedPlugins, baseUrl, logs }) {
+  const bus = createEventBus();
+
+  try {
+    const { loadModelAliases } = await import("../providers/model-id.js");
+    loadModelAliases();
+  } catch {}
+
+  const router = createRouter({ token, upstream, models, auto, logs, peers, maxHops: maxHopsValue(), groups, bans, bus, plugins: loadedPlugins });
+  const listenHost = effectiveHost();
+  const isDebug = process.env.MSLXDFF_DEBUG === "1";
+  const srv = startServer({
+    router,
+    signals: !isDebug,
+    host: listenHost,
+    onBeforeClose: loadedPlugins.length
+      ? () => runHook(loadedPlugins, "server:stop", { version: VERSION }).then(() => {})
+      : undefined,
+  });
+
+  if (isDebug) {
+    bus.subscribe((e) => {
+      try {
+        console.log(fmtEvent(e));
+      } catch {}
+    });
+    const { startDaemon: sd } = await import("../daemon.js");
+    const restore2 = () => {
+      console.log("\n[debug] restoring background daemon...");
+      try {
+        const restoredPid = sd([]);
+        console.log(`[debug] daemon restored (pid ${restoredPid})`);
+      } catch (err) {
+        console.error(`[debug] could not restore daemon: ${err.message}`);
+      }
+      setTimeout(() => process.exit(0), 300);
+    };
+    process.on("SIGINT", restore2);
+    process.on("SIGTERM", restore2);
+  }
+
+  // Robust ready: if EADDRINUSE (bare daemon still holds port), kill holders and retry once
+  try {
+    await srv.ready();
+  } catch (err) {
+    const msg = String(err?.message || err);
+    const code = err?.code || "";
+    if (code === "EADDRINUSE" || msg.includes("EADDRINUSE")) {
+      console.log(`port ${resolvePort()} in use — freeing stale holder and retrying...`);
+      try {
+        const { execFile } = await import("node:child_process");
+        const execAsync2 = (f, a) => new Promise((res) => execFile(f, a, { windowsHide: true, timeout: 4000 }, (e, so, se) => res({ e, so: String(so||""), se: String(se||"") })));
+        const port = resolvePort();
+        // kill via ss parse (same as autostart)
+        const ss1 = await execAsync2("ss", ["-lptn", `sport = :${port}`]);
+        const out = ss1.so || "";
+        const pids = new Set();
+        let m;
+        const re = /pid=(\d+)/g;
+        while ((m = re.exec(out))) pids.add(Number(m[1]));
+        if (!pids.size) {
+          const ss2 = await execAsync2("ss", ["-lptn"]);
+          for (const line of (ss2.so||"").split("\n")) {
+            if (!line.includes(`:${port}`)) continue;
+            let m2; const re2 = /pid=(\d+)/g;
+            while ((m2 = re2.exec(line))) pids.add(Number(m2[1]));
+          }
+        }
+        for (const p of pids) { if (p !== process.pid) try { process.kill(p, "SIGTERM"); } catch {} }
+        if (pids.size) await new Promise((r2) => setTimeout(r2, 600));
+        for (const p of pids) try { const { isPidAlive } = await import("../daemon.js"); if (isPidAlive(p)) process.kill(p, "SIGKILL"); } catch {}
+        try { await execAsync2("fuser", ["-k", `${port}/tcp`]); } catch {}
+        for (let i=0;i<10;i++) {
+          const chk = await execAsync2("ss", ["-ltn"]);
+          if (!chk.so.includes(`:${port}`)) break;
+          await new Promise((r2)=>setTimeout(r2,200));
+        }
+      } catch {}
+      await srv.ready();
+    } else throw err;
+  }
+
+  if (loadedPlugins.length) {
+    runHook(loadedPlugins, "server:start", { port: srv.server.address()?.port, host: listenHost, version: VERSION }).catch(() => {});
+    const eventPlugins = loadedPlugins.filter((p) => typeof p.onEvent === "function");
+    if (eventPlugins.length) {
+      bus.subscribe((e) => {
+        for (const p of eventPlugins) {
+          try { p.onEvent(e); } catch {}
+        }
+      });
+    }
+  }
+
+  setTimeout(() => {
+    upstream.preheat().then((r) => {
+      const entry = { ts: Date.now(), type: "upstream-preheat", ...r, baseUrl };
+      try { bus.emit(entry); } catch {}
+      try { logs.appendEvent(entry); } catch {}
+      if (r.skipped) console.log(`[preheat] skipped (MSLXDFF_PREHEAT disabled)`);
+      else if (r.ok) console.log(`[preheat] opencode models ok ${r.status} ${r.ms}ms`);
+      else console.log(`[preheat] opencode models failed ${r.error || r.status || ""} ${r.ms || 0}ms`);
+    }).catch(() => {});
+  }, 100).unref?.();
+
+  models.startAutoRefresh();
+  if (process.env.MSLXDFF_DAEMON) {
+    writePid(process.pid, VERSION);
+  }
+  const addr = srv.server.address();
+  const host = addr.address === "0.0.0.0" || addr.address === "::" ? "localhost" : addr.address;
+  console.log(`mslxdff v${VERSION} listening on http://${host}:${addr.port}`);
+  if (created) {
+    console.log(`auth token: ${token}`);
+  }
+  console.log(`endpoint:   http://${host}:${addr.port}/v1`);
+  try {
+    const { hedgeDelayMs } = await import("../routes/hedge.js");
+    const hd = hedgeDelayMs();
+    console.log(`hedge:      ${hd ? `${hd}ms` : "off"} (MSLXDFF_HEDGE_DELAY_MS)`);
+  } catch {}
+
+  // best-effort: ensure autostart on Linux (so daemon survives reboot/SSH disconnect without manual cmd)
+  if (process.platform === "linux" && !process.env.MSLXDFF_NO_AUTOSTART) {
+    setTimeout(async () => {
+      try {
+        const { getAutostartStatus, enableAutostart } = await import("../autostart.js");
+        const st = await getAutostartStatus();
+        if (!st.enabled) {
+          const r = await enableAutostart();
+          if (r.ok) {
+            console.log(`autostart auto-enabled: ${r.method}${r.linger ? ` linger=${r.linger}` : ""}`);
+            try { bus?.emit({ ts: Date.now(), type: "autostart-auto-enabled", method: r.method }); } catch {}
+            try { logs.appendEvent({ ts: Date.now(), type: "autostart-auto-enabled", method: r.method }); } catch {}
+          } else {
+            console.log(`autostart auto-enable failed: ${r.error || "unknown"} (run mslxdff -enable-autostart manually)`);
+          }
+        }
+      } catch {}
+    }, 2500).unref?.();
+  }
+
+  return { srv, bus, router };
+}

package/src/state/facade.js

@@ -48,6 +48,7 @@ export {
   saveModelLatencies,
   loadModelStats,
   saveModelStats,
+  recordModelStats,
   loadPreferredModel,
   loadModelPicks,
   saveModelPicks,

package/src/state/schemas/model.js

@@ -30,6 +30,47 @@ export function saveModelStats(stats, { file = defaultStateFile() } = {}) {
   return stats;
 }
 
+const STATS_ALPHA = 0.3;
+function ema(prev, next) {
+  if (!Number.isFinite(prev) || prev <= 0) return Math.round(next);
+  if (!Number.isFinite(next) || next <= 0) return Math.round(prev);
+  return Math.round(prev * (1 - STATS_ALPHA) + next * STATS_ALPHA);
+}
+
+export function recordModelStats(id, { ttfbMs, totalMs, tps, completionTokens, file = defaultStateFile() } = {}) {
+  if (!id || typeof id !== "string") return null;
+  const stats = loadModelStats({ file });
+  const cur = stats[id] || { count: 0 };
+  const next = { ...cur };
+  next.count = (cur.count || 0) + 1;
+  next.lastAt = Date.now();
+  if (Number.isFinite(ttfbMs) && ttfbMs >= 0) {
+    next.avgTtfbMs = cur.avgTtfbMs != null ? ema(cur.avgTtfbMs, ttfbMs) : Math.round(ttfbMs);
+    next.emaTtfbMs = next.avgTtfbMs;
+    // 简易 p95：取 max 的 EMA
+    if (cur.p95Ttfb == null) next.p95Ttfb = Math.round(ttfbMs);
+    else next.p95Ttfb = Math.max(cur.p95Ttfb, Math.round(ttfbMs * 0.7 + cur.p95Ttfb * 0.3));
+  }
+  if (Number.isFinite(totalMs) && totalMs >= 0) {
+    next.avgTotalMs = cur.avgTotalMs != null ? ema(cur.avgTotalMs, totalMs) : Math.round(totalMs);
+    next.emaTotalMs = next.avgTotalMs;
+    next.lastTotalMs = Math.round(totalMs);
+  }
+  if (Number.isFinite(tps) && tps > 0) {
+    next.avgTps = cur.avgTps != null ? Number((cur.avgTps * (1 - STATS_ALPHA) + tps * STATS_ALPHA).toFixed(1)) : Number(tps.toFixed(1));
+    next.emaTps = next.avgTps;
+  }
+  if (Number.isFinite(completionTokens) && completionTokens > 0) {
+    const prevAvg = cur.avgCompTok;
+    next.avgCompTok = prevAvg != null ? Math.round(prevAvg * (1 - STATS_ALPHA) + completionTokens * STATS_ALPHA) : Math.round(completionTokens);
+  }
+  // 兼容旧字段：lastAt 供排序
+  stats[id] = next;
+  // 监控需实时可见，用同步落盘而非 500ms  debounce
+  try { writeStateImmediate(file, { modelStats: stats }); } catch { saveModelStats(stats, { file }); }
+  return next;
+}
+
 export function loadPreferredModel({ file = defaultStateFile() } = {}) {
   const v = readState(file).preferredModel;
   return typeof v === "string" && v.trim() ? v.trim() : null;

package/src/upstream-responses.js

@@ -0,0 +1,64 @@
+/**
+ * responses 转换层 — 从 upstream.js 抽出的 muse-spark 专用形状转换。
+ * chat ⇄ responses 互转纯函数，无网络、无副作用。
+ */
+export function isResponsesModel(model) {
+  return String(model || "").toLowerCase().startsWith("muse-spark");
+}
+
+export function chatToResponsesBody(chatBody) {
+  const msgs = Array.isArray(chatBody?.messages) ? chatBody.messages : [];
+  const system = msgs.filter((m) => m.role === "system").map((m) => String(m.content || "")).join("\n");
+  const nonSystem = msgs.filter((m) => m.role !== "system");
+  const inputParts = nonSystem.map((m) => {
+    const c = m.content;
+    if (typeof c === "string") return `${m.role}: ${c}`;
+    if (Array.isArray(c)) return `${m.role}: ${c.map((x) => x.text || "").join("")}`;
+    return `${m.role}: ${String(c || "")}`;
+  });
+  const input = inputParts.join("\n\n") || "hi";
+  const out = { model: chatBody.model, input, stream: false };
+  if (system) out.instructions = system;
+  if (chatBody.tools) out.tools = chatBody.tools;
+  if (chatBody.tool_choice) out.tool_choice = chatBody.tool_choice;
+  if (chatBody.temperature != null) out.temperature = chatBody.temperature;
+  if (chatBody.max_tokens != null) out.max_output_tokens = chatBody.max_tokens;
+  return out;
+}
+
+export function responsesToChatJson(respJson) {
+  let text = "";
+  for (const item of respJson.output || []) {
+    if (item.type === "message" && item.role === "assistant") {
+      for (const c of item.content || []) {
+        if (c.type === "output_text") text += c.text || "";
+        else if (c.type === "text") text += c.text || "";
+      }
+    }
+  }
+  if (!text) {
+    for (const item of respJson.output || []) {
+      if (item.type === "message") {
+        const t = item.content?.[0]?.text;
+        if (t) { text = t; break; }
+      }
+    }
+  }
+  const chatJson = {
+    id: respJson.id || `resp_${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor((respJson.created_at || Date.now() / 1000)),
+    model: respJson.model,
+    choices: [{ index: 0, finish_reason: respJson.status === "completed" ? "stop" : "length", message: { role: "assistant", content: text } }],
+    usage: respJson.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+  return chatJson;
+}
+
+/** responses 成功 Response 转回 chat 形状（anon 兜底与主路径复用） */
+export function toChatResponse(res, respJson) {
+  const chatJson = responsesToChatJson(respJson);
+  const headers = new Headers(res.headers);
+  headers.set("content-type", "application/json");
+  return new Response(JSON.stringify(chatJson), { status: res.status, headers });
+}

package/src/upstream.js

@@ -6,6 +6,7 @@ import { performance } from "node:perf_hooks";
 import { isFreeModel } from "./models.js";
 import { fmtShanghaiYMDHMS } from "./time.js";
 import { createTransport } from "./transport/index.js";
+import { isResponsesModel, chatToResponsesBody, toChatResponse } from "./upstream-responses.js";
 
 function genId(prefix) {
   return `${prefix}${crypto.randomUUID().replace(/-/g, "")}`;
@@ -81,56 +82,6 @@ export function createUpstreamClient({
     if (raw === "0" || raw === "off" || raw === "false" || raw === "no") return false;
     return true;
   }
-  function isResponsesModel(model) {
-    return String(model || "").toLowerCase().startsWith("muse-spark");
-  }
-  function chatToResponsesBody(chatBody) {
-    const msgs = Array.isArray(chatBody?.messages) ? chatBody.messages : [];
-    const system = msgs.filter((m) => m.role === "system").map((m) => String(m.content || "")).join("\n");
-    const nonSystem = msgs.filter((m) => m.role !== "system");
-    const inputParts = nonSystem.map((m) => {
-      const c = m.content;
-      if (typeof c === "string") return `${m.role}: ${c}`;
-      if (Array.isArray(c)) return `${m.role}: ${c.map((x) => x.text || "").join("")}`;
-      return `${m.role}: ${String(c || "")}`;
-    });
-    const input = inputParts.join("\n\n") || "hi";
-    const out = { model: chatBody.model, input, stream: false };
-    if (system) out.instructions = system;
-    if (chatBody.tools) out.tools = chatBody.tools;
-    if (chatBody.tool_choice) out.tool_choice = chatBody.tool_choice;
-    if (chatBody.temperature != null) out.temperature = chatBody.temperature;
-    if (chatBody.max_tokens != null) out.max_output_tokens = chatBody.max_tokens;
-    return out;
-  }
-  function responsesToChatJson(respJson) {
-    let text = "";
-    for (const item of respJson.output || []) {
-      if (item.type === "message" && item.role === "assistant") {
-        for (const c of item.content || []) {
-          if (c.type === "output_text") text += c.text || "";
-          else if (c.type === "text") text += c.text || "";
-        }
-      }
-    }
-    if (!text) {
-      for (const item of respJson.output || []) {
-        if (item.type === "message") {
-          const t = item.content?.[0]?.text;
-          if (t) { text = t; break; }
-        }
-      }
-    }
-    const chatJson = {
-      id: respJson.id || `resp_${Date.now()}`,
-      object: "chat.completion",
-      created: Math.floor((respJson.created_at || Date.now() / 1000)),
-      model: respJson.model,
-      choices: [{ index: 0, finish_reason: respJson.status === "completed" ? "stop" : "length", message: { role: "assistant", content: text } }],
-      usage: respJson.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-    };
-    return chatJson;
-  }
   function freeAnonLogFile() {
     return process.env.MSLXDFF_FREE_ANON_LOG || join(process.cwd(), "free-anon-extra.txt");
   }
@@ -196,16 +147,14 @@ export function createUpstreamClient({
           continue;
         }
         if (anonRes.status !== 429) {
-          // responses 模型需转回 chat 形状
+          // responses 模型需转回 chat 形状（复用 upstream-responses）
           let outAnon = anonRes;
           if (isResp && anonRes.ok) {
             try {
               const txt = await anonRes.text();
               const j = JSON.parse(txt);
               if (j && Array.isArray(j.output)) {
-                const chatJson = responsesToChatJson(j);
-                outAnon = new Response(JSON.stringify(chatJson), { status: anonRes.status, headers: new Headers(anonRes.headers) });
-                outAnon.headers.set("content-type", "application/json");
+                outAnon = toChatResponse(anonRes, j);
               } else {
                 outAnon = new Response(txt, { status: anonRes.status, headers: anonRes.headers });
               }
@@ -228,16 +177,13 @@ export function createUpstreamClient({
       }
     }
 
-    // responses 模型成功态转 chat
+    // responses 模型成功态转 chat（复用 upstream-responses）
     if (isResp && res.ok) {
       try {
         const txt = await res.text();
         const j = JSON.parse(txt);
         if (j && Array.isArray(j.output)) {
-          const chatJson = responsesToChatJson(j);
-          const headers = new Headers(res.headers);
-          headers.set("content-type", "application/json");
-          const transformed = new Response(JSON.stringify(chatJson), { status: res.status, headers });
+          const transformed = toChatResponse(res, j);
           transformed._t = { ...(res._t || {}), totalMs: Math.round(performance.now() - t0) };
           return transformed;
         }