dsh-decision-engine 0.6.1 → 0.7.0

package/lib/index.js

@@ -28,7 +28,6 @@ import { dirname, join } from "node:path";
 import z from "@deepseek-ai/schemastery";
 
 import { DecisionCache } from "./decision-cache.js";
-import { TokenBudget } from "./budget.js";
 import { DECISION_POINTS, POINT_MODES, readPointModes } from "./decision-points.js";
 import { createDecisionRunner } from "./engine.js";
 import { POINT_SPECS } from "./points/spec.js";
@@ -89,6 +88,16 @@ const DEFAULTS = {
   model: DEFAULT_MODEL,
   /** system one 的模型字段；留空 = 由服务端选默认（jev-latest）。 */
   systemoneModel: "",
+  /**
+   * 硅基流动 / Silicon Flow 的模型字段。
+   *
+   * 刻意留空、不在这里钉模型名：这两个端点把 `model` 列为必填（实测省略或
+   * 空串都回 400 `Model field is required.`），「留空」的语义由
+   * `resolveProvider` 解释为「用预设默认 Kev-4B」。填了就以填的为准
+   * （想换 SemIf 填 SemIf），两条路都不会发出注定失败的请求。
+   */
+  siliconflowModel: "",
+  siliconflowIntlModel: "",
   /** 自定义 provider：地址、端点风格、鉴权、请求头、模型。 */
   customBaseUrl: "",
   customEndpointStyle: "auto",
@@ -97,11 +106,15 @@ const DEFAULTS = {
   /** 各 provider 的显式 key（与变量名分开存，互不覆盖）。 */
   systemoneApiKey: "",
   bamboonodeApiKey: "",
+  siliconflowApiKey: "",
+  siliconflowIntlApiKey: "",
   customModel: "",
   customHeaders: "",
   /** 各预设的密钥来源变量名，留空即用预设内置值。 */
   bamboonodeApiKeyEnv: "",
   systemoneApiKeyEnv: "",
+  siliconflowApiKeyEnv: "",
+  siliconflowIntlApiKeyEnv: "",
   /**
    * 密钥保存位置：
    *   credentials = ~/.dsh/.credentials.yaml 的 refs 段（默认，与其他服务统一托管）
@@ -187,9 +200,6 @@ const DEFAULTS = {
   pointSkillPick: "off",
   pointCotTranslate: "off",
   // ---- 自身开销护栏 ----------------------------------------------------
-  // 决策模型每次约 1.9k token；不设上限时，多决策点会把它变成主要消耗方。
-  budgetTokens: 400000,
-  budgetWindowMs: 3600000,
   cacheTtlMs: 600000,
 };
 
@@ -209,7 +219,10 @@ export const Config = z.object({
   provider: z.union([...PROVIDER_IDS]).default(DEFAULTS.provider)
     .description(
       "systemone = 任意 system-one 风格服务（TypeSafe / 自建 llama.cpp）；"
-        + "bamboonode = StartLux 官方端点（原有默认）；custom = 自己填地址",
+        + "bamboonode = StartLux 官方端点（原有默认）；"
+        + "siliconflow = 硅基流动（api.siliconflow.cn，POST /v1/systemone）；"
+        + "siliconflow-intl = Silicon Flow 国际站（api.siliconflow.com）；"
+        + "custom = 自己填地址",
     ),
   baseUrl: z.string().default(DEFAULTS.baseUrl)
     .description("bamboonode 预设的地址覆盖；/v1 与 /v1/decisions 两种写法都接受"),
@@ -217,6 +230,10 @@ export const Config = z.object({
     .description("bamboonode 预设的模型 id；留空表示由服务端选默认"),
   systemoneModel: z.string().default(DEFAULTS.systemoneModel)
     .description("system one 预设的模型 id；留空表示由服务端选默认（jev-latest）"),
+  siliconflowModel: z.string().default(DEFAULTS.siliconflowModel)
+    .description("硅基流动预设的模型 id；留空用预设默认 Kev-4B（该端点 model 必填，不可省略）"),
+  siliconflowIntlModel: z.string().default(DEFAULTS.siliconflowIntlModel)
+    .description("Silicon Flow 国际站预设的模型 id；留空用预设默认 Kev-4B（该端点 model 必填）"),
   customBaseUrl: z.string().default(DEFAULTS.customBaseUrl)
     .description("provider=custom 时的 base URL，必须是 http/https 地址"),
   customEndpointStyle: z.union([...ENDPOINT_STYLES]).default(DEFAULTS.customEndpointStyle)
@@ -227,6 +244,10 @@ export const Config = z.object({
     .description("system one 的 API key；留空则读 TYPESAFE_API_KEY"),
   bamboonodeApiKey: z.string().role("secret").default(DEFAULTS.bamboonodeApiKey)
     .description("bamboonode 的 API key；留空则读 BAMBOO_API_KEY"),
+  siliconflowApiKey: z.string().role("secret").default(DEFAULTS.siliconflowApiKey)
+    .description("硅基流动的 API key；留空则读 SILICONFLOW_API_KEY"),
+  siliconflowIntlApiKey: z.string().role("secret").default(DEFAULTS.siliconflowIntlApiKey)
+    .description("Silicon Flow 国际站的 API key；留空则读 SILICONFLOW_INTL_API_KEY"),
   customApiKeyEnv: z.string().default(DEFAULTS.customApiKeyEnv)
     .description("custom 的密钥来源变量名（环境变量或 .credentials.yaml 的 refs 键）"),
   customModel: z.string().default(DEFAULTS.customModel)
@@ -237,6 +258,10 @@ export const Config = z.object({
     .description("bamboonode 预设的密钥变量名覆盖；留空用 BAMBOO_API_KEY"),
   systemoneApiKeyEnv: z.string().default(DEFAULTS.systemoneApiKeyEnv)
     .description("systemone 预设的密钥变量名覆盖；留空用 TYPESAFE_API_KEY"),
+  siliconflowApiKeyEnv: z.string().default(DEFAULTS.siliconflowApiKeyEnv)
+    .description("siliconflow 预设的密钥变量名覆盖；留空用 SILICONFLOW_API_KEY"),
+  siliconflowIntlApiKeyEnv: z.string().default(DEFAULTS.siliconflowIntlApiKeyEnv)
+    .description("siliconflow-intl 预设的密钥变量名覆盖；留空用 SILICONFLOW_INTL_API_KEY"),
   apiKey: z.string().role("secret")
     .description("当前 provider 的 API key；留空则读 apiKeyEnv 指定的环境变量"),
   apiKeyEnv: z.string().default(DEFAULTS.apiKeyEnv)
@@ -319,9 +344,6 @@ export const Config = z.object({
         .description(`${point.label}：off 不参与 / observe 只记录 / enforce 生效`),
     ]),
   ),
-  budgetTokens: z.number().step(1).min(0).default(DEFAULTS.budgetTokens)
-    .description("决策模型自身每窗口的 token 上限；0 表示不限制。超限后自动退回启发式"),
-  budgetWindowMs: z.number().step(1).min(60000).default(DEFAULTS.budgetWindowMs),
   cacheTtlMs: z.number().step(1).min(1000).default(DEFAULTS.cacheTtlMs)
     .description("缓存存活时间；改策略或配置后旧裁决不应继续被复用"),
 });
@@ -455,7 +477,11 @@ export function validateProviderPatch(patch, current) {
   }
 
   // 变量名必须能当环境变量用，否则凭据永远读不到。
-  for (const key of ["customApiKeyEnv", "bamboonodeApiKeyEnv", "systemoneApiKeyEnv"]) {
+  // 逐个预设取它自己的变量名覆盖字段，而不是写死三个名字——否则新增预设时
+  // 漏加这一项，用户填的变量名会被原样写进 yml，然后永远读不到 key
+  //（守卫是 fail-open 的，症状又是「配了没反应」）。
+  for (const preset of Object.values(PROVIDER_PRESETS)) {
+    const key = preset.keyEnvField;
     if (!Object.hasOwn(patch, key)) continue;
     const value = typeof patch[key] === "string" ? patch[key].trim() : "";
     if (value.length === 0) continue;
@@ -936,16 +962,12 @@ class StartluxClient {
     // 遥测目录由 apply() 注入：它要兼顾「更名前的旧目录里已有历史记录」，
     // 这个判断需要文件系统探测，不适合放进纯客户端。
     this.telemetryDir = options.telemetryDir;
-    // 缓存与预算都传「取值函数」而不是快照：与 endpoint/model/key 同一套
+    // 缓存也传「取值函数」而不是快照：与 endpoint/model/key 同一套
     // 原则——配置改了立刻对下一次生效，不要求重启。
     this.cache = new DecisionCache(
       () => this.getConfig().cacheSize,
       () => this.getConfig().cacheTtlMs,
     );
-    this.budget = new TokenBudget(
-      () => this.getConfig().budgetTokens,
-      () => this.getConfig().budgetWindowMs,
-    );
     this.failures = 0;
     this.cooldownUntil = 0;
     this.lastDegrade = undefined;
@@ -1032,19 +1054,15 @@ class StartluxClient {
         provider: provider.id,
         hint:
           provider.apiKeyEnv.length > 0
-            ? `设置 apiKey（或 customApiKey）或导出 $${provider.apiKeyEnv}`
-            : "为 custom provider 填写 customApiKey，或设置 customApiKeyEnv",
+            // 指名该 provider 自己的字段（siliconflowApiKey / bamboonodeApiKey /
+            // customApiKey …）。写死 apiKey 会让人把 key 填进 bamboonode 的格子，
+            // 而其它 provider 并不读它——遥测里就会出现「填了 key 仍报 no-key」。
+            ? `设置 ${provider.preset?.keyField ?? "apiKey"} 或导出 $${provider.apiKeyEnv}`
+            : `为 ${provider.id} 填写 ${provider.preset?.keyField ?? "自定义 key 字段"}，或设置 ${provider.preset?.keyEnvField ?? "密钥变量名"}`,
       });
     }
     if (Date.now() < this.cooldownUntil) return degrade("cooldown");
 
-    // 预算闸：决策模型自己也烧 token。超限就退回启发式并 fail-open，
-    // 等窗口滚过去自动恢复——绝不因为「省钱的东西」把活卡住。
-    if (this.budget.exhausted()) {
-      this.budget.noteBlocked();
-      return degrade("budget-exhausted", { budget: this.budget.report });
-    }
-
     const endpoint = provider.endpoint;
     // 允许留空：不发送 model 字段时，服务端会用它当前的默认决策模型
     //（实测省略 model 返回 200 且 model 回填为实际使用的模型）。
@@ -1065,8 +1083,8 @@ class StartluxClient {
       return { ...hit, cached: true, latencyMs: 0 };
     }
 
-    const budget = Math.max(1000, cfg.timeoutMs);
-    const timer = AbortSignal.timeout(budget);
+    const timeoutMs = Math.max(1000, cfg.timeoutMs);
+    const timer = AbortSignal.timeout(timeoutMs);
     const signal = call.signal === undefined ? timer : AbortSignal.any([call.signal, timer]);
 
     this.stats.requests += 1;
@@ -1111,7 +1129,7 @@ class StartluxClient {
       if (call.signal?.aborted) return degrade("caller-aborted");
       if (timer.aborted || error?.name === "AbortError") {
         this.noteFailure();
-        return degrade("timeout", { budgetMs: budget, endpoint: usedEndpoint });
+        return degrade("timeout", { timeoutMs, endpoint: usedEndpoint });
       }
       this.noteFailure();
       return degrade("network-error", {
@@ -1197,8 +1215,6 @@ class StartluxClient {
     counter.latencyMax = Math.max(counter.latencyMax, result.latencyMs);
     if (typeof inputTokens === "number") {
       counter.tokens += inputTokens;
-      // 记进自身预算：这是「省钱插件」自己的花销。
-      this.budget.spend(inputTokens);
     }
 
     this.cache.set(exactKey, result);
@@ -1369,14 +1385,18 @@ export function apply(ctx, config) {
     /** 本次要写进 yml 的键值。 */
     const ymlPatch = { ...patch };
 
-    // provider → 它的显式 key 字段名与 refs 键名
-    const slots = [
-      { keyField: "systemoneApiKey", refName: current.systemoneApiKeyEnv || "TYPESAFE_API_KEY" },
-      { keyField: "bamboonodeApiKey", refName: current.bamboonodeApiKeyEnv || "BAMBOO_API_KEY" },
-      { keyField: "customApiKey", refName: current.customApiKeyEnv || "DECISION_ENGINE_CUSTOM_KEY" },
-      // 历史共享字段：老前端只认 apiKey，按 bamboonode 处理
-      { keyField: "apiKey", refName: current.bamboonodeApiKeyEnv || "BAMBOO_API_KEY" },
-    ];
+    // provider → 它的显式 key 字段名与 refs 键名。
+    // 逐个预设生成而不是写死：漏掉一个 provider，它的 key 就会**绕过凭据文件
+    // 直接以明文写进 config.yml**——那是「托管到凭据文件」这条承诺的破口。
+    const slots = Object.values(PROVIDER_PRESETS).map((preset) => {
+      const override = typeof current[preset.keyEnvField] === "string" ? current[preset.keyEnvField].trim() : "";
+      return { keyField: preset.keyField, refName: override.length > 0 ? override : preset.apiKeyEnv };
+    });
+    // 历史共享字段：老前端只认 apiKey，按 bamboonode 处理
+    slots.push({
+      keyField: "apiKey",
+      refName: current.bamboonodeApiKeyEnv || PROVIDER_PRESETS.bamboonode.apiKeyEnv,
+    });
 
     for (const slot of slots) {
       if (!Object.hasOwn(patch, slot.keyField)) continue;
@@ -1548,7 +1568,7 @@ export function apply(ctx, config) {
   // ---- 其余八个决策点 ----------------------------------------------------
   //
   // 与工具授权不同，这八个点共用一条 execution 链路（engine.js）：模式判断、
-  // 预算、冷却、答案校验、遥测都由 runner.ask() 统一处理，适配器只负责
+  // 冷却、答案校验、遥测都由 runner.ask() 统一处理，适配器只负责
   // 「给出 state」与「落地副作用」。这样任何一处降级逻辑都不会漏。
   const runner = createDecisionRunner({
     getConfig,
@@ -1641,8 +1661,13 @@ export function apply(ctx, config) {
         ok: false,
         text:
           `未找到 API key（provider: ${provider.id}）：\n` +
-          `请设置 config.apiKey${provider.id === "custom" ? " / customApiKey" : ""}` +
-          (provider.apiKeyEnv.length > 0 ? `，或导出 $${provider.apiKeyEnv}` : "，或设置 customApiKeyEnv"),
+          // 指名该 provider 自己的那一格（bamboonodeApiKey / siliconflowApiKey /
+          // customApiKey …）。写死 apiKey 会让人把 key 填进 bamboonode 的字段，
+          // 而其它 provider 根本不读它——「填了 key 还是说没 key」就是这么来的。
+          `请在 ${CONFIG_FILE_NAME} 写 ${provider.preset?.keyField ?? "显式 key 字段"}，` +
+          (provider.apiKeyEnv.length > 0
+            ? `或导出 $${provider.apiKeyEnv}（也可存入 .credentials.yaml 的 refs 段）`
+            : `或设置 ${provider.preset?.keyEnvField ?? "密钥变量名"}`),
       };
     }
     const started = Date.now();
@@ -1670,7 +1695,13 @@ export function apply(ctx, config) {
       );
       const response = result.response;
       const elapsed = Date.now() - started;
-      const requestId = response?.headers?.get?.("x-oneapi-request-id") ?? "(无)";
+      // 追踪 id 各家名字不同：bamboonode 走 x-oneapi-request-id，SiliconFlow
+      // 走 x-siliconcloud-trace-id（实测）。只读一家会让另一家的诊断永远显示
+      //「(无)」，而排查问题时这个 id 是唯一的抓手。
+      const requestId =
+        response?.headers?.get?.("x-oneapi-request-id")
+        ?? response?.headers?.get?.("x-siliconcloud-trace-id")
+        ?? "(无)";
       let bodyTextOut = "";
       try {
         bodyTextOut = (await response.text()).slice(0, 300);
@@ -1818,6 +1849,28 @@ export function apply(ctx, config) {
         defaultModel: provider.defaultModel,
         rawModel: provider.model,
         rawSystemoneModel: typeof cfg.systemoneModel === "string" ? cfg.systemoneModel : "",
+        rawSiliconflowModel: typeof cfg.siliconflowModel === "string" ? cfg.siliconflowModel : "",
+        rawSiliconflowIntlModel:
+          typeof cfg.siliconflowIntlModel === "string" ? cfg.siliconflowIntlModel : "",
+        /**
+         * 全部 provider 的模型原值，键 = config.yml 里的字段名（model /
+         * systemoneModel / siliconflowModel / …）。
+         *
+         * 上面几项是历史散字段（回显用），这张表是给「模型输入框写回配置」用的：
+         * 界面必须知道当前 provider 的那一格叫什么名字，而名字只有预设表知道。
+         * 由预设表生成并下发，前端就不必为每个 provider 抄一份分支——新增预设
+         * 只改 providers.js 一处，界面的模型框自动接上。
+         *
+         * 值取 cfg 原文而非 provider.model：后者对 requiresModel 的 provider
+         * 已经回落到预设默认（Kev-4B），把它回显成「当前值」会让用户以为自己
+         * 填过模型，进而不知道留空本来就有默认。
+         */
+        rawModels: Object.fromEntries(
+          Object.values(PROVIDER_PRESETS).map((preset) => [
+            preset.modelField,
+            typeof cfg[preset.modelField] === "string" ? cfg[preset.modelField] : "",
+          ]),
+        ),
         // custom 的字段原样回显（除 key 明文）：用户保存后再打开必须看到自己填的值。
         customBaseUrl: cfg.customBaseUrl ?? "",
         customEndpointStyle: cfg.customEndpointStyle ?? "auto",
@@ -1852,9 +1905,8 @@ export function apply(ctx, config) {
         keyEnvName: provider.apiKeyEnv,
         configPath: ownConfigPath,
         stats: client.stats,
-        // 决策点与自身开销：配置页靠这三项显示「哪个点在花多少钱」。
+        // 决策点与缓存：配置页靠这两项显示「哪个点在花多少钱」。
         points: effectivePointModes(cfg),
-        budget: client.budget.report,
         cache: client.cache.report,
       };
     };
@@ -1877,27 +1929,27 @@ export function apply(ctx, config) {
         try {
           const body = JSON.parse(await request.text());
           // 只允许改这些键，避免前端误写任意字段。
+          //
+          // 各 provider 自己的三格（模型 / 显式 key / 密钥变量名）由预设表生成，
+          // 不逐个写死：漏掉一个 provider，界面上「粘贴 key / 选模型」会 200
+          // 成功但什么都没写——正是最难自查的「保存了没生效」。
           const allowed = [
             "enabled",
             "mode",
             "apiKey",
             "baseUrl",
-            "model",
-            "systemoneModel",
             "thinkMode",
             "timeoutMs",
             "provider",
             "customBaseUrl",
             "customEndpointStyle",
-            "customApiKey",
-            "customApiKeyEnv",
-            "customModel",
             "customHeaders",
-            "bamboonodeApiKeyEnv",
-            "systemoneApiKeyEnv",
-            "systemoneApiKey",
-            "bamboonodeApiKey",
             "keyStorage",
+            ...Object.values(PROVIDER_PRESETS).flatMap((preset) => [
+              preset.modelField,
+              preset.keyField,
+              preset.keyEnvField,
+            ]),
           ];
           const patch = {};
           for (const key of allowed) {
@@ -1950,7 +2002,7 @@ export function apply(ctx, config) {
      * 决策点总览与切换。
      *
      * GET  返回注册表 + 当前模式 + 分账实测数据。
-     * PUT  改模式与自身预算。
+     * PUT  改模式。
      *
      * 合成一个注册项按 method 分支，而不是同路径注册两次：
      * DSH 的 fetch 注册表以 path 为键，重复注册会互相覆盖（实测踩过）。
@@ -1994,7 +2046,6 @@ export function apply(ctx, config) {
           };
         }),
         modes: POINT_MODES,
-        budget: client.budget.report,
         cache: client.cache.report,
       };
     };
@@ -2034,9 +2085,6 @@ export function apply(ctx, config) {
               patch[point.key] = mode;
             }
           }
-          if (Number.isFinite(body.budgetTokens)) {
-            patch.budgetTokens = Math.max(0, Math.floor(body.budgetTokens));
-          }
           if (Object.keys(patch).length === 0) return json({ error: "no updatable fields" }, 400);
           await persistConfig(patch);
           // 立即回一份新的总览，前端不必再发一次 GET。
@@ -2086,7 +2134,7 @@ export function apply(ctx, config) {
           const response = await fetch(`${origin}/v1/models`, {
             headers: buildHeaders(provider, key),
             // 列表接口比决策接口慢（实测数秒），且只在用户打开配置页时调用一次，
-            // 用独立预算，不占用决策路径的 timeoutMs。
+            // 用独立超时，不占用决策路径的 timeoutMs。
             signal: AbortSignal.timeout(20000),
           });
           if (!response.ok) {
@@ -2104,10 +2152,21 @@ export function apply(ctx, config) {
           // 放进下拉会让用户选了就失败，因此排除。
           const decisionTypes = ["StartLux Decision", "StartLux SystemOne"];
           const typedOnly = provider.id === "bamboonode";
+          // 预设给了 knownModels 的 provider（SiliconFlow 实测）：它的
+          // /v1/models 会一并返回 98 个模型，其中决策模型只有 Kev-4B / SemIf，
+          // 且**没有任何一条**带 supported_endpoint_types——按类型过滤会得到
+          // 空列表，全收则把 96 个 chat 模型塞进下拉，选一个就是一个 400
+          // `Model does not exist.`。这类端点只认预设清单里的名字。
+          const knownModels = provider.preset?.knownModels ?? [];
           const models = [];
           for (const row of rows) {
             const id = typeof row?.id === "string" ? row.id : "";
             if (id.length === 0) continue;
+            if (knownModels.length > 0) {
+              if (!knownModels.some((name) => name.toLowerCase() === id.toLowerCase())) continue;
+              models.push({ id, types: [] });
+              continue;
+            }
             const types = Array.isArray(row?.supported_endpoint_types) ? row.supported_endpoint_types : [];
             const isDecision = types.some((type) =>
               decisionTypes.some((needle) => String(type).toLowerCase() === needle.toLowerCase()),
@@ -2126,7 +2185,7 @@ export function apply(ctx, config) {
             current: provider.model,
             defaultHint: provider.defaultModel || DEFAULT_MODEL,
             provider: provider.id,
-            filtered: typedOnly,
+            filtered: typedOnly || knownModels.length > 0,
           });
         } catch (error) {
           return json({

package/lib/providers.js

@@ -32,10 +32,13 @@
 /**
  * 可选的 provider 标识。
  *
- * `systemone` / `bamboonode` 是内置预设（默认地址与参数由本模块提供）；
- * `custom` 使用用户在设置界面填写的 base URL 与鉴权信息。
+ * `systemone` / `bamboonode` / `siliconflow` / `siliconflow-intl` 是内置预设
+ *（默认地址与参数由本模块提供）；`custom` 使用用户在设置界面填写的
+ * base URL 与鉴权信息。
+ *
+ * 顺序即设置界面下拉的顺序：常用项在前，`custom` 收尾（它要填的东西最多）。
  */
-export const PROVIDER_IDS = ["systemone", "bamboonode", "custom"];
+export const PROVIDER_IDS = ["systemone", "bamboonode", "siliconflow", "siliconflow-intl", "custom"];
 
 /** 默认 provider。刻意选 bamboonode：老用户的 `startlux.yml` 里没有 provider 键，
  *  必须继续走原来的地址与端点风格，升级不能改变既有行为。 */
@@ -102,7 +105,22 @@ export function normalizeThinkMode(raw) {
  * 内置预设。
  *
  * 每个预设必须给出：显示名称、默认 base URL、端点风格、环境变量名、
- * 默认模型提示。用户选了预设就用这里的值，不需要在设置界面重复填写。
+ * 默认模型与三个配置字段名。用户选了预设就用这里的值，不需要在设置界面
+ * 重复填写。
+ *
+ * 两个可选标记（都是「按服务商实测」得出的，不是风格偏好）：
+ *
+ *   - `requiresModel: true`：该端点**不接受**省略 model 的请求（实测
+ *     SiliconFlow 的 /v1/systemone 省略或空串都回 400
+ *     `Model field is required.`）。这类预设在模型留空时回落到
+ *     `defaultModel`，而不是沿用「留空 = 省略字段」的通用规则——
+ *     那会导致一次注定 400 的请求，而守卫是 fail-open 的，表现为静默失效。
+ *     其余服务商（bamboonode / system one）省略 model 会由服务端回填默认
+ *     模型，保留省略语义才能在它们改名时不失效。
+ *   - `knownModels`：该服务 `/v1/models` 会一并返回大量**非决策**模型且不带
+ *     `supported_endpoint_types`（实测 SiliconFlow 返回 98 个，其中 chat
+ *     模型打到 /v1/systemone 是 400 `Model does not exist.`）。
+ *     列了这份清单就按它筛，不让下拉里出现「选了就失败」的选项。
  */
 export const PROVIDER_PRESETS = {
   systemone: {
@@ -143,6 +161,55 @@ export const PROVIDER_PRESETS = {
     hint: "StartLux 官方端点（POST /v1/decisions），本插件的原有默认值",
     hintEn: "StartLux official endpoint (POST /v1/decisions); the original default",
   },
+  siliconflow: {
+    id: "siliconflow",
+    label: "硅基流动",
+    labelEn: "SiliconFlow",
+    baseUrl: "https://api.siliconflow.cn/v1",
+    // 实测（2026-10-25，真实 key）：该站只认 /systemone，/v1/decisions 回 404。
+    // 因此这里直接给 systemone，不必让 404 回退先烧一次请求。
+    endpointStyle: "systemone",
+    // 两个 SiliconFlow 站点是**两套账号**，key 互不通用，因此各占一格。
+    apiKeyEnv: "SILICONFLOW_API_KEY",
+    legacyApiKeyEnvs: [],
+    keyField: "siliconflowApiKey",
+    // 实测省略 model 会 400 `Model field is required.`，而 bamboonode 省略会
+    // 由服务端回填默认模型。因此这个 provider 必须**总带着一个模型名**——
+    // 留空时回落到下面的 defaultModel，而不是省略字段（见 resolveProvider）。
+    // 这正是「只填一个 API key 就能用」的前提：模型名是预设给好的。
+    requiresModel: true,
+    // /v1/models 里这条就叫 Kev-4B（官方文档两处分别写作 Kev-4b 与 Kev-4B，
+    // 实测三种大小写都 200），取服务返回的写法，免得下拉里出现两条同模型。
+    defaultModel: "Kev-4B",
+    // 官方只支持这两个决策模型；/v1/models 却会一并返回 98 个 chat 模型且
+    // 不带 supported_endpoint_types（实测把 chat 模型打过来是 400
+    // `Model does not exist.`），所以按这份清单筛，不让下拉里出现选了就坏的项。
+    knownModels: ["Kev-4B", "SemIf"],
+    modelField: "siliconflowModel",
+    keyEnvField: "siliconflowApiKeyEnv",
+    hint: "硅基流动（国内站）的 System One 端点（POST /v1/systemone）；可用模型 Kev-4B / SemIf，默认 Kev-4B，只填一个 API key 即可使用",
+    hintEn: "SiliconFlow China (POST /v1/systemone); models Kev-4B / SemIf, default Kev-4B — just add an API key",
+  },
+  "siliconflow-intl": {
+    id: "siliconflow-intl",
+    label: "Silicon Flow",
+    labelEn: "Silicon Flow",
+    baseUrl: "https://api.siliconflow.com/v1",
+    // 同样只认 /systemone：实测打 /v1/decisions 回 404 Not Found。
+    endpointStyle: "systemone",
+    // 与国内站分开：两套账号的 key 不能共用一格，否则切过去就 401，
+    // 而用户看不出是「拿错了 key」还是「key 失效」。
+    apiKeyEnv: "SILICONFLOW_INTL_API_KEY",
+    legacyApiKeyEnvs: [],
+    keyField: "siliconflowIntlApiKey",
+    requiresModel: true,
+    defaultModel: "Kev-4B",
+    knownModels: ["Kev-4B", "SemIf"],
+    modelField: "siliconflowIntlModel",
+    keyEnvField: "siliconflowIntlApiKeyEnv",
+    hint: "Silicon Flow（国际站）的 System One 端点（POST /v1/systemone）；与国内站账号不通用，可用模型 Kev-4B / SemIf，默认 Kev-4B，只填一个 API key 即可使用",
+    hintEn: "Silicon Flow global (POST /v1/systemone); separate account from the CN site, models Kev-4B / SemIf, default Kev-4B — just add an API key",
+  },
   custom: {
     id: "custom",
     label: "custom",
@@ -417,7 +484,17 @@ export function resolveProvider(cfg = {}) {
   // `systemoneModel` 属于 system one。共用一格会把 bamboonode 的模型名发给
   // TypeSafe，得到 400 `model not served`——「切 provider 就坏」的典型来源。
   const modelField = preset.modelField;
-  const model = typeof cfg[modelField] === "string" ? cfg[modelField].trim() : "";
+  const rawModel = typeof cfg[modelField] === "string" ? cfg[modelField].trim() : "";
+  // 模型留空有两种含义，取决于该服务商的端点接不接受「不带 model」的请求：
+  //
+  //   - requiresModel（SiliconFlow 实测）：省略或空串都回 400
+  //     `Model field is required.`，因此留空必须回落到预设的 defaultModel
+  //     ——不发一个注定失败的请求，守卫才不会又一次静默失效。
+  //   - 其余服务商：留空 = 省略字段，由服务端回填默认模型。保留省略语义，
+  //     服务商将来给模型改名时本配置不会失效（反过来把模型名钉死在这里
+  //     才是最脆的那种配法）。
+  const model =
+    rawModel.length > 0 ? rawModel : preset.requiresModel === true ? preset.defaultModel : "";
   // 密钥变量名：`apiKeyEnv` 是**历史字段**，只对 bamboonode 有覆盖意义
   //（老版本只有这一个 provider，用户可能已经在里面写了自己的变量名）。
   // 若让它参与 system one 的解析，会盖掉 TYPESAFE_API_KEY——切到 system one
@@ -542,8 +619,11 @@ export function buildRequestBody(provider, payload) {
  * 供设置界面展示的 provider 清单。
  *
  * 由服务端下发而不是前端硬编码：新增预设只改本文件一处，界面自动多一个选项。
+ * `keyField` / `modelField` 也一并下发——界面写回配置时必须知道「这一格在
+ * config.yml 里叫什么」，而这个名字只有预设表知道；让前端自己再抄一份，
+ * 就是「界面显示存到 A、实际写进 B」这种最难自查的偏差。
  *
- * @returns 每个预设的 id / 显示名 / 默认地址 / 说明。
+ * @returns 每个预设的 id / 显示名 / 默认地址 / 字段名 / 说明。
  */
 export function providerCatalog() {
   return PROVIDER_IDS.map((id) => {
@@ -560,6 +640,14 @@ export function providerCatalog() {
       // 界面用它说明「key 存在配置文件的哪一格」——只报变量名会让人
       // 以为 key 在 .credentials.yaml 里，而实际生效的可能是配置文件。
       keyField: preset.keyField,
+      // 该 provider 的模型字段名（`model` / `systemoneModel` / …）。
+      // 模型输入框按它写回配置，切 provider 不会把 A 的模型名写进 B 那一格。
+      modelField: preset.modelField,
+      // 「模型」那一行的语义全靠这两项：端点是否强制要 model（决定留空的
+      // 写法是「预设默认」还是「服务端默认」），以及能选的模型有哪些。
+      // 都由预设表下发，前端不必知道任何一家服务商的脾气。
+      requiresModel: preset.requiresModel === true,
+      knownModels: [...(preset.knownModels ?? [])],
       hint: preset.hint,
       hintEn: preset.hintEn,
       customizable: id === "custom",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-decision-engine",
-  "version": "0.6.1",
-  "description": "dsh-decision-engine: a cheap judgement layer for DeepSeek Harness — all nine decision points (tool authorization, model routing, delegation, compaction, turn continuation, retrieval, skill pick, session title, COT translation) are implemented and individually switchable, and it works against any system-one style API (system one, bamboonode, or a custom base URL).",
+  "version": "0.7.0",
+  "description": "dsh-decision-engine: a cheap judgement layer for DeepSeek Harness — all nine decision points (tool authorization, model routing, delegation, compaction, turn continuation, retrieval, skill pick, session title, COT translation) are implemented and individually switchable, and it works against any system-one style API (system one, bamboonode, SiliconFlow / Silicon Flow, or a custom base URL).",
   "icon": "./icon.svg",
   "type": "module",
   "main": "lib/index.js",
@@ -36,6 +36,9 @@
     "system-1",
     "typesafe",
     "jev",
+    "siliconflow",
+    "siliconflow-cn",
+    "kev-4b",
     "provider",
     "custom-base-url",
     "tool-approval",

package/lib/budget.js

@@ -1,92 +0,0 @@
-/**
- * 决策模型自身的 token 预算。
- *
- * 引入理由：StartLux 每次决策实测约 1,900 token，p50 延迟约 2 秒。
- * 把这个判断层挂到多个决策点上，调用量会成倍上升——如果不设上限，
- * 「省 token 的插件」反而会变成主要的 token 消耗方。
- *
- * 预算按滑动窗口统计（默认 1 小时）。一旦超限，所有决策点立刻退回
- * 本地启发式并 fail-open，等窗口滚过去自动恢复；不需要重启，也不会
- * 让工具调用被卡住。
- */
-export class TokenBudget {
-  /**
-   * @param getLimitTokens - 返回当前上限的取值函数；0 表示不限制。
-   *   刻意接收函数而不是数值：本插件的原则是「配置每次现读」，
-   *   若在构造时固化，用户在配置页改了预算就得重启才生效。
-   * @param getWindowMs - 返回当前窗口长度的取值函数。
-   */
-  constructor(getLimitTokens, getWindowMs) {
-    this.getLimitTokens = getLimitTokens;
-    this.getWindowMs = getWindowMs;
-    /** @type {Array<{at: number, tokens: number}>} */
-    this.entries = [];
-    this.blocked = 0;
-  }
-
-  /** 当前生效的上限（读不到时按不限制处理，绝不因预算自身出错而卡住决策）。 */
-  get limitTokens() {
-    const raw = typeof this.getLimitTokens === "function" ? this.getLimitTokens() : this.getLimitTokens;
-    const value = Number(raw);
-    return Number.isFinite(value) && value > 0 ? value : 0;
-  }
-
-  /** 当前生效的窗口长度。 */
-  get windowMs() {
-    const raw = typeof this.getWindowMs === "function" ? this.getWindowMs() : this.getWindowMs;
-    const value = Number(raw);
-    return Number.isFinite(value) && value > 0 ? value : 3600000;
-  }
-
-  /** 丢弃窗口外的记录。 */
-  prune(now = Date.now()) {
-    const cutoff = now - this.windowMs;
-    let drop = 0;
-    while (drop < this.entries.length && this.entries[drop].at < cutoff) drop += 1;
-    if (drop > 0) this.entries.splice(0, drop);
-  }
-
-  /** 窗口内已消耗的 token。 */
-  used(now = Date.now()) {
-    this.prune(now);
-    let total = 0;
-    for (const entry of this.entries) total += entry.tokens;
-    return total;
-  }
-
-  /** 预算是否已耗尽（未设置上限时永远 false）。 */
-  exhausted(now = Date.now()) {
-    if (this.limitTokens <= 0) return false;
-    return this.used(now) >= this.limitTokens;
-  }
-
-  /**
-   * 记一次消耗。
-   * @param tokens - 本次估算或实测的 input token 数。
-   */
-  spend(tokens) {
-    const amount = Number.isFinite(tokens) && tokens > 0 ? tokens : 0;
-    if (amount === 0) return;
-    this.entries.push({ at: Date.now(), tokens: amount });
-  }
-
-  /** 记一次「因为预算耗尽而放弃判断」，用于配置页展示。 */
-  noteBlocked() {
-    this.blocked += 1;
-  }
-
-  /** 供 UI 展示的快照。 */
-  get report() {
-    const now = Date.now();
-    const used = this.used(now);
-    const limit = this.limitTokens;
-    return {
-      used,
-      limit,
-      windowMs: this.windowMs,
-      remaining: limit <= 0 ? null : Math.max(0, limit - used),
-      exhausted: this.exhausted(now),
-      blocked: this.blocked,
-    };
-  }
-}