mslxdff 0.1.110 → 0.1.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.110",
+  "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/model-capabilities/enrich.js

@@ -12,6 +12,10 @@ function splitProvider(modelId) {
 }
 
 // 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 = {
@@ -22,6 +26,9 @@ function capsToEntryFields(caps) {
     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 };
@@ -30,8 +37,9 @@ function capsToEntryFields(caps) {
 }
 
 // entry: 现有条目（含 name 等）；modelId: 内部 canonical id；capsSvc: 可注入（默认全局单例）
+// wbSource: workbuddy 动态源接缝（测试注入；生产 = workbuddyAllModels 上游原生字段）
 // 返回 { entry: 增强后条目, caps: caps|null }；服务异常静默降级（同步命令不能因目录拉取失败而挂）
-export async function enrichOpencodeEntry(entry, modelId, capsSvc) {
+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 };
@@ -42,6 +50,12 @@ export async function enrichOpencodeEntry(entry, modelId, capsSvc) {
     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 兜底在服务内已做）
   }
@@ -61,7 +75,7 @@ export function capsSummary(caps) {
   } else if (caps.effortType === "budget_tokens") {
     parts.push("推理 budget_tokens");
   } else if (caps.reasoning) {
-    parts.push("推理模型");
+    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}`);

package/src/model-capabilities/index.js

@@ -4,7 +4,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { normalizeProviderModels } from "./parse.js";
+import { normalizeProviderModels, normalizeWorkbuddyCaps } from "./parse.js";
 import { compatFetch } from "../compat.js";
 
 export const DEFAULT_SOURCE_URL = "https://models.opencode.ai/api.json";
@@ -128,3 +128,36 @@ function defaultCacheFile() {
   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

@@ -37,3 +37,32 @@ export function normalizeProviderModels(modelsObj) {
   }
   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;

package/src/providers/model-id.js

@@ -131,4 +131,33 @@ export function normalizeFullId(id, knownProviders = []) {
     return `${head}/${s.slice(idx + 1)}`;
   }
   return `${DEFAULT_PROVIDER}/${s}`;
+}
+
+const BUILTIN_PROVIDERS = new Set([DEFAULT_PROVIDER, "openrouter"]);
+
+/**
+ * 过滤 provider 已不存在的 picks 孤儿（纯函数，零 IO，可单测）。
+ * - 含 `/` 前缀：head（归一+小写）∉ 已知集合 → stale（如 amddev/*）。
+ * - Bare id：∉ 上游 liveIds ∪ allowlist 展开 → stale（如 laguna-s-2.1-free）。
+ * - provider 存在但未启用（如 deepseek 缺 baseUrl）→ 保留，不可用由 [error] 表达。
+ * - 未知一律保留（默认放行不误删显示）；dash 别名经 resolveAlias 还原后判定；
+ *   上游 liveIds 为空时 bare 一律保留（无法判定则放行）。
+ * 数据不动，只决定进不进 `-models` 交互列表 — 见 .scratch/models-stale-picks/SPEC.md。
+ */
+export function filterStalePicks(pickedIds, { knownProviders = [], liveIds = [], allowedIds = [], resolveAlias = getModelAlias } = {}) {
+  const known = new Set([...BUILTIN_PROVIDERS, ...(knownProviders || []).map((p) => normalizeProviderId(p).toLowerCase())]);
+  const live = new Set((liveIds || []).map((id) => String(id).toLowerCase()));
+  const allowed = new Set((allowedIds || []).map((id) => String(id).toLowerCase()));
+  return (pickedIds || []).filter((pick) => {
+    const raw = String(pick || "").trim();
+    if (!raw) return false;
+    let id = raw;
+    try { id = resolveAlias(raw) || raw; } catch { id = raw; }
+    const slash = String(id).indexOf("/");
+    if (slash > 0) return known.has(normalizeProviderId(id.slice(0, slash)).toLowerCase());
+    // 上游列表为空（刷新与缓存双失败的极端情况）时无法判定 bare 生死 → 保留（默认放行）
+    if (live.size === 0) return true;
+    const low = String(id).toLowerCase();
+    return live.has(low) || allowed.has(low);
+  });
 }

package/src/providers/workbuddy/chat.js

@@ -3,6 +3,8 @@ import { isAuthError, isInsufficientStatus } from "./auth.js";
 import { appendRotationLog as defaultAppend } from "./rotation-log.js";
 import { createTransport } from "../../transport/index.js";
 import { reshapeWorkbuddySse } from "./reshape.js";
+import { attemptOnceSdk } from "./sdk-chat.js";
+import { resolveEngineMode } from "../../upstream-engine/mode.js";
 
 function buildAuthHeaders(key, auth) {
   const h = {
@@ -79,7 +81,24 @@ export function createChatService({
     return { uid: "", domain: "www.codebuddy.cn", enterpriseId: "", refreshToken: "" };
   }
 
+  // SDK 通道（缺省启用）：缺省底层走 @ai-sdk/openai-compatible，`legacy`/关闭词
+  // （局部 MSLXDFF_WORKBUDDY_SDK，未设则继承全局 MSLXDFF_UPSTREAM_ENGINE）回退原生 transport；
+  // 不可用（Node16/未安装）自动回退并告警一次。上层轮换/刷新/reshape 全链复用。
+  // Note: 为什么默认 SDK、翻译层代价与回退语义 — 见 .agents/notes/implemented/feature/2026-09-12-workbuddy-sdk-channel.md
+  const engineMode = resolveEngineMode(process.env, "MSLXDFF_WORKBUDDY_SDK");
+  let sdkFallbackLogged = false;
   async function fetchOnce(url, body, key, auth) {
+    if (engineMode === "sdk") {
+      try {
+        return await attemptOnceSdk({ url, body, key, auth, buildHeaders: buildAuthHeaders });
+      } catch (e) {
+        if (!e || !e._sdkLoadFailed) throw e;
+        if (!sdkFallbackLogged) {
+          sdkFallbackLogged = true;
+          try { console.error(`[workbuddy] ${e.message} — 回退原生通道`); } catch {}
+        }
+      }
+    }
     return transport.request({ url, headers: buildAuthHeaders(key, auth), body: { ...body, stream: true }, stream: true });
   }
 

package/src/providers/workbuddy/reshape.js

@@ -107,24 +107,31 @@ export function reshapeWorkbuddySse(res) {
     async pull(controller) {
       if (closed) { try { controller.close(); } catch {} return; }
       try {
-        const { done, value } = await reader.read();
-        if (done) {
-          closed = true;
+        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
+        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
+        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
+        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
+        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            closed = true;
+            const out = [];
+            if (buf) { processInto(buf + "\n", out); buf = ""; }
+            flushReasoningInto(out);
+            if (out.length) controller.enqueue(encoder.encode(out.join("")));
+            controller.close();
+            return;
+          }
+          buf += decoder.decode(value, { stream: true });
+          const idx = buf.lastIndexOf("\n");
+          if (idx < 0) continue;
+          const complete = buf.slice(0, idx + 1);
+          buf = buf.slice(idx + 1);
           const out = [];
-          if (buf) { processInto(buf + "\n", out); buf = ""; }
-          flushReasoningInto(out);
-          if (out.length) controller.enqueue(encoder.encode(out.join("")));
-          controller.close();
-          return;
+          processInto(complete, out);
+          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
         }
-        buf += decoder.decode(value, { stream: true });
-        const idx = buf.lastIndexOf("\n");
-        if (idx < 0) return;
-        const complete = buf.slice(0, idx + 1);
-        buf = buf.slice(idx + 1);
-        const out = [];
-        processInto(complete, out);
-        if (out.length) controller.enqueue(encoder.encode(out.join("")));
       } catch {
         closed = true;
         try { controller.close(); } catch {}

package/src/providers/workbuddy/sdk-chat.js

@@ -0,0 +1,25 @@
+// workbuddy SDK 实验通道（薄壳）：转调共用执行器 upstream-engine/sdk/attempt.js。
+// 契约保持：attemptOnceSdk({url, body, key, auth, buildHeaders}) → Response（SSE）。
+// HTTP 错误映射与 _sdkLoadFailed 语义在共用层；本壳只注入 workbuddy 特有参数。
+// 见 .scratch/workbuddy-sdk-channel/SPEC.md。
+import { attemptOnceSdk as attemptGeneric, sdkBaseFromUrl } from "../../upstream-engine/sdk/attempt.js";
+
+export { sdkBaseFromUrl };
+
+let channelLogged = false;
+
+export async function attemptOnceSdk({ url, body, key, auth, buildHeaders, clock = Date.now } = {}) {
+  const out = await attemptGeneric({
+    url,
+    body,
+    headers: buildHeaders ? buildHeaders(key, auth) : {},
+    providerName: "workbuddy",
+    marker: { name: "x-mslxdff-workbuddy-channel", value: "sdk" },
+    clock,
+  });
+  if (!channelLogged) {
+    channelLogged = true;
+    try { console.error(`[workbuddy-sdk-channel] active via @ai-sdk/openai-compatible (model=${body?.model || ""} uid=${auth?.uid || ""})`); } catch {}
+  }
+  return out;
+}

package/src/routes/hedge.js

@@ -18,8 +18,8 @@ function shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, mod
   if (!canForwardPeers) return false;
   if (!hasPeers) return false;
   if (!d || d <= 0) return false;
-  // 不做供应商级禁对冲特判：对冲仅按 useGroup/流式/peer 可用性决定
-  // muse-spark 走 /responses 流式（event: 包装 + 加密 reasoning），组员旧版无此整形且聚合 JSON 带错 header，必抢赢本地慢首块，需本地直出
+  // 供应商级禁对冲在 shouldUseGroupForModel 层收敛（workbuddy local-only 硬禁，见 ADR-0015）；
+  // 这里只留 muse-spark 特判：走 /responses 流式（event: 包装 + 加密 reasoning），组员旧版无此整形且聚合 JSON 带错 header，必抢赢本地慢首块，需本地直出
   if (String(model || "").toLowerCase().startsWith("muse-spark")) return false;
   return true;
 }