mslxdff 0.1.88 → 0.1.90

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/transport/index.js

@@ -0,0 +1,248 @@
+import { performance } from "node:perf_hooks";
+import { resolveRetry, sleep, backoffDelay } from "./retry.js";
+import { createSseParser } from "./sse.js";
+import { createPool } from "./pool.js";
+
+let UndiciFetch = null;
+try {
+  const mod = await import("undici");
+  UndiciFetch = mod.fetch;
+} catch {}
+
+const DEFAULT_RETRY = {
+  network: { attempts: 2, delayMs: 300 },
+  429: { attempts: 1, delayMs: 100 },
+  502: { attempts: 1, delayMs: 100 },
+  503: { attempts: 1, delayMs: 100 },
+  504: { attempts: 1, delayMs: 100 },
+};
+
+export function createTransport({
+  baseUrl,
+  headers: baseHeaders = {},
+  keepAlive = true,
+  fetchImpl,
+  dispatcher: extDispatcher,
+  timeoutMs: defaultTimeoutMs = 30_000,
+  retry: defaultRetry = DEFAULT_RETRY,
+  hooks,
+} = {}) {
+  if (!fetchImpl) fetchImpl = UndiciFetch || globalThis.fetch;
+  const pool = keepAlive && !extDispatcher ? createPool({ keepAlive }) : null;
+  const getDispatcher = () => extDispatcher || pool?.dispatcher || null;
+
+  let closed = false;
+
+  function resolveUrl(url) {
+    if (!url) return baseUrl || "";
+    if (/^https?:\/\//i.test(url)) return url;
+    if (!baseUrl) return url;
+    return `${String(baseUrl).replace(/\/+$/, "")}/${String(url).replace(/^\/+/, "")}`;
+  }
+
+  async function applyHooks(name, ctx) {
+    if (!hooks) return null;
+    try { return await hooks(name, ctx); } catch { return null; }
+  }
+
+  async function request({
+    url,
+    method = "POST",
+    headers = {},
+    body,
+    stream,
+    timeoutMs,
+    retry,
+    dispatcher,
+  } = {}) {
+    const finalUrl = resolveUrl(url);
+    const retryCfg = retry ?? defaultRetry;
+    const timeout = Number(timeoutMs ?? defaultTimeoutMs) || 30_000;
+    const disp = dispatcher ?? getDispatcher();
+    const t0 = performance.now();
+    const attempts = [];
+    let waitMs = 0;
+
+    // 合并 headers
+    const finalHeaders = { ...baseHeaders, ...headers };
+    if (body != null && !finalHeaders["Content-Type"] && !finalHeaders["content-type"]) {
+      finalHeaders["Content-Type"] = "application/json";
+    }
+    if (stream && !finalHeaders["Accept"] && !finalHeaders["accept"]) {
+      finalHeaders["Accept"] = "text/event-stream";
+    }
+
+    const bodyStr = body != null && typeof body !== "string" ? JSON.stringify(body) : body;
+
+    for (let attempt = 0; ; attempt++) {
+      const tAttempt = performance.now();
+      let res;
+      let err = null;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new Error(`upstream timed out after ${timeout}ms`)), timeout);
+      try {
+        let reqUrl = finalUrl;
+        let reqHeaders = { ...finalHeaders };
+        // hooks
+        const hh = await applyHooks("upstream:headers", { url: reqUrl, body, headers: reqHeaders });
+        if (hh?.changed && hh.value?.headers) reqHeaders = hh.value.headers;
+        const br = await applyHooks("upstream:before-request", { url: reqUrl, method, body, headers: reqHeaders });
+        if (br?.changed && br.value) {
+          if (typeof br.value.url === "string" && br.value.url) reqUrl = br.value.url;
+          if (br.value.headers && typeof br.value.headers === "object") reqHeaders = br.value.headers;
+        }
+        const opts = { method, headers: reqHeaders, body: bodyStr, signal: controller.signal };
+        if (disp) opts.dispatcher = disp;
+        res = await fetchImpl(reqUrl, opts);
+      } catch (e) {
+        err = e;
+      } finally {
+        clearTimeout(timer);
+      }
+      const ms = Math.round(performance.now() - tAttempt);
+
+      if (err) {
+        attempts.push({ type: "network", ms });
+        const { shouldRetry, delayMs } = resolveRetry("network", attempt, retryCfg);
+        if (shouldRetry) {
+          await sleep(delayMs);
+          waitMs += delayMs;
+          continue;
+        }
+        err._t = { attempts, waitMs, totalMs: Math.round(performance.now() - t0) };
+        throw err;
+      }
+
+      // http
+      attempts.push({ type: `http${res.status}`, ms });
+      const { shouldRetry, delayMs } = resolveRetry(res.status, attempt, retryCfg);
+      if (shouldRetry) {
+        // 消耗 body 以释放连接
+        try { if (res.body) await res.text().catch(() => {}); } catch {}
+        await sleep(delayMs);
+        waitMs += delayMs;
+        continue;
+      }
+
+      const ttfbMs = Math.round(performance.now() - t0);
+      const isStreamRequested = stream === true;
+      const contentType = res.headers.get("content-type") || "";
+      // 若请求为 stream 但上游返回的是 JSON（测试桩常见），则回退为非流式处理，避免 SSE 空聚合
+      const isStream = isStreamRequested && contentType.includes("text/event-stream");
+      if (!isStream) {
+        // 非流式：预读 body 以得 totalMs 与缓存（兼容 stream:true 但返回 JSON 的桩）
+        let cachedText = "";
+        let readMs = ttfbMs;
+        try {
+          cachedText = await res.text();
+          readMs = Math.round(performance.now() - t0);
+        } catch {
+          cachedText = "";
+          readMs = ttfbMs;
+        }
+        const totalMs = readMs;
+        const headers = res.headers;
+        return {
+          status: res.status,
+          headers,
+          ok: res.ok,
+          ttfbMs,
+          totalMs,
+          _t: { attempts, waitMs, totalMs },
+          async json() { try { return JSON.parse(cachedText); } catch { return cachedText; } },
+          async text() { return cachedText; },
+          stream() { throw new Error("not-streaming: call with stream:true"); },
+          get body() { return null; },
+        };
+      } else {
+        // 流式：保留原始 res 用于 stream()
+        const headers = res.headers;
+        let firstTtfb = ttfbMs; // 更新为首事件到达时刻（测得即所得）
+        let firstDone = false;
+        let lastRead = ttfbMs;
+        const markFirst = () => {
+          if (!firstDone) { firstTtfb = Math.round(performance.now() - t0); firstDone = true; }
+        };
+        let _t = { attempts, waitMs, totalMs: ttfbMs };
+        return {
+          status: res.status,
+          headers,
+          ok: res.ok,
+          get ttfbMs() { return firstDone ? firstTtfb : ttfbMs; },
+          get totalMs() { return lastRead; },
+          get _t() { return _t; },
+          set _t(v) { _t = v; },
+          async json() {
+            let acc = "";
+            for await (const chunk of this.stream()) acc += chunk;
+            try { return JSON.parse(acc); } catch { return acc; }
+          },
+          async text() {
+            let acc = "";
+            for await (const chunk of this.stream()) acc += chunk;
+            return acc;
+          },
+          get body() { return res.body; },
+          async *stream() {
+            const parser = createSseParser();
+            if (res.body && typeof res.body.getReader === "function") {
+              const reader = res.body.getReader();
+              const decoder = new TextDecoder();
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                lastRead = Math.round(performance.now() - t0);
+                try { _t.totalMs = lastRead; } catch {}
+                const text = decoder.decode(value, { stream: true });
+                const evs = parser.push(text);
+                for (const e of evs) {
+                  if (e === "[DONE]") return;
+                  if (e === "") continue;
+                  markFirst();
+                  yield e;
+                }
+              }
+            } else if (typeof res.text === "function") {
+              const txt = await res.text();
+              const evs = parser.push(txt);
+              for (const e of evs) {
+                if (e === "[DONE]") return;
+                if (e === "") continue;
+                markFirst();
+                yield e;
+              }
+            }
+          },
+        };
+      }
+    }
+  }
+
+  async function preheat(url) {
+    const target = url || (baseUrl ? `${String(baseUrl).replace(/\/+$/, "")}/zen/v1/models` : null);
+    if (!target) return { ok: false, skipped: true };
+    const t0 = performance.now();
+    try {
+      const res = await request({ url: target, method: "GET", stream: false, timeoutMs: 3000 });
+      try { if (res.text) await res.text().catch(() => {}); } catch {}
+      return { ok: res.ok, status: res.status, ms: Math.round(performance.now() - t0) };
+    } catch (e) {
+      return { ok: false, error: String(e?.message || e), ms: Math.round(performance.now() - t0) };
+    }
+  }
+
+  async function close() {
+    if (closed) return;
+    closed = true;
+    if (pool) await pool.close();
+  }
+
+  return {
+    request,
+    preheat,
+    close,
+    get dispatcher() { return getDispatcher(); },
+    get agent() { return pool?.agent || null; },
+    [Symbol.asyncDispose]: close,
+  };
+}

package/src/transport/pool.js

@@ -0,0 +1,60 @@
+let UndiciAgent = null;
+try {
+  const mod = await import("undici");
+  UndiciAgent = mod.Agent;
+} catch {
+  UndiciAgent = null;
+}
+
+function envInt(name, fallback) {
+  const v = Number(process.env[name]);
+  return Number.isInteger(v) && v > 0 ? v : fallback;
+}
+
+export function createPool({
+  keepAlive = true,
+  keepAliveTimeout,
+  keepAliveMaxTimeout,
+  connections,
+} = {}) {
+  const keepAliveTimeoutMs = keepAliveTimeout ?? envInt("MSLXDFF_UPSTREAM_KEEPALIVE_TIMEOUT", 30_000);
+  const keepAliveMaxTimeoutMs = keepAliveMaxTimeout ?? envInt("MSLXDFF_UPSTREAM_KEEPALIVE_MAX_TIMEOUT", 60_000);
+  const keepAliveConnections = connections ?? envInt("MSLXDFF_UPSTREAM_KEEPALIVE_CONNECTIONS", 20);
+
+  let agent = null;
+  let dispatcher = null;
+  let closed = false;
+
+  if (keepAlive && UndiciAgent) {
+    try {
+      agent = new UndiciAgent({
+        keepAliveTimeout: keepAliveTimeoutMs,
+        keepAliveMaxTimeout: keepAliveMaxTimeoutMs,
+        connections: keepAliveConnections,
+        pipelining: 1,
+      });
+      dispatcher = agent;
+    } catch {
+      agent = null;
+      dispatcher = null;
+    }
+  }
+
+  async function close() {
+    if (closed) return;
+    closed = true;
+    if (agent && typeof agent.close === "function") {
+      try { await agent.close(); } catch {}
+    } else if (dispatcher && typeof dispatcher.close === "function" && dispatcher !== agent) {
+      try { await dispatcher.close(); } catch {}
+    }
+  }
+
+  return {
+    get dispatcher() { return dispatcher; },
+    get agent() { return agent; },
+    get closed() { return closed; },
+    close,
+    [Symbol.asyncDispose]: close,
+  };
+}