mslxdff 0.1.109 → 0.1.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.109",
+  "version": "0.1.111",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {
@@ -29,5 +29,10 @@
   "license": "MIT",
   "dependencies": {
     "undici": "^5.28.4"
+  },
+  "optionalDependencies": {
+    "@ai-sdk/openai-compatible": "2.0.41",
+    "@ai-sdk/openai": "3.0.84",
+    "zod": "^3.25.76"
   }
 }

package/src/chat-pipeline/dedup.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+
+/**
+ * 请求去重（防前端双击/重试风暴）
+ * key = ip | requested | stream | bodyHash(messages+model变体)
+ * 窗口内重复到达的相同请求直接 429 返回，提示前端去重
+ * 默认窗口 1000ms，可用 MSLXDFF_DEDUP_WINDOW_MS 覆盖，0 为关闭
+ */
+export function dedupWindowMs() {
+  const raw = process.env.MSLXDFF_DEDUP_WINDOW_MS;
+  if (raw != null && String(raw).trim() !== "") {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+  }
+  return 1000;
+}
+
+function hashBody(body) {
+  try {
+    const m = body?.messages;
+    const s = JSON.stringify({
+      model: body?.model || "",
+      stream: Boolean(body?.stream),
+      max_tokens: body?.max_tokens ?? body?.maxTokens ?? null,
+      messages: Array.isArray(m) ? m.map((x) => ({ role: x.role, content: typeof x.content === "string" ? x.content.slice(0, 4000) : JSON.stringify(x.content).slice(0, 4000) })) : [],
+      // 工具调用等也纳入，避免误判
+      tools: body?.tools ? JSON.stringify(body.tools).slice(0, 1000) : "",
+    });
+    return createHash("sha1").update(s).digest("hex").slice(0, 16);
+  } catch {
+    return String(body?.model || "").slice(0, 32);
+  }
+}
+
+let _global = null;
+export function globalDedup() {
+  if (!_global) _global = createDedup({ windowMs: dedupWindowMs() });
+  // 若环境变量在运行时被改，同步窗口
+  const want = dedupWindowMs();
+  if (_global.windowMs !== want) {
+    _global.windowMs = want;
+  }
+  return _global;
+}
+export function _resetGlobalDedup() { _global = null; }
+
+export function createDedup({ windowMs = dedupWindowMs(), now = Date.now } = {}) {
+  const map = new Map(); // key -> at
+  let sweepAt = 0;
+
+  function sweep() {
+    const t = now();
+    if (t - sweepAt < windowMs) return;
+    sweepAt = t;
+    for (const [k, at] of map) {
+      if (t - at > windowMs) map.delete(k);
+    }
+  }
+
+  function keyFor({ ip, requested, body }) {
+    const h = hashBody(body);
+    const stream = body?.stream ? "1" : "0";
+    return `${ip || "-"}|${requested || "-"}|${stream}|${h}`;
+  }
+
+  function check({ ip, requested, body }) {
+    if (!windowMs) return { dup: false, key: null };
+    sweep();
+    const key = keyFor({ ip, requested, body });
+    const at = map.get(key);
+    const t = now();
+    if (at != null && t - at < windowMs) {
+      return { dup: true, key, ageMs: t - at };
+    }
+    map.set(key, t);
+    return { dup: false, key };
+  }
+
+  function _size() { return map.size; }
+  function _clear() { map.clear(); }
+
+  return { check, keyFor, _size, _clear, windowMs };
+}

package/src/chat-pipeline/serial-trial.js

@@ -9,7 +9,7 @@ import { handlePeerRelay } from "../routes/chat/peer-handler.js";
 import { handleBroadbandRelay } from "../routes/chat/broadband-handler.js";
 import { handleViaRoute } from "../routes/chat/via-route-handler.js";
 import { handleExhaustedLocal, handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
-import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
+import { shouldUseGroupForModel, isHardLocalOnly } from "../state/schemas/use-group.js";
 
 /**
  * 串行 trial — 从 engine.js 抽出的第二段：via-route 单路径 → 串行 trial →
@@ -131,7 +131,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     if (canForwardPeers) {
       if (!shouldUseGroupForModel(model)) {
-        evt("group-skip", { reqId, model, reason: "useGroup=off (peer)" });
+        evt("group-skip", { reqId, model, reason: isHardLocalOnly(model) ? "provider local-only（禁组员，仅本机直连）" : "useGroup=off (peer)" });
       } else {
         const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
         if (pr.handled) return { done: true };
@@ -139,7 +139,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     if (groups) {
       if (!shouldUseGroupForModel(model)) {
-        evt("group-skip", { reqId, model, reason: "useGroup=off (broadband)" });
+        evt("group-skip", { reqId, model, reason: isHardLocalOnly(model) ? "provider local-only（禁组员，仅本机直连）" : "useGroup=off (broadband)" });
       } else {
         const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
         if (br.handled) return { done: true };

package/src/cli/commands/model/list.js

@@ -9,6 +9,7 @@ import { readModelsCache } from "../../util.js";
 import { pickInteractiveMulti } from "../../interactive.js";
 import { buildAliasMap, readFullAliases, renderProviderList, renderFreeList, groupByProvider } from "./list-render.js";
 import { renderOtherProviders } from "./list-providers.js";
+import { filterStalePicks } from "../../../providers/model-id.js";
 
 /**
  * `-model list` 全流程：参数解析 → 刷新/回退 → provider 分支 → TTY 交互 → 分组渲染。
@@ -137,21 +138,33 @@ export async function handleModelList(args, idx, sub) {
       const pickedIds = loadModelPicks();
       const combinedIds = [...ids];
       const seen = new Set(combinedIds);
+      let staleFilter = null;
       try {
         const { loadProviderConfigs, loadProviderAllowedModels } = await import("../../../state.js");
+        const { buildProviderRows } = await import("../../provider-row.js");
+        // 已知 = 已启用（与 -provider list 同一 enabled 口径：有 baseUrl 且有 key；
+        // openrouter 有 key 即算，opencode 内置恒启用）。未启用 provider 的 picks
+        // 不进列表，启用后自动回来（数据未动）。
+        const knownProviders = buildProviderRows({}).filter((r) => r.enabled).map((r) => r.id);
         const configs = loadProviderConfigs();
-        for (const pid of Object.keys(configs).filter((k) => String(k).toLowerCase() !== "opencode")) {
+        const allowedIds = [];
+        for (const pid of knownProviders.filter((k) => String(k).toLowerCase() !== "opencode")) {
           const allowed = loadProviderAllowedModels(pid);
           for (const raw of allowed) {
             const canonical = `${pid}/${raw}`;
+            allowedIds.push(canonical);
             if (!seen.has(canonical)) {
               seen.add(canonical);
               combinedIds.push(canonical);
             }
           }
         }
+        staleFilter = { knownProviders, liveIds: ids, allowedIds };
       } catch {}
-      for (const pid of pickedIds) {
+      // provider 已不存在的 picks 孤儿不进交互列表（数据不动，status --all 仍可审计）。
+      // configs 读失败时 staleFilter 为空 → 不过滤（默认放行）。
+      const visiblePicks = staleFilter ? filterStalePicks(pickedIds, staleFilter) : pickedIds;
+      for (const pid of visiblePicks) {
         if (!seen.has(pid)) {
           seen.add(pid);
           combinedIds.push(pid);

package/src/cli/commands/provider/models.js

@@ -75,15 +75,28 @@ export async function handleProviderModels(id, sub, args, rest) {
         const part = String(b).split(":")[1];
         return part ? ` [${part}]` : ` [${b}]`;
       };
+      // 能力列：上下文 k + 📷识图 🧠推理 🔧工具调用（workbuddy 原生字段；其他供应商无这些字段则显示 —）
+      const fmtCaps = (m) => {
+        const ctx = Number(m.maxInputTokens) || null;
+        const hasAny = ctx || m.supportsImages != null || m.supportsReasoning != null || m.supportsToolCall != null;
+        if (!hasAny) return "—";
+        const parts = [];
+        if (ctx) parts.push(ctx >= 1_000_000 ? `${Math.round(ctx / 100000) / 10}M` : `${Math.round(ctx / 1000)}k`);
+        if (m.supportsImages && !m.disabledMultimodal) parts.push("📷");
+        if (m.supportsReasoning) parts.push("🧠");
+        if (m.supportsToolCall) parts.push("🔧");
+        return parts.join(" ");
+      };
       const idW = Math.max(22, ...all.map((m) => String(m.id).length)) + 2;
       const priceW = Math.max(6, ...all.map((m) => fmtPrice(m).length)) + 2;
+      const capsW = Math.max(4, ...all.map((m) => fmtCaps(m).length)) + 2;
       for (const m of all) {
         const ok = markAllowed(m.id);
         const price = fmtPrice(m);
         const badge = fmtBadge(m);
         const name = m.name ? ` ${m.name}` : "";
         const blocked = ok ? "" : "  [blocked — allowlist]";
-        const line = `  ${ok ? "✓" : "x"} ${String(m.id).padEnd(idW)}${String(price).padEnd(priceW)}${name}${badge}${blocked}`;
+        const line = `  ${ok ? "✓" : "x"} ${String(m.id).padEnd(idW)}${String(price).padEnd(priceW)}${fmtCaps(m).padEnd(capsW)}${name}${badge}${blocked}`;
         console.log(line);
       }
       if (!all.length) console.log(`  (no models — check baseUrl/keys or try: curl ${baseUrl}/models)`);

package/src/cli/commands/sync.js

@@ -88,6 +88,8 @@ export async function handleSetto(args) {
           if (r.action === "inserted") inserted++; else updated++;
           prunedTotal += r.pruned || 0;
           console.log(`  ${r.action} "${r.id}" -> ${r.internal} @ ${file}`);
+          if (r.capsSummaryText) console.log(`      ${r.capsSummaryText}`);
+          if (r.upgraded) console.log(`      能力补齐 ${r.upgraded} 个旧条目`);
         }
         console.log(`synced to opencode: ${inserted} inserted, ${updated} updated, total ${list.length} @ ${file}`);
         if (prunedTotal) console.log(`  pruned ${prunedTotal} 个失效模型（未在 picks，不再于 opencode 显示）`);
@@ -158,6 +160,9 @@ export async function handleSetto(args) {
       const file = opencodeConfigPath();
       const r = await syncToOpencode({ id, token, port, file, keep: pruneKeep(), ensureAll: pruneKeep() });
       console.log(`synced to opencode: ${r.action} "${r.id}" @ ${file}`);
+      if (r.capsSummaryText) console.log(`  能力: ${r.capsSummaryText}`);
+      else console.log(`  能力: 未收录该模型的能力目录，条目仅含名称（不影响使用）`);
+      if (r.upgraded) console.log(`  能力补齐 ${r.upgraded} 个旧条目（此前仅含名称，已注入推理档位/读图/上下文）`);
       if (r.backfilled) console.log(`  backfilled ${r.backfilled} 个 picks 模型（此前 pick 了但未同步过，现已补齐）`);
       if (r.pruned) console.log(`  pruned ${r.pruned} 个失效模型（未在 picks，不再于 opencode 显示）`);
       console.log(`  url: http://127.0.0.1:${port}/v1`);

package/src/model-capabilities/enrich.js

@@ -0,0 +1,86 @@
+// -setto opencode 条目能力注入（ADR-0016 联动）：把 models.dev 能力写进 opencode.json
+// 的 per-model 条目（opencode Model 形状，实测 debug config 原样保留并生效），
+// 并产出一行人话摘要供 CLI 展示。查不到能力（未收录 provider/模型）时原样返回不硬造。
+import { globalCapabilities } from "./index.js";
+
+// "bai/glm-5.3-flash" → { provider: "bai", raw: "glm-5.3-flash" }；裸 id 归 opencode
+function splitProvider(modelId) {
+  const s = String(modelId || "").trim();
+  const i = s.indexOf("/");
+  if (i > 0) return { provider: s.slice(0, i).toLowerCase(), raw: s.slice(i + 1) };
+  return { provider: "opencode", raw: s };
+}
+
+// caps → opencode Model 形状增量（只含能力字段，name 等原有键不动）
+// variants：config 条目显式档位（provider.ts config 路径 mergeDeep(config.variants) 优先于启发式，
+// 绕过 transform.ts 黑名单——glm/kimi/deepseek-v3/minimax/qwen/big-pickle 启发式恒 return {}）。
+// 参数形状 reasoningEffort 对齐 @ai-sdk/openai-compatible（muse-spark 启发式同款）。
+// toggle/budget_tokens 型不注入（OpenAI 兼容协议无标准开关参数，留启发式判断）。
+function capsToEntryFields(caps) {
+  if (!caps) return null;
+  const fields = {
+    reasoning: Boolean(caps.reasoning),
+    tool_call: Boolean(caps.toolCall),
+    attachment: Boolean(caps.attachment),
+    temperature: Boolean(caps.temperature),
+    modalities: { input: caps.inputModalities || ["text"], output: caps.outputModalities || ["text"] },
+    limit: { context: Number(caps.context) || 0, output: Number(caps.maxOutput) || 0 },
+  };
+  if (caps.effortType === "effort" && Array.isArray(caps.effortValues) && caps.effortValues.length) {
+    fields.variants = Object.fromEntries(caps.effortValues.map((v) => [String(v), { reasoningEffort: String(v) }]));
+  }
+  if (caps.releaseDate) fields.release_date = caps.releaseDate;
+  if (caps.costIn != null || caps.costOut != null) {
+    fields.cost = { input: Number(caps.costIn) || 0, output: Number(caps.costOut) || 0 };
+  }
+  return fields;
+}
+
+// entry: 现有条目（含 name 等）；modelId: 内部 canonical id；capsSvc: 可注入（默认全局单例）
+// wbSource: workbuddy 动态源接缝（测试注入；生产 = workbuddyAllModels 上游原生字段）
+// 返回 { entry: 增强后条目, caps: caps|null }；服务异常静默降级（同步命令不能因目录拉取失败而挂）
+export async function enrichOpencodeEntry(entry, modelId, capsSvc, wbSource) {
+  const base = entry && typeof entry === "object" && !Array.isArray(entry) ? entry : {};
+  const svc = capsSvc === undefined ? globalCapabilities() : capsSvc;
+  if (!svc) return { entry: base, caps: null };
+  const { provider, raw } = splitProvider(modelId);
+  let caps = null;
+  try {
+    await svc.ready();
+    caps = svc.get(provider, raw) || null;
+    // 降级匹配：mslxdff 自建目录的 -free/-search-free/-expert-free 后缀在 models.dev 无后缀
+    if (!caps && /-free$/.test(raw)) caps = svc.get(provider, raw.replace(/-free$/, "")) || null;
+    // workbuddy 不在 models.dev 目录 → 上游原生字段兜底（maxInputTokens/supportsImages/... first-party 最准）
+    if (!caps && provider === "workbuddy") {
+      const { workbuddyCapsFromModels, workbuddyAllModels } = await import("./index.js");
+      const map = await workbuddyCapsFromModels(wbSource || workbuddyAllModels)();
+      caps = map[raw] || null;
+    }
+  } catch {
+    caps = null; // 目录不可用：降级为无能力条目（staleness 兜底在服务内已做）
+  }
+  const fields = capsToEntryFields(caps);
+  if (!fields) return { entry: base, caps: null };
+  return { entry: { ...base, ...fields }, caps };
+}
+
+// caps → 一行人话摘要（无有效信息返回 ""，调用方按空跳过不噪音）
+export function capsSummary(caps) {
+  if (!caps) return "";
+  const parts = [];
+  if (caps.effortType === "effort" && Array.isArray(caps.effortValues) && caps.effortValues.length) {
+    parts.push(`推理档 ${caps.effortValues.join("/")}`);
+  } else if (caps.effortType === "toggle") {
+    parts.push("推理 开关型");
+  } else if (caps.effortType === "budget_tokens") {
+    parts.push("推理 budget_tokens");
+  } else if (caps.reasoning) {
+    parts.push(caps.defaultEffort ? `推理（默认 ${caps.defaultEffort}）` : "推理模型");
+  }
+  if (caps.imageInput) parts.push("📷读图");
+  if (caps.context) parts.push(`上下文 ${caps.context >= 1000 ? `${Math.round(caps.context / 1000)}k` : caps.context}`);
+  if (caps.costIn != null || caps.costOut != null) {
+    parts.push(`$${caps.costIn ?? 0}/${caps.costOut ?? 0} 每M`);
+  }
+  return parts.join(" · ");
+}

package/src/model-capabilities/index.js

@@ -0,0 +1,163 @@
+// 模型能力目录服务（opencode 官方同源 models.dev）：fetch + 磁盘缓存 + TTL + staleness 降级
+// 源：https://models.opencode.ai/api.json（opencode core models-dev.ts:160 同款；备选 https://models.dev/api.json）
+// 形状：{ [providerId]: { models: { [modelId]: raw } } }；mslxdff 裸 id 归 opencode，`prov/id` 前缀路由到对应 provider
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeProviderModels, normalizeWorkbuddyCaps } from "./parse.js";
+import { compatFetch } from "../compat.js";
+
+export const DEFAULT_SOURCE_URL = "https://models.opencode.ai/api.json";
+
+export function sourceUrl() {
+  const raw = process.env.MSLXDFF_MODELS_DEV_URL;
+  return raw && String(raw).trim() ? String(raw).trim() : DEFAULT_SOURCE_URL;
+}
+
+export function ttlMs() {
+  const n = Number(process.env.MSLXDFF_MODELS_DEV_TTL_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 86_400_000; // 默认 24h
+}
+
+export function createCapabilitiesService({
+  fetchImpl = compatFetch,
+  cacheFile = "",
+  ttlMs: ttl = ttlMs(),
+  url = sourceUrl(),
+  now = Date.now,
+} = {}) {
+  let raw = null;          // 原始目录（全 provider）
+  let capsIndex = new Map(); // providerId -> { modelId -> caps }
+  let loadedAt = 0;
+  let inflight = null;
+
+  function buildIndex(data) {
+    const idx = new Map();
+    for (const [pid, p] of Object.entries(data || {})) {
+      if (!p || typeof p !== "object") continue;
+      idx.set(pid, normalizeProviderModels(p.models || {}));
+    }
+    return idx;
+  }
+
+  function readCache() {
+    if (!cacheFile) return null;
+    try { return JSON.parse(readFileSync(cacheFile, "utf8")); } catch { return null; }
+  }
+
+  function writeCache(data) {
+    if (!cacheFile || !data) return;
+    try {
+      mkdirSync(dirname(cacheFile), { recursive: true });
+      writeFileSync(cacheFile, JSON.stringify(data));
+    } catch { /* 缓存失败不致命 */ }
+  }
+
+  async function fetchFresh() {
+    const res = await fetchImpl(url, { headers: { Accept: "application/json" } });
+    if (!res?.ok) throw new Error(`models.dev fetch ${res?.status || "network"}`);
+    return res.json();
+  }
+
+  // ready：缓存新鲜直接用；否则拉新；失败回退旧缓存（含磁盘），完全无数据才抛
+  async function ready() {
+    const t = now();
+    if (raw && t - loadedAt < ttl) return;
+    if (inflight) return inflight;
+    inflight = (async () => {
+      try {
+        const data = await fetchFresh();
+        raw = data;
+        capsIndex = buildIndex(data);
+        loadedAt = t;
+        writeCache(data);
+      } catch (e) {
+        if (raw) return; // 内存还有旧的，继续用
+        const disk = readCache();
+        if (disk) {
+          raw = disk;
+          capsIndex = buildIndex(disk);
+          loadedAt = t; // 视作刚加载，避免每请求都重试打上游
+          return;
+        }
+        throw e;
+      } finally {
+        inflight = null;
+      }
+    })();
+    return inflight;
+  }
+
+  function capsFor(pid) {
+    return capsIndex.get(pid) || null;
+  }
+
+  function get(providerId, modelId) {
+    const pid = String(providerId || "opencode").toLowerCase();
+    const mid = String(modelId || "");
+    const map = capsFor(pid);
+    if (!map) return null;
+    return map[mid] || null;
+  }
+
+  function list(providerId) {
+    const pid = String(providerId || "opencode").toLowerCase();
+    const map = capsFor(pid);
+    if (!map) return [];
+    return Object.entries(map).map(([id, capabilities]) => ({ id, capabilities }));
+  }
+
+  function providers() {
+    return [...capsIndex.keys()].sort();
+  }
+
+  return { ready, get, list, providers };
+}
+
+// 模块级单例（与 globalDedup 同模式）：HTTP handler 懒加载，测试 _reset 后注入
+let _global = null;
+export function globalCapabilities() {
+  if (!_global) _global = createCapabilitiesService({ cacheFile: defaultCacheFile() });
+  return _global;
+}
+export function _resetGlobalCapabilities() { _global = null; }
+
+// 缓存落盘位置：MSLXDFF_MODELS_DEV_CACHE 覆盖 > ~/.config/mslxdff/models-dev.json（与 state 同目录）
+function defaultCacheFile() {
+  const override = process.env.MSLXDFF_MODELS_DEV_CACHE;
+  if (override && String(override).trim()) return String(override).trim();
+  return join(homedir(), ".config", "mslxdff", "models-dev.json");
+}
+
+// workbuddy 动态源：从聚合模型服务（models.get()，带 10min 上游缓存）拉 workbuddy/ 前缀条目
+// → 统一 caps 形状 map（{ rawId -> caps }）。上游原生字段 first-party 最准，不走 models.dev。
+export function workbuddyCapsFromModels(getModels, normalizeFn) {
+  const normalize = normalizeFn || ((m) => normalizeWorkbuddyCaps(m.id, m));
+  return async () => {
+    const agg = await getModels();
+    const all = Array.isArray(agg?.data) ? agg.data : [];
+    const map = {};
+    for (const entry of all) {
+      const id = String(entry?.id || "");
+      if (!id.toLowerCase().startsWith("workbuddy/")) continue;
+      const raw = id.slice("workbuddy/".length);
+      if (!raw) continue;
+      map[raw] = normalize(entry);
+    }
+    return map;
+  };
+}
+
+// workbuddy provider 单例（直连上游 listModels 自带 10min 缓存）：HTTP handler 与
+// -setto opencode 能力注入共享同一个实例，避免双份连接池/缓存。
+let _wbProv = null;
+export function _resetWorkbuddyProv() { _wbProv = null; }
+export async function workbuddyAllModels() {
+  if (!_wbProv) {
+    const { createWorkbuddyProvider } = await import("../providers/workbuddy.js");
+    const { defaultStateFile } = await import("../state.js");
+    _wbProv = createWorkbuddyProvider({ file: defaultStateFile() });
+  }
+  const list = await _wbProv.listModels();
+  return { object: "list", data: Array.isArray(list) ? list : [] };
+}

package/src/model-capabilities/parse.js

@@ -0,0 +1,68 @@
+// models.dev 能力目录 → mslxdff 能力形状的纯函数解析层（无 IO，测试接缝 S1）
+// 源数据形态（实测 models.opencode.ai/api.json 2026-09-11）：
+//   reasoning_options: [{type:"effort",values:["low","medium","high","max"]} | {type:"toggle"} | {type:"budget_tokens",min}]
+//   modalities.input 含 "image" 即可读图；limit.context/output；cost.input/output 为 $/M tokens
+export function normalizeModelCaps(_id, m) {
+  const opts = Array.isArray(m?.reasoning_options) ? m.reasoning_options : [];
+  const effort = opts.find((o) => o?.type === "effort");
+  const toggle = opts.some((o) => o?.type === "toggle");
+  const budget = opts.find((o) => o?.type === "budget_tokens");
+  const input = Array.isArray(m?.modalities?.input) ? m.modalities.input : [];
+  return {
+    reasoning: Boolean(m?.reasoning),
+    effortType: effort ? "effort" : toggle ? "toggle" : budget ? "budget_tokens" : null,
+    effortValues: effort && Array.isArray(effort.values) ? effort.values.map(String) : null,
+    imageInput: input.includes("image"),
+    toolCall: Boolean(m?.tool_call),
+    context: Number(m?.limit?.context) || null,
+    maxOutput: Number(m?.limit?.output) || null,
+    costIn: Number(m?.cost?.input) || null,
+    costOut: Number(m?.cost?.output) || null,
+    // opencode Model 形状补充字段（-setto opencode 条目注入用）
+    attachment: Boolean(m?.attachment),
+    temperature: Boolean(m?.temperature),
+    releaseDate: typeof m?.release_date === "string" && m.release_date ? m.release_date : null,
+    inputModalities: input.length ? input : ["text"],
+    outputModalities: Array.isArray(m?.modalities?.output) && m.modalities.output.length ? m.modalities.output : ["text"],
+  };
+}
+
+// provider.models 对象（{ [modelId]: rawModel }）→ { [modelId]: caps }
+export function normalizeProviderModels(modelsObj) {
+  const out = {};
+  if (!modelsObj || typeof modelsObj !== "object") return out;
+  for (const [id, m] of Object.entries(modelsObj)) {
+    if (!m || typeof m !== "object") continue;
+    out[id] = normalizeModelCaps(id, m);
+  }
+  return out;
+}
+
+// workbuddy 上游原生字段（/console/enterprises/personal/models，first-party 最准）→ 统一 caps 形状
+// 实测字段（2026-09-11，29 模型全覆盖）：maxInputTokens/maxOutputTokens/supportsImages/
+// supportsReasoning/reasoning{effort,summary}/supportsToolCall/disabledMultimodal/credits/tags/name/vendor
+// reasoning 是"当前档位"非档位列表 → effortType=effort 但 effortValues=null、defaultEffort 记默认档
+export function normalizeWorkbuddyCaps(_id, m) {
+  const imageOk = Boolean(m?.supportsImages) && !m?.disabledMultimodal;
+  const reasoning = Boolean(m?.supportsReasoning);
+  const effort = reasoning && m?.reasoning && typeof m.reasoning === "object" ? String(m.reasoning.effort || "").trim() : "";
+  return {
+    reasoning,
+    effortType: reasoning ? "effort" : null,
+    // 上游只给当前档位不给档位列表；实测 hy3 reasoning_effort low/high 均生效（思考块 99 vs 210），
+    // 网关层按 OpenAI 兼容标准给通用三档（上游不识别时忽略，无害）
+    effortValues: reasoning ? ["low", "medium", "high"] : null,
+    defaultEffort: effort || null,
+    imageInput: imageOk,
+    toolCall: Boolean(m?.supportsToolCall),
+    context: Number(m?.maxInputTokens) || null,
+    maxOutput: Number(m?.maxOutputTokens) || null,
+    costIn: null,
+    costOut: null,
+    attachment: false,
+    temperature: m?.temperature != null,
+    releaseDate: null,
+    inputModalities: imageOk ? ["text", "image"] : ["text"],
+    outputModalities: ["text"],
+  };
+}

package/src/providers/base.js

@@ -1,6 +1,7 @@
 import { createKeyRing } from "./keyring.js";
 import { joinModelId } from "./model-id.js";
 import { getUndici as compatGetUndici, compatFetch } from "../compat.js";
+import { createSdkDispatch } from "../upstream-engine/sdk/dispatch.js";
 
 const { fetch: UndiciFetch, Agent: UndiciAgent } = compatGetUndici();
 
@@ -44,8 +45,17 @@ export function collectApiKeysGeneric(id, apiKeys, apiKey, loadKeys) {
   return [...new Set(list.map((k) => k.trim()))];
 }
 
-export function createChatRunner({ id, ring, cooldownMs, retry, fetchImpl, dispatcher, buildHeaders, getUrl, connectTimeoutMs = 30_000 }) {
+export function createChatRunner({ id, ring, cooldownMs, retry, fetchImpl, dispatcher, buildHeaders, getUrl, connectTimeoutMs = 30_000, sdkDispatch } = {}) {
+  // SDK 通道（缺省）：仅流式；非流式委派原生，避免把 JSON 客户端 SSE 化。
+  const sdk = sdkDispatch === undefined ? createSdkDispatch({ id, providerName: id }) : sdkDispatch;
+
   async function attemptOnce(url, body, key, activeRing) {
+    if (sdk?.enabled && body?.stream !== false) {
+      let r;
+      try { r = await sdk.trySdk({ url, body, headers: buildHeaders(body, key), fetchImpl }); }
+      catch (err) { return err; } // 交 runChat 的 network 重试/冷却
+      if (r) return r.status === 401 && !activeRing.size ? { __needKey: true } : r;
+    }
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error(`${id} timed out after ${connectTimeoutMs}ms`)), connectTimeoutMs);
     try {

package/src/providers/classify.js

@@ -0,0 +1,22 @@
+// ADR-0015：供应商路由分类三态 + EMA 纯函数（零依赖，防循环 import）
+// local-only：本机账号绑定（workbuddy），组员转发无效
+// quota-pool：图额度不图速度（opencode free），直连先行、429 后组员兜底
+// latency-compare：key/token 类，direct vs link+remote 比延迟
+export function classifyProvider(id) {
+  const s = String(id || "").trim().toLowerCase();
+  if (s === "workbuddy") return "local-only";
+  if (s === "opencode") return "quota-pool";
+  return "latency-compare";
+}
+
+// EMA（α=0.3）：prev 为空取 now；now 非法样本不参与；两者皆非法返 null
+// 0ms 是合法样本（本地/瞬时响应），只有 null/undefined/NaN/负数才非法
+export function emaMerge(prev, now, alpha = 0.3) {
+  const norm = (v) => (v === null || v === undefined ? null : (Number.isFinite(Number(v)) && Number(v) >= 0 ? Number(v) : null));
+  const a = norm(prev);
+  const b = norm(now);
+  if (a === null && b === null) return null;
+  if (a === null) return Math.round(b);
+  if (b === null) return Math.round(a);
+  return Math.round(a * (1 - alpha) + b * alpha);
+}

package/src/providers/cline/chat.js

@@ -1,6 +1,7 @@
 import { joinUrl, sleep } from "../base.js";
 import { clineHeaders } from "./headers.js";
 import { createTransport } from "../../transport/index.js";
+import { createSdkDispatch } from "../../upstream-engine/sdk/dispatch.js";
 
 function genSessionId() { return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`; }
 
@@ -70,12 +71,18 @@ export function createChatService({
   const resolvedBase = String(baseUrl).trim().replace(/\/+$/, "");
   const resolvedChat = chatPath || (String(resolvedBase).includes("/api/v1") ? "/chat/completions" : "/api/v1/chat/completions");
   const transport = createTransport({ fetchImpl, dispatcher, keepAlive: !!dispatcher, timeoutMs: connectTimeoutMs, retry: {} });
+  const sdk = createSdkDispatch({ id, providerName: id || "cline" });
 
-  async function clineFetch(body, sessionId) {
+  async function clineFetch(body, sessionId, allowSdk = false) {
     const token = await authPool.getAccessToken();
     const headers = clineHeaders(sessionId, token);
     const finalUrl = joinUrl(resolvedBase, resolvedChat);
     const isStream = body?.stream === true;
+    // SDK 通道（缺省）：仅客户端显式流式；forceStream 聚合与非流式保持原生（避免丢 nonStreamWithContentCheck）。
+    if (allowSdk && sdk.enabled) {
+      const r = await sdk.trySdk({ url: finalUrl, body, headers, fetchImpl });
+      if (r) return r;
+    }
     return transport.request({ url: finalUrl, headers, body, stream: isStream, timeoutMs: connectTimeoutMs });
   }
 
@@ -85,14 +92,22 @@ export function createChatService({
     return false;
   }
 
-  async function clineFetchWithRetry(body, sessionId) {
+  async function clineFetchWithRetry(body, sessionId, allowSdk = false) {
     const maxRetries = 4;
     let lastResp = null;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const resp = await authPool.enqueue(() => clineFetch(body, sessionId));
-      lastResp = resp;
+      const resp0 = await authPool.enqueue(() => clineFetch(body, sessionId, allowSdk));
+      let resp = resp0;
       let bodyText = "";
-      if (resp.status !== 200) { try { bodyText = await resp.text(); } catch {} }
+      if (resp.status !== 200) {
+        try { bodyText = await resp.text(); } catch {}
+        // 错误响应体已在此读走：原生 transport 的 text() 有缓存，而 SDK Response 的 body 一次性，
+        // 重建以便上层/客户端仍能读到错误详情（如 429 的 INFERENCE_CAP_ERROR）。
+        try {
+          resp = new Response(bodyText, { status: resp0.status, statusText: resp0.statusText, headers: new Headers(resp0.headers) });
+        } catch {}
+      }
+      lastResp = resp;
       const hit = isLimitHit(resp.status, bodyText);
       if (hit) {
         const { parseCooldown } = await import("./auth.js");
@@ -174,7 +189,7 @@ export function createChatService({
     }
     for (let netAttempt = 0; netAttempt < 3; netAttempt++) {
       try {
-        const resp = await clineFetchWithRetry(upstreamBody, sessionId);
+        const resp = await clineFetchWithRetry(upstreamBody, sessionId, isStream);
         if (!resp) throw new Error("empty response");
         if (!resp.ok) return resp;
         if (isStream) return resp;