mslxdff 0.1.55 → 0.1.56

package/src/chat/tools.js

@@ -0,0 +1,304 @@
+import { execFile } from "node:child_process";
+import { readFileSync, statSync, existsSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { performance } from "node:perf_hooks";
+import { FORBIDDEN } from "./config.js";
+import { logDir } from "../logs.js";
+import { defaultStateFile, loadProviderKeys, loadProviderConfigs } from "../state.js";
+
+const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const allowedRoots = [
+  resolve(pkgRoot),
+  resolve(logDir()),
+  resolve(dirname(defaultStateFile())),
+];
+
+function isAllowed(p) {
+  const abs = resolve(p);
+  // 展开 ~/ 形式
+  const expanded = abs.startsWith("~/") ? join(process.env.HOME || process.env.USERPROFILE || "", abs.slice(2)) : abs;
+  const chk = resolve(expanded);
+  return allowedRoots.some((r) => chk === r || chk.startsWith(r + "/") || chk.startsWith(r + "\\"));
+}
+
+function parseCommand(str) {
+  // 支持引号包裹
+  const out = [];
+  let cur = "";
+  let q = null;
+  for (let i = 0; i < str.length; i++) {
+    const c = str[i];
+    if (q) {
+      if (c === q) q = null;
+      else cur += c;
+    } else if (c === '"' || c === "'") {
+      q = c;
+    } else if (c === " " || c === "\t") {
+      if (cur) { out.push(cur); cur = ""; }
+    } else {
+      cur += c;
+    }
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+export function getToolDefs() {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "run_command",
+        description: "执行一条 mslxdff CLI 命令（不含 mslxdff 前缀）。仅限 cli_help_mini 所列命令，禁止 -uninstall。",
+        parameters: {
+          type: "object",
+          properties: {
+            command: { type: "string", description: "例如: -model set hy3-free 或 -group list 或 -log 20" },
+          },
+          required: ["command"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "read_file",
+        description: "读取项目内的文件内容（src/ docs/ logs/ 等），用于查看日志或配置。禁止读取项目外文件。",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "相对项目根或绝对路径，如 src/logs.js 或 ~/.config/mslxdff/events.log" },
+            limit: { type: "number", description: "最多读取字符数，默认 8000" },
+          },
+          required: ["path"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "curl",
+        description: "网络/HTTP 探活，检测上游或本机服务可用性。支持任意 http(s) URL，返回状态码、耗时、响应头与前几千字符。常用： upstream(上游模型列表)、local/health(本机健康)、local/models(本机模型列表)。简写会自动补全为完整 URL。",
+        parameters: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "要请求的 URL 或简写：upstream、upstream/models、upstream/chat、local、local/health、local/models、health、models，或完整 http(s) URL" },
+            method: { type: "string", description: "HTTP 方法，默认 GET", enum: ["GET", "POST", "PUT", "DELETE", "HEAD", "PATCH", "OPTIONS"] },
+            headers: { type: "object", description: "附加请求头，键值均为字符串", additionalProperties: { type: "string" } },
+            body: { type: "string", description: "请求体（POST/PUT 时），字符串，如 JSON" },
+            timeoutMs: { type: "number", description: "超时毫秒，默认 8000，最大 15000" },
+          },
+          required: ["url"],
+        },
+      },
+    },
+  ];
+}
+
+export function validateCommand(cmd) {
+  const low = String(cmd || "").toLowerCase();
+  for (const f of FORBIDDEN) if (low.includes(f)) return `forbidden: ${f} 已拦截，禁止执行`;
+  return null;
+}
+
+export async function execCommand(command) {
+  const err = validateCommand(command);
+  if (err) return { ok: false, output: err };
+  const args = parseCommand(String(command).trim());
+  if (!args.length) return { ok: false, output: "empty command" };
+  // 关键路径打点：exec 本身耗时（fork+加载）是 -chat 最大的本地开销，后续可改直调以省 300-500ms
+  const bin = join(pkgRoot, "bin/mslxdff.js");
+  const t0 = performance.now();
+  const res = await new Promise((resolve) => {
+    execFile(process.execPath, [bin, ...args], { timeout: 15000, maxBuffer: 1024 * 500 }, (e, stdout, stderr) => {
+      const out = String(stdout || "") + (stderr ? `\n${stderr}` : "");
+      if (e) {
+        resolve({ ok: false, output: out.slice(0, 8000) || String(e.message).slice(0, 2000) });
+      } else {
+        resolve({ ok: true, output: out.slice(0, 8000) || "(no output)" });
+      }
+    });
+  });
+  res._ms = Math.round(performance.now() - t0);
+  return res;
+}
+
+export async function readFileTool({ path, limit }) {
+  const raw = String(path || "").trim();
+  if (!raw) return { ok: false, output: "empty path" };
+  let target = raw;
+  if (target.startsWith("~/")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    target = join(home, target.slice(2));
+  } else if (!target.startsWith("/") && !/^[A-Za-z]:/.test(target)) {
+    // 相对路径视作项目根相对
+    target = join(pkgRoot, target);
+  }
+  if (!isAllowed(target)) return { ok: false, output: `not allowed: ${raw}（仅限项目目录或日志目录）` };
+  try {
+    if (!existsSync(target)) return { ok: false, output: `not found: ${raw}` };
+    const st = statSync(target);
+    if (st.isDirectory()) {
+      // 列目录
+      const { readdirSync } = await import("node:fs");
+      const files = readdirSync(target).slice(0, 80);
+      return { ok: true, output: `dir ${raw}:\n` + files.join("\n") };
+    }
+    const cap = Number(limit) > 0 ? Math.min(Number(limit), 20000) : 8000;
+    const data = readFileSync(target, "utf8");
+    const txt = data.length > cap ? data.slice(0, cap) + `\n... (truncated ${data.length - cap} chars)` : data;
+    return { ok: true, output: txt || "(empty file)" };
+  } catch (e) {
+    return { ok: false, output: String(e.message).slice(0, 2000) };
+  }
+}
+
+function resolveLocalPort() {
+  // 复用 state 的端口优先级：state.port > MSLXDFF_PORT env > 8989
+  try {
+    const f = defaultStateFile();
+    const j = JSON.parse(readFileSync(f, "utf8"));
+    const p = j?.port;
+    if (Number.isInteger(p) && p > 0) return p;
+  } catch {}
+  const env = Number(process.env.MSLXDFF_PORT);
+  if (Number.isInteger(env) && env > 0) return env;
+  return 8989;
+}
+
+function resolveLocalToken() {
+  try {
+    const f = defaultStateFile();
+    const j = JSON.parse(readFileSync(f, "utf8"));
+    const t = j?.token;
+    if (typeof t === "string" && t.trim()) return t.trim();
+  } catch {}
+  return "";
+}
+
+function expandCurlUrl(raw) {
+  const s = String(raw || "").trim();
+  const low = s.toLowerCase();
+  const port = resolveLocalPort();
+  const localBase = `http://127.0.0.1:${port}`;
+  // 完整 http(s) 直接用
+  if (/^https?:\/\//i.test(s)) return s;
+  // 简写映射
+  if (low === "upstream" || low === "upstream/models" || low === "upstream/models/") return "https://opencode.ai/zen/v1/models";
+  if (low === "upstream/chat" || low === "upstream/chat/completions") return "https://opencode.ai/zen/v1/chat/completions";
+  if (low === "local" || low === "local/health" || low === "health") return `${localBase}/health`;
+  if (low === "local/models" || low === "models" || low === "v1/models") return `${localBase}/v1/models`;
+  if (low === "local/chat" || low === "v1/chat/completions") return `${localBase}/v1/chat/completions`;
+  // 供应商简写：bai/models、openrouter/models 等 → 该供应商 baseUrl + /models
+  const provMatch = low.match(/^([a-z0-9_-]+)\/models\/?$/);
+  if (provMatch) {
+    try {
+      const pid = provMatch[1];
+      const cfgs = loadProviderConfigs();
+      const cfg = cfgs[pid];
+      if (cfg?.baseUrl) return `${cfg.baseUrl.replace(/\/+$/, "")}/models`;
+    } catch {}
+  }
+  // 裸路径视作本机相对
+  if (s.startsWith("/")) return `${localBase}${s}`;
+  return s;
+}
+
+export async function curlTool({ url, method, headers, body, timeoutMs }) {
+  const raw = String(url || "").trim();
+  if (!raw) return { ok: false, output: "empty url" };
+  let target = expandCurlUrl(raw);
+  // 仅允许 http(s)
+  if (!/^https?:\/\//i.test(target)) return { ok: false, output: `only http(s) allowed: ${raw} -> ${target}` };
+  let m = String(method || "GET").toUpperCase();
+  if (!["GET", "POST", "PUT", "DELETE", "HEAD", "PATCH", "OPTIONS"].includes(m)) return { ok: false, output: `unsupported method: ${m}` };
+  const timeout = Math.min(Math.max(Number(timeoutMs) || 8000, 500), 15000);
+  // 组装头
+  const h = {};
+  if (headers && typeof headers === "object") {
+    for (const [k, v] of Object.entries(headers)) if (typeof v === "string") h[String(k)] = v;
+  }
+  // 上游自动补最小可用头
+  if (/opencode\.ai/i.test(target)) {
+    if (!h["x-opencode-client"]) h["x-opencode-client"] = "desktop";
+    if (!h["Authorization"] && !h["authorization"]) h["Authorization"] = "Bearer public";
+    if (!h["Accept"]) h["Accept"] = m === "GET" ? "*/*" : "application/json";
+    if (!h["Content-Type"] && m !== "GET" && m !== "HEAD") h["Content-Type"] = "application/json";
+  }
+  // 本机自动带 token（/v1/* 需要鉴权）；/v1/models 必须是 GET，模型常误用 POST 直接纠正
+  if (/127\.0\.0\.1|localhost/i.test(target) && /\/v1\//i.test(target)) {
+    const hasAuth = !!(h["Authorization"] || h["authorization"]);
+    if (!hasAuth) {
+      const tok = resolveLocalToken();
+      if (tok) h["Authorization"] = `Bearer ${tok}`;
+    }
+    if (/\/v1\/models/i.test(target) && m === "POST") m = "GET";
+  }
+  // 已配置供应商自动带 key（curl 直连供应商时免手动传头）
+  if (!h["Authorization"] && !h["authorization"]) {
+    try {
+      const cfgs = loadProviderConfigs();
+      for (const [pid, cfg] of Object.entries(cfgs)) {
+        const base = String(cfg?.baseUrl || "").replace(/\/+$/, "");
+        if (!base) continue;
+        if (target.toLowerCase().startsWith(base.toLowerCase())) {
+          const keys = loadProviderKeys(pid);
+          if (keys.length) { h["Authorization"] = `Bearer ${keys[0]}`; break; }
+        }
+      }
+      // 兜底：api.b.ai 即 bai 供应商（env 或 state）
+      if (!h["Authorization"] && /api\.b\.ai/i.test(target)) {
+        const k = loadProviderKeys("bai")[0];
+        if (k) h["Authorization"] = `Bearer ${k}`;
+      }
+    } catch {}
+  }
+  // fetch 实现优先 undici，其次全局
+  let fetchImpl = globalThis.fetch;
+  try {
+    const mod = await import("undici");
+    if (mod?.fetch) fetchImpl = mod.fetch;
+  } catch {}
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error(`curl timed out after ${timeout}ms`)), timeout);
+  const t0 = performance.now();
+  try {
+    const opts = { method: m, headers: h, signal: controller.signal };
+    if (body != null && m !== "GET" && m !== "HEAD") opts.body = String(body);
+    const res = await fetchImpl(target, opts);
+    const ms = Math.round(performance.now() - t0);
+    // 抓响应头（过滤成可读）
+    const rh = {};
+    try {
+      for (const [k, v] of res.headers.entries()) rh[k] = v;
+    } catch {}
+    let txt = "";
+    try {
+      // 限制读取大小，避免超大 body
+      const ab = await res.arrayBuffer();
+      const buf = Buffer.from(ab);
+      const lim = 6000;
+      txt = buf.toString("utf8").slice(0, lim);
+      if (buf.length > lim) txt += `\n... (truncated ${buf.length - lim} bytes)`;
+    } catch (e) {
+      txt = String(e.message || e).slice(0, 1000);
+    }
+    const headerLines = Object.entries(rh).slice(0, 20).map(([k, v]) => `${k}: ${v}`).join("\n");
+    const out = [
+      `${m} ${target}`,
+      `status: ${res.status} ${res.statusText || ""}`.trim(),
+      `latency: ${ms}ms`,
+      headerLines ? `headers:\n${headerLines}` : "headers: (none)",
+      `body (${txt.length} chars):`,
+      txt || "(empty body)",
+    ].join("\n");
+    // 2xx 视为 ok，其余仍返回 ok:true 但带状态，便于模型判断（网络层面成功）
+    return { ok: true, output: out.slice(0, 8000) };
+  } catch (e) {
+    const ms = Math.round(performance.now() - t0);
+    return { ok: false, output: `curl failed: ${String(e.message || e).slice(0, 1200)}\nurl: ${target}\nlatency: ${ms}ms` };
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/chat/upstream.js

@@ -0,0 +1,90 @@
+import { performance } from "node:perf_hooks";
+import { CHAT_PREFERRED, CHAT_FALLBACK, CHAT_TIMEOUT_MS } from "./config.js";
+import { createUpstreamClient } from "../upstream.js";
+
+function modelForAttempt(attempt) {
+  return attempt === 0 ? CHAT_PREFERRED : CHAT_FALLBACK;
+}
+
+export async function chatOnce({ messages, tools, model }) {
+  const client = createUpstreamClient({ connectTimeoutMs: CHAT_TIMEOUT_MS, keepAlive: false, fetchImpl: globalThis.fetch });
+  const body = {
+    model: model || CHAT_PREFERRED,
+    messages,
+    stream: false,
+  };
+  if (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);
+      const isInput400 = res.status === 400 && /prompt|messages/i.test(msg) && tools?.length;
+      if (isInput400) {
+        try { await client.close(); } catch {}
+        const retry = await chatOnceNoTools({ messages, model });
+        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 {}
+  }
+}
+
+async function chatOnceNoTools({ messages, model }) {
+  const client = createUpstreamClient({ connectTimeoutMs: CHAT_TIMEOUT_MS, keepAlive: false, fetchImpl: globalThis.fetch });
+  const body = { model: model || CHAT_PREFERRED, messages, stream: false };
+  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: ${txt.slice(0,800)}`, status: res.status }; }
+    if (!res.ok) return { ok: false, error: j?.error?.message || txt.slice(0,800), 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 {} }
+}
+
+// 带自动降级：仅 mimo-v2.5-free → big-pickle，不引入其他模型
+export async function chatWithFallback(opts) {
+  const TRACE = process.env.MSLXDFF_CHAT_TRACE !== "0";
+  const t0 = TRACE ? performance.now() : 0;
+  const first = await chatOnce({ ...opts, model: CHAT_PREFERRED });
+  if (TRACE) {
+    const dt = Math.round(performance.now() - t0);
+    console.log(`\x1b[90m· [LLM] ${CHAT_PREFERRED} ${first.ok ? "OK" : "FAIL"} · ${dt}ms${first.ok ? "" : ` · ${String(first.error).slice(0, 80)}`}\x1b[0m`);
+  }
+  if (first.ok) return { ...first, model: CHAT_PREFERRED };
+  const t1 = TRACE ? performance.now() : 0;
+  const second = await chatOnce({ ...opts, model: CHAT_FALLBACK });
+  if (TRACE) {
+    const dt = Math.round(performance.now() - t1);
+    const total = Math.round(performance.now() - t0);
+    console.log(`\x1b[90m· [LLM] ${CHAT_FALLBACK} ${second.ok ? "OK" : "FAIL"} · ${dt}ms · 总 ${total}ms (fallback)\x1b[0m`);
+  }
+  if (second.ok) return { ...second, model: CHAT_FALLBACK, fallback: true, firstError: first.error };
+  return { ok: false, error: `${CHAT_PREFERRED} failed: ${first.error}; ${CHAT_FALLBACK} failed: ${second.error}`, status: second.status || first.status };
+}
+
+// 压缩用：简短摘要请求（不带 tools），128k 上下文下仅 95% 触发，需完整摘要
+export async function summarizeHistory(messages) {
+  const prompt = [
+    { role: "system", content: "你是对话压缩助手，把以下历史对话压缩成 800 字以内的中文摘要，保留关键操作与结果、用户的偏好与待办、模型设置与群组操作及时间线，不要遗漏重要细节。" },
+    { role: "user", content: messages.map((m) => `${m.role}: ${m.content || JSON.stringify(m.tool_calls || "")}`).join("\n").slice(0, 90000) },
+  ];
+  const r = await chatWithFallback({ messages: prompt });
+  if (!r.ok) return null;
+  const txt = String(r.message?.content || "").trim();
+  return txt ? `【历史摘要】${txt}` : null;
+}

package/src/models.js

@@ -22,14 +22,102 @@ export function filterFreeModels(list) {
   return out;
 }
 
-export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, refreshMs = DEFAULT_REFRESH_MS, cacheFile } = {}) {
+export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, refreshMs = DEFAULT_REFRESH_MS, cacheFile, providers } = {}) {
+  // 多供应商聚合模式：给 `providers` 数组，则缓存并返回所有供应商的模型列表
+  if (providers?.length) {
+    let aggregate = null;
+    let aggFetchedAt = 0;
+    let lastAllowlistKey = "";
+    async function currentAllowlistKey() {
+      try {
+        const { loadProviderAllowedModels } = await import("./state.js");
+        return providers.map((p) => `${p.id}:${loadProviderAllowedModels(p.id).join(",")}`).join("|");
+      } catch {
+        return "";
+      }
+    }
+    async function aggLoad() {
+      const all = [];
+      for (const p of providers) {
+        try {
+          let list = (await p.listModels?.()) ?? [];
+          // 白名单过滤：若该供应商设置了 allowlist，则仅保留名单内模型
+          try {
+            const { loadProviderAllowedModels } = await import("./state.js");
+            const allowed = loadProviderAllowedModels(p.id);
+            if (allowed.length) {
+              const allowedSet = new Set(allowed);
+              const { splitModelId } = await import("./providers/model-id.js");
+              list = list.filter((m) => {
+                if (!m || !m.id) return false;
+                const { raw } = splitModelId(m.id, providers.map((x) => x.id));
+                return allowedSet.has(String(raw || "").trim());
+              });
+            }
+          } catch {}
+          all.push(...list);
+        } catch {
+          // 单供应商取数失败不拖垮整体
+        }
+      }
+      aggregate = { object: "list", data: all };
+      try {
+        lastAllowlistKey = await currentAllowlistKey();
+      } catch {}
+      if (cacheFile) persistModels(aggregate, cacheFile);
+      return aggregate;
+    }
+    async function get() {
+      const now = Date.now();
+      if (aggregate && now - aggFetchedAt < ttlMs) {
+        // 热更新白名单：allowlist 变化时，即使命中 TTL 也要重载（否则 clear 后仍返回旧过滤结果）
+        try {
+          const curKey = await currentAllowlistKey();
+          if (curKey !== lastAllowlistKey) {
+            const out = await aggLoad();
+            aggFetchedAt = Date.now();
+            return out;
+          }
+        } catch {}
+        // 否则尝试在缓存上二次过滤（处理 allowlist 从空变非空等未触发重载的场景）
+        try {
+          const { loadProviderAllowedModels } = await import("./state.js");
+          const { splitModelId } = await import("./providers/model-id.js");
+          const filteredData = aggregate.data.filter((m) => {
+            if (!m || !m.id) return false;
+            const { provider, raw } = splitModelId(m.id, providers.map((x) => x.id));
+            const allowed = loadProviderAllowedModels(provider);
+            if (!allowed.length) return true;
+            return allowed.includes(String(raw || "").trim());
+          });
+          if (filteredData.length !== aggregate.data.length) return { ...aggregate, data: filteredData };
+          return aggregate;
+        } catch {
+          return aggregate;
+        }
+      }
+      const out = await aggLoad();
+      aggFetchedAt = Date.now();
+      return out;
+    }
+    return { get, startAutoRefresh: () => {}, stopAutoRefresh: () => {} };
+  }
   let cache = null;
   let fetchedAt = 0;
   let inflight = null;
   let timer = null;
 
   async function load() {
-    const data = await fetchUpstreamModels({ baseUrl, headers });
+    let data = await fetchUpstreamModels({ baseUrl, headers });
+    // 白名单过滤：opencode 亦支持 allowlist
+    try {
+      const { loadProviderAllowedModels } = await import("./state.js");
+      const allowed = loadProviderAllowedModels("opencode");
+      if (allowed.length) {
+        const allowedSet = new Set(allowed);
+        data = { ...data, data: (data.data || []).filter((m) => m && m.id && allowedSet.has(String(m.id).trim())) };
+      }
+    } catch {}
     cache = data;
     fetchedAt = Date.now();
     if (cacheFile) persistModels(data, cacheFile);

package/src/providers/dispatcher.js

@@ -0,0 +1,100 @@
+import { splitModelId, DEFAULT_PROVIDER, joinModelId } from "./model-id.js";
+import { isModelAllowed, loadProviderAllowedModels } from "../state.js";
+
+// 多供应商 dispatcher：把多个 Provider 聚合成一个 `upstream` 形状（chat/preheat/close），
+// 按 body.model 的前缀路由到对应供应商，转发上游前剥掉前缀只发原始 id。
+export function createProviderDispatcher(providers = []) {
+  const byId = new Map(providers.map((p) => [p.id, p]));
+
+  function resolve(model) {
+    const split = splitModelId(model, providers.map((p) => p.id));
+    return {
+      provider: byId.get(split.provider) ?? byId.get(DEFAULT_PROVIDER) ?? providers[0],
+      raw: split.raw,
+      prefixed: split.prefixed,
+    };
+  }
+
+  async function chat(body, opts = {}) {
+    let { provider, raw } = resolve(body?.model);
+    if (!provider) throw new Error(`no provider for model ${body?.model ?? "(empty)"}`);
+    let workbuddyUid = opts?.workbuddyUid ? String(opts.workbuddyUid).trim() : "";
+    // model 前缀钉死：workbuddy/<uid>:<rawId>  -> 剥 uid，rawId 为真实模型
+    if (provider.id === "workbuddy" && typeof raw === "string" && raw.includes(":")) {
+      const idx = raw.indexOf(":");
+      const uidPart = raw.slice(0, idx).trim();
+      const modelPart = raw.slice(idx + 1).trim();
+      if (uidPart && modelPart) {
+        if (!workbuddyUid) workbuddyUid = uidPart;
+        raw = modelPart;
+      }
+    }
+    if (!isModelAllowed(provider.id, raw)) {
+      const allowed = loadProviderAllowedModels(provider.id);
+      const msg = `model not allowed for provider "${provider.id}": "${raw}" — allowed: ${allowed.join(", ") || "(none)"} (use: mslxdff -provider ${provider.id} allowlist add <model>)`;
+      return new Response(JSON.stringify({ error: msg }), { status: 403, headers: { "Content-Type": "application/json", "x-mslxdff-allowlist": "1" } });
+    }
+    const forwarded = raw === body?.model ? body : { ...body, model: raw };
+    // ADR-0008：本请求携带瞬时共享 key（shareKeys 由组员侧按 header 解析后传入）。
+    const sharedKeys = opts?.shareKeys?.[provider.id];
+    if (sharedKeys && sharedKeys.length && typeof provider.chatWithKeys === "function") {
+      return provider.chatWithKeys(forwarded, sharedKeys);
+    }
+    if (provider.id === "workbuddy" && workbuddyUid) {
+      return provider.chat(forwarded, { workbuddyUid });
+    }
+    return provider.chat(forwarded);
+  }
+
+  // 聚合所有供应商的模型列表；默认供应商（opencode）裸 id，其它带前缀
+  // 若某供应商设置了 allowlist（非空），则仅暴露白名单内的模型（按 raw id 匹配）
+  async function listModels() {
+    const out = [];
+    const seen = new Set();
+    for (const p of providers) {
+      let list;
+      try {
+        list = (await p.listModels?.()) ?? [];
+      } catch {
+        list = [];
+      }
+      const allowed = loadProviderAllowedModels(p.id);
+      const allowedSet = allowed.length ? new Set(allowed) : null;
+      for (const m of list) {
+        if (!m || !m.id) continue;
+        if (seen.has(m.id)) continue;
+        if (allowedSet) {
+          // m.id 已是带前缀的对外 id，需剥回 raw 再比对
+          const { raw } = splitModelId(m.id, providers.map((x) => x.id));
+          const rawNorm = String(raw || "").trim();
+          if (!allowedSet.has(rawNorm)) continue;
+          // 对于 opencode 裸 id，rawNorm 即 m.id 本身
+        }
+        seen.add(m.id);
+        out.push(m);
+      }
+    }
+    return out;
+  }
+
+  async function preheat() {
+    const results = [];
+    for (const p of providers) {
+      if (typeof p.preheat !== "function") continue;
+      try {
+        results.push(await p.preheat());
+      } catch {
+        results.push({ ok: false, error: "preheat failed" });
+      }
+    }
+    return results.length ? results[0] : { ok: false, skipped: true };
+  }
+
+  async function close() {
+    for (const p of providers) {
+      try { await p.close?.(); } catch {}
+    }
+  }
+
+  return { providers, byId, resolve, listModels, chat, preheat, close, joinModelId };
+}