mslxdff 0.1.66 → 0.1.68

package/package.json

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

package/src/bench/probe.js

@@ -0,0 +1,68 @@
+import { joinUrl } from "../providers/base.js";
+
+function normalizeModelsPayload(json) {
+  if (!json) return [];
+  if (Array.isArray(json)) return json;
+  if (Array.isArray(json.data)) return json.data;
+  if (Array.isArray(json.models)) return json.models;
+  if (json.data && typeof json.data === "object" && Array.isArray(json.data.data)) return json.data.data;
+  return [];
+}
+
+function toModelId(m) {
+  if (!m) return "";
+  if (typeof m === "string") return m;
+  if (typeof m.id === "string") return m.id;
+  if (typeof m.model === "string") return m.model;
+  if (typeof m.name === "string") return m.name;
+  return "";
+}
+
+export async function probeModels({
+  baseUrl,
+  modelsPath,
+  chatPath,
+  headers = {},
+  fetchImpl = globalThis.fetch,
+  timeoutMs = 8000,
+} = {}) {
+  const base = String(baseUrl || "").replace(/\/+$/, "");
+  if (!base) return { ok: false, error: "missing baseUrl", tried: [], data: [] };
+  const candidates = [];
+  const seen = new Set();
+  const push = (p) => {
+    const s = String(p || "").trim();
+    if (!s) return;
+    const norm = s.startsWith("/") ? s : `/${s}`;
+    if (!seen.has(norm)) { seen.add(norm); candidates.push(norm); }
+  };
+  if (modelsPath) push(modelsPath);
+  // 通用回退：/v1/models 与 /models
+  push("/v1/models");
+  push("/models");
+  // workbuddy 异形已在 defaultModelsPath 注入，若仍未命中则 candidates 已含
+  const tried = [];
+  let lastError = "";
+  for (const p of candidates) {
+    const url = joinUrl(base, p);
+    tried.push(url);
+    try {
+      const controller = new AbortController();
+      const t = setTimeout(() => controller.abort(new Error(`probe timeout ${timeoutMs}ms`)), timeoutMs);
+      let res;
+      try {
+        res = await fetchImpl(url, { headers, signal: controller.signal });
+      } finally { clearTimeout(t); }
+      if (res instanceof Error) { lastError = res.message || String(res); continue; }
+      if (!res.ok) { lastError = `HTTP ${res.status}`; continue; }
+      let json = {};
+      try { json = await res.json(); } catch { json = {}; }
+      const raw = normalizeModelsPayload(json);
+      const data = raw.map((m) => ({ id: toModelId(m), raw: m })).filter((x) => x.id).map((x) => ({ id: x.id, ...x.raw }));
+      return { ok: true, data, tried, url, rawCount: raw.length };
+    } catch (e) {
+      lastError = e?.message || String(e);
+    }
+  }
+  return { ok: false, error: lastError || "all probes failed", tried, data: [] };
+}

package/src/bench/report.js

@@ -0,0 +1,56 @@
+export function sortResults(list) {
+  const arr = [...(list || [])];
+  arr.sort((a, b) => {
+    if (a.ok !== b.ok) return a.ok ? -1 : 1;
+    if (a.ok && b.ok) {
+      const at = a.ttfbMs ?? a.totalMs ?? 1e9;
+      const bt = b.ttfbMs ?? b.totalMs ?? 1e9;
+      if (at !== bt) return at - bt;
+      const ap = a.tps ?? a.charsPerSec ?? -1;
+      const bp = b.tps ?? b.charsPerSec ?? -1;
+      return bp - ap;
+    }
+    return 0;
+  });
+  return arr;
+}
+
+function pad(s, n, align = "left") {
+  const str = String(s ?? "");
+  if (str.length >= n) return str.slice(0, n);
+  const d = n - str.length;
+  if (align === "right") return " ".repeat(d) + str;
+  return str + " ".repeat(d);
+}
+
+export function formatReport(results, { json = false } = {}) {
+  const sorted = sortResults(results);
+  const winner = sorted.find((r) => r.ok) || null;
+  if (json) {
+    return { text: JSON.stringify(sorted, null, 2), json: sorted, winner, sorted };
+  }
+  const lines = [];
+  lines.push("模型                          状态     TTFB   总耗时  速度        tokens  备注");
+  lines.push("─".repeat(84));
+  for (const r of sorted) {
+    const isWin = winner && r.id === winner.id;
+    const mark = isWin ? "*" : " ";
+    const id = pad((isWin ? "* " : "  ") + r.id, 28);
+    const label = pad(r.label || (r.ok ? "成功" : "失败"), 8);
+    const ttfb = pad(r.ttfbMs != null ? `${r.ttfbMs}ms` : "—", 6, "right");
+    const total = pad(r.totalMs != null ? `${r.totalMs}ms` : "—", 7, "right");
+    let speed = "—";
+    if (r.tps != null) speed = `${r.tps} t/s`;
+    else if (r.charsPerSec != null) speed = `${r.charsPerSec} 字/秒`;
+    speed = pad(speed, 11, "right");
+    const tok = r.tokens?.completion != null ? String(r.tokens.completion) : r.chars != null ? String(r.chars) : "—";
+    const note = r.ok ? "" : (r.error || "").slice(0, 28);
+    lines.push(`${mark}${id} ${label} ${ttfb} ${total} ${speed} ${pad(tok, 6, "right")}  ${note}`);
+  }
+  lines.push("─".repeat(84));
+  if (winner) lines.push(`最快：${winner.id}  TTFB ${winner.ttfbMs}ms  总 ${winner.totalMs}ms  ${winner.tps != null ? `${winner.tps} t/s` : `${winner.charsPerSec ?? "—"} 字/秒`}`);
+  else lines.push("无可用模型（均失败）");
+  const failed = sorted.filter((r) => !r.ok).length;
+  lines.push(`完成：${sorted.length} 个，成功 ${sorted.length - failed}，失败 ${failed}`);
+  return { text: lines.join("\n"), json: sorted, winner, sorted };
+}

package/src/bench/runner.js

@@ -0,0 +1,74 @@
+import { joinUrl } from "../providers/base.js";
+import { computeMetrics, extractUsageFromJson } from "../metrics.js";
+
+function classifyError(status, bodyText) {
+  const t = String(bodyText || "").slice(0, 300);
+  if (status === 401) return { label: "鉴权失败", retryable: false };
+  if (status === 402 || /insufficient balance/i.test(t)) return { label: "余额不足", retryable: false };
+  if (status === 403) return { label: /insufficient/i.test(t) ? "余额不足" : "鉴权失败", retryable: false };
+  if (status === 429) return { label: "限流", retryable: true };
+  if (status >= 500) return { label: `上游错误 ${status}`, retryable: true };
+  if (status === 404) return { label: "模型不存在", retryable: false };
+  return { label: `HTTP ${status}`, retryable: false };
+}
+
+export async function runOne({
+  baseUrl,
+  chatPath = "/v1/chat/completions",
+  model,
+  providerId,
+  apiKey,
+  headers = {},
+  prompt = "hi",
+  maxTokens = 32,
+  timeoutMs = 30000,
+  fetchImpl = globalThis.fetch,
+  clock = Date.now,
+} = {}) {
+  const started = clock();
+  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : started;
+  if (!baseUrl) return { id: model, ok: false, error: "missing baseUrl", label: "配置错误", ttfbMs: null, totalMs: 0, tps: null, charsPerSec: null, tokens: null };
+  if (!model) return { id: model, ok: false, error: "missing model", label: "配置错误", ttfbMs: null, totalMs: 0, tps: null, charsPerSec: null, tokens: null };
+  if (!apiKey) return { id: model, ok: false, error: "missing apiKey", label: "未配置 Key", ttfbMs: null, totalMs: 0, tps: null, charsPerSec: null, tokens: null };
+  const url = joinUrl(String(baseUrl).replace(/\/+$/, ""), chatPath);
+  const body = { model: String(model).split("/").pop(), stream: false, messages: [{ role: "user", content: prompt }], max_tokens: maxTokens };
+  // workbuddy 需额外 workbuddy 透传头由调用方 headers 注入；此处直接透传
+  const finalHeaders = { "Content-Type": "application/json", Accept: "application/json", ...headers };
+  if (apiKey && !finalHeaders.Authorization) finalHeaders.Authorization = `Bearer ${apiKey}`;
+
+  let ttfbMs = null;
+  let res;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error(`timeout ${timeoutMs}ms`)), timeoutMs);
+    const fetchStart = typeof performance !== "undefined" && performance.now ? performance.now() : clock();
+    try {
+      res = await fetchImpl(url, { method: "POST", headers: finalHeaders, body: JSON.stringify(body), signal: controller.signal });
+    } finally { clearTimeout(timer); }
+    ttfbMs = Math.round((typeof performance !== "undefined" && performance.now ? performance.now() : clock()) - fetchStart);
+    if (res instanceof Error) throw res;
+    const totalMs = Math.round((typeof performance !== "undefined" && performance.now ? performance.now() : clock()) - t0);
+    if (!res.ok) {
+      let txt = "";
+      try { txt = await res.text(); } catch {}
+      const cls = classifyError(res.status, txt);
+      return { id: model, providerId, ok: false, status: res.status, error: txt.slice(0, 300) || `HTTP ${res.status}`, label: cls.label, ttfbMs, totalMs, tps: null, charsPerSec: null, tokens: null };
+    }
+    let json = {};
+    let txt = "";
+    try { txt = await res.text(); json = JSON.parse(txt); } catch { json = {}; }
+    const usage = extractUsageFromJson(json);
+    const content = json?.choices?.[0]?.message?.content || json?.choices?.[0]?.text || txt || "";
+    const chars = typeof content === "string" ? content.length : 0;
+    const promptTokens = usage?.prompt_tokens ?? null;
+    const completionTokens = usage?.completion_tokens ?? null;
+    const { tps, charsPerSec } = computeMetrics({ ttfbMs, totalMs, promptTokens, completionTokens, chars });
+    const totalTokens = usage?.total_tokens ?? (promptTokens !== null && completionTokens !== null ? promptTokens + completionTokens : null);
+    return { id: model, providerId, ok: true, status: res.status, ttfbMs, totalMs, tps, charsPerSec, tokens: { prompt: promptTokens, completion: completionTokens, total: totalTokens }, chars, label: "成功", raw: json };
+  } catch (e) {
+    const totalMs = Math.round((typeof performance !== "undefined" && performance.now ? performance.now() : clock()) - t0);
+    const msg = e?.message || String(e);
+    const isTimeout = /timeout|abort/i.test(msg);
+    return { id: model, providerId, ok: false, error: msg.slice(0, 300), label: isTimeout ? "超时" : "网络错误", ttfbMs, totalMs, tps: null, charsPerSec: null, tokens: null };
+  }
+}

package/src/chat/cooling.js

@@ -0,0 +1,99 @@
+/**
+ * 冷却深模块：对 state 的 10min 冷却 + EMA 延迟做唯一封装
+ * 注入化便于单测（内存 Map + now）
+ */
+
+export function createCooling({
+  loadModelErrors,
+  saveModelErrors,
+  loadModelLatencies,
+  saveModelLatencies,
+  flush,
+  now = () => Date.now(),
+  cooldownMs = 10 * 60 * 1000,
+  slowCooldownMs = 10 * 60 * 1000,
+} = {}) {
+  const _loadErrors = loadModelErrors || (() => ({}));
+  const _saveErrors = saveModelErrors || (() => {});
+  const _loadLats = loadModelLatencies || (() => ({}));
+  const _saveLats = saveModelLatencies || (() => {});
+  const _flush = flush || (() => {});
+
+  async function isCooling(id) {
+    try {
+      const errors = _loadErrors() || {};
+      const e = errors[id];
+      if (!e || typeof e !== "object") return false;
+      const at = Number(e.at || 0);
+      if (!at) return false;
+      const isSlow = !!e.slow;
+      const cd = isSlow ? slowCooldownMs : cooldownMs;
+      return now() - at < cd && (e.status === "limit" || e.status === "error");
+    } catch {
+      return false;
+    }
+  }
+
+  async function recordError(id, status, { slow = false, latencyMs = 0 } = {}) {
+    try {
+      const errors = _loadErrors() || {};
+      const isLimit = Number(status) === 429 || String(status).includes("429");
+      const entryStatus = isLimit ? "limit" : "error";
+      errors[id] = { status: entryStatus, at: now(), code: Number.isInteger(Number(status)) ? Number(status) : null, slow: !!slow };
+      _saveErrors(errors);
+      try { _flush(); } catch {}
+      if (slow && Number.isFinite(latencyMs) && latencyMs > 0) {
+        try {
+          const lat = _loadLats() || {};
+          const prev = lat[id]?.emaMs;
+          const ema = prev ? Math.round(prev * 0.7 + latencyMs * 0.3) : Math.round(latencyMs);
+          lat[id] = { emaMs: ema, lastMs: Math.round(latencyMs), at: now(), count: (lat[id]?.count ?? 0) + 1 };
+          _saveLats(lat);
+          try { _flush(); } catch {}
+        } catch {}
+      }
+    } catch {}
+  }
+
+  async function recordOk(id, latencyMs) {
+    try {
+      const errors = _loadErrors() || {};
+      errors[id] = { status: "normal", at: now(), code: 200, slow: false };
+      _saveErrors(errors);
+      try { _flush(); } catch {}
+      if (Number.isFinite(latencyMs) && latencyMs > 0) {
+        const lat = _loadLats() || {};
+        const prev = lat[id]?.emaMs;
+        const ema = prev ? Math.round(prev * 0.7 + latencyMs * 0.3) : Math.round(latencyMs);
+        lat[id] = { emaMs: ema, lastMs: Math.round(latencyMs), at: now(), count: (lat[id]?.count ?? 0) + 1 };
+        _saveLats(lat);
+        try { _flush(); } catch {}
+      }
+    } catch {}
+  }
+
+  // 兼容旧命名
+  const recordChatError = recordError;
+  const recordChatOk = recordOk;
+  const isCoolingAsync = isCooling;
+
+  return { isCooling, isCoolingAsync, recordError, recordChatError, recordOk, recordChatOk };
+}
+
+// 默认实例（对接真实 state.js）
+let _default = null;
+export function getDefaultCooling() {
+  if (_default) return _default;
+  // 懒加载 state，避免循环
+  _default = createCooling({
+    loadModelErrors: () => {
+      try { const s = require("../state.js"); return s.loadModelErrors(); } catch { return {}; }
+    },
+    saveModelErrors: (o) => { try { const s = require("../state.js"); s.saveModelErrors(o); } catch {} },
+    loadModelLatencies: () => { try { const s = require("../state.js"); return s.loadModelLatencies(); } catch { return {}; } },
+    saveModelLatencies: (o) => { try { const s = require("../state.js"); s.saveModelLatencies(o); } catch {} },
+    flush: () => { try { const s = require("../state.js"); s.flushStateSync(); } catch {} },
+    now: () => Date.now(),
+  });
+  return _default;
+}

package/src/chat/direct.js

@@ -0,0 +1,57 @@
+import { performance } from "node:perf_hooks";
+
+function isInput400(status, msg, hasTools) {
+  return status === 400 && /prompt|messages/i.test(String(msg || "")) && hasTools;
+}
+
+/**
+ * 直连深模块：mimo/pickle 经 createUpstreamClient 的 stream:false 调用
+ * 注入化：便于用 fake client 触发 400→去 tools 重试
+ */
+export function createDirectClient({ createUpstreamClient, chatTimeoutMs = 15000, env = process.env, fetchImpl = globalThis.fetch } = {}) {
+  const _create = createUpstreamClient || (() => { throw new Error("createUpstreamClient not injected"); });
+
+  async function doChat({ messages, tools, model }, withoutTools) {
+    const prevAnon = env.MSLXDFF_FREE_ANON;
+    const needDisable = model === "mimo-v2.5-free" || model === "big-pickle";
+    if (needDisable) env.MSLXDFF_FREE_ANON = "0";
+    const client = _create({ connectTimeoutMs: chatTimeoutMs, keepAlive: false, fetchImpl });
+    const body = { model: model || "mimo-v2.5-free", messages, stream: false };
+    if (!withoutTools && tools?.length) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+    try {
+      const res = await client.chat(body);
+      const txt = await res.text();
+      let j;
+      try { j = JSON.parse(txt); } catch { return { ok: false, error: `non-json upstream: ${txt.slice(0, 800)}`, status: res.status }; }
+      if (!res.ok) {
+        const msg = j?.error?.message || txt.slice(0, 800);
+        if (!withoutTools && isInput400(res.status, msg, !!tools?.length)) {
+          try { await client.close(); } catch {}
+          // 重试去 tools
+          const retry = await doChat({ messages, model }, true);
+          if (retry.ok) return { ...retry, retriedWithoutTools: true };
+          return { ok: false, error: msg, status: res.status, retried: retry.error };
+        }
+        return { ok: false, error: msg, status: res.status };
+      }
+      const choice = j.choices?.[0];
+      if (!choice) return { ok: false, error: "no choice", status: res.status };
+      return { ok: true, message: choice.message, usage: j.usage, raw: j, status: res.status };
+    } finally {
+      try { await client.close(); } catch {}
+      if (needDisable) {
+        if (prevAnon === undefined) delete env.MSLXDFF_FREE_ANON;
+        else env.MSLXDFF_FREE_ANON = prevAnon;
+      }
+    }
+  }
+
+  async function chatOnce(opts) {
+    return doChat(opts, false);
+  }
+
+  return { chatOnce, _doChat: doChat };
+}

package/src/chat/gateway.js

@@ -0,0 +1,148 @@
+import { performance } from "node:perf_hooks";
+import { parseSse } from "./sse.js";
+import { DEFAULT_PORT } from "../state.js";
+
+/**
+ * 网关深模块：POST 127.0.0.1:port/v1/chat/completions model:auto
+ * 注入化：fetch/loadToken/getPort/readModelsJson 均可伪，便于单测
+ */
+export function createGatewayClient({
+  fetchImpl = globalThis.fetch,
+  loadToken,
+  getPort,
+  defaultPort = DEFAULT_PORT,
+  readModelsJson,
+  gatewayTimeoutMs = 25000,
+  env = process.env,
+} = {}) {
+  const _fetch = fetchImpl;
+  const _loadToken = loadToken || (async () => {
+    try {
+      const state = await import("../state.js");
+      const loaded = await state.loadToken();
+      return String(loaded?.token || "").trim();
+    } catch { return ""; }
+  });
+  const _getPort = getPort || (() => {
+    try { const s = require("../state.js"); const p = s.getPort(); if (Number.isInteger(p) && p > 0) return p; } catch {}
+    const v = Number(env.MSLXDFF_PORT);
+    if (Number.isInteger(v) && v > 0) return v;
+    return defaultPort;
+  });
+  const _readModels = readModelsJson || (async () => {
+    try {
+      const { readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { homedir } = await import("node:os");
+      const cache = join(homedir(), ".config", "mslxdff", "models.json");
+      if (existsSync(cache)) return JSON.parse(readFileSync(cache, "utf8"));
+    } catch {}
+    return { data: [] };
+  });
+
+  async function chatViaGateway({ messages, tools }) {
+    const TRACE = env.MSLXDFF_CHAT_TRACE !== "0";
+    const t0 = TRACE ? performance.now() : 0;
+    let port = defaultPort;
+    let token = "";
+    try {
+      token = String((await _loadToken()) || "").trim();
+      const p = _getPort();
+      if (Number.isInteger(p) && p > 0) port = p;
+    } catch {}
+    if (!token) {
+      try {
+        const { readFileSync, existsSync } = await import("node:fs");
+        const { join } = await import("node:path");
+        const { homedir } = await import("node:os");
+        const sf = env.MSLXDFF_STATE_FILE || join(homedir(), ".config", "mslxdff", "state.json");
+        if (existsSync(sf)) {
+          const j = JSON.parse(readFileSync(sf, "utf8"));
+          if (typeof j.token === "string" && j.token.trim()) token = j.token.trim();
+        }
+      } catch {}
+    }
+    const url = `http://127.0.0.1:${port}/v1/chat/completions`;
+    const body = { model: "auto", messages, stream: false };
+    if (tools?.length) { body.tools = tools; body.tool_choice = "auto"; }
+
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), gatewayTimeoutMs);
+      const res = await _fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+      const txt = await res.text();
+      let j;
+      try { j = JSON.parse(txt); } catch {
+        if (txt.includes("data:")) {
+          try {
+            const parsed = parseSse(txt);
+            if (parsed.sseOk && (parsed.content || parsed.toolCalls.length)) {
+              const hasToolCalls = parsed.toolCalls.length > 0;
+              const hasContent = !!parsed.content;
+              let finishReason = parsed.finishReason;
+              if (hasToolCalls && !hasContent) finishReason = "tool_calls";
+              const tool_calls = hasToolCalls ? parsed.toolCalls : undefined;
+              const msg = { role: "assistant", content: parsed.content || "" };
+              if (tool_calls) msg.tool_calls = tool_calls;
+              j = { id: `sse-${Date.now()}`, object: "chat.completion", model: parsed.model, choices: [{ index: 0, finish_reason: finishReason, message: msg }], usage: parsed.usage };
+            } else if (parsed.sseOk) {
+              return { ok: false, error: `gateway SSE no content: ${txt.slice(0, 800)}`, status: res.status };
+            } else {
+              return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
+            }
+          } catch {
+            return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
+          }
+        } else {
+          return { ok: false, error: `gateway non-json: ${txt.slice(0, 800)}`, status: res.status };
+        }
+      }
+      if (!res.ok) {
+        const msg = j?.error?.message || j?.error || j?.data?.error?.message || j?.data?.error || txt.slice(0, 800);
+        if (TRACE) console.log(`\x1b[90m· [LLM] gateway auto FAIL · ${Math.round(performance.now() - t0)}ms · HTTP ${res.status} ${String(msg).slice(0, 80)}\x1b[0m`);
+        return { ok: false, error: msg, status: res.status };
+      }
+      const choice = j.choices?.[0] || j.data?.choices?.[0];
+      const effectiveJ = j.choices ? j : (j.data?.choices ? j.data : j);
+      if (!choice) {
+        if (TRACE) console.log(`\x1b[90m· [gateway debug] no choice, txt=${txt.slice(0, 800)} · j=${JSON.stringify(j).slice(0, 800)}\x1b[0m`);
+        return { ok: false, error: `gateway no choice: ${txt.slice(0, 800)}`, status: res.status };
+      }
+      let provider = "opencode";
+      const rawModel = effectiveJ.model || j.model || choice.message?.model || "auto";
+      try {
+        const c = await _readModels();
+        const ids = (c.data || []).map((x) => x.id).filter(Boolean);
+        for (const pid of ids) {
+          const slash = pid.indexOf("/");
+          const prov = slash > 0 ? pid.slice(0, slash) : "opencode";
+          const raw = slash > 0 ? pid.slice(slash + 1) : pid;
+          if (pid === rawModel || raw === rawModel || pid.endsWith("/" + rawModel)) { provider = prov; break; }
+        }
+        if (provider === "opencode" && rawModel.includes("/")) {
+          const maybe = rawModel.split("/")[0];
+          if (["workbuddy", "clinebot", "sensenova", "openrouter", "generic"].includes(maybe)) provider = maybe;
+        }
+      } catch {}
+      if (TRACE) {
+        const dt = Math.round(performance.now() - t0);
+        console.log(`\x1b[90m· [LLM] gateway auto OK · ${dt}ms · 模型 ${provider !== "opencode" ? provider + "/" : ""}${rawModel} · 总 ${dt}ms (gateway-fallback)\x1b[0m`);
+      }
+      return { ok: true, message: choice.message, usage: effectiveJ.usage || j.usage, raw: j, status: res.status, model: rawModel, provider, viaGateway: true };
+    } catch (err) {
+      const msg = String(err?.message || err).slice(0, 800);
+      if (env.MSLXDFF_CHAT_TRACE !== "0") {
+        const dt2 = performance.now() - (performance.now() - 0); // placeholder, TRACE off in tests
+      }
+      return { ok: false, error: `gateway ${msg}`, status: 502 };
+    }
+  }
+
+  return { chatViaGateway };
+}