dsh-decision-engine 0.6.0 → 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";
@@ -37,6 +36,7 @@ import { mountRoutePoint } from "./adapters/route.js";
 import { mountAgentPoints } from "./adapters/agent.js";
 import { mountCotTranslatePoint } from "./adapters/translate.js";
 import { applyConfigUpdates, parseConfigText } from "./config-file.js";
+import { EndpointMemory, sendWithEndpointFallback } from "./endpoint-fallback.js";
 import { resolveDshHome } from "./home-paths.js";
 import { applyRefUpdates, listRefNames, pickRefValue } from "./credentials.js";
 import {
@@ -49,6 +49,7 @@ import {
   buildEndpoint,
   buildHeaders,
   buildRequestBody,
+  endpointStyleOfPath,
   normalizeBaseUrl,
   normalizeThinkMode,
   parseCustomHeaders,
@@ -87,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",
@@ -95,11 +106,15 @@ const DEFAULTS = {
   /** 各 provider 的显式 key（与变量名分开存，互不覆盖）。 */
   systemoneApiKey: "",
   bamboonodeApiKey: "",
+  siliconflowApiKey: "",
+  siliconflowIntlApiKey: "",
   customModel: "",
   customHeaders: "",
   /** 各预设的密钥来源变量名，留空即用预设内置值。 */
   bamboonodeApiKeyEnv: "",
   systemoneApiKeyEnv: "",
+  siliconflowApiKeyEnv: "",
+  siliconflowIntlApiKeyEnv: "",
   /**
    * 密钥保存位置：
    *   credentials = ~/.dsh/.credentials.yaml 的 refs 段（默认，与其他服务统一托管）
@@ -185,9 +200,6 @@ const DEFAULTS = {
   pointSkillPick: "off",
   pointCotTranslate: "off",
   // ---- 自身开销护栏 ----------------------------------------------------
-  // 决策模型每次约 1.9k token；不设上限时，多决策点会把它变成主要消耗方。
-  budgetTokens: 400000,
-  budgetWindowMs: 3600000,
   cacheTtlMs: 600000,
 };
 
@@ -207,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 两种写法都接受"),
@@ -215,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)
@@ -225,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)
@@ -235,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)
@@ -317,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("缓存存活时间；改策略或配置后旧裁决不应继续被复用"),
 });
@@ -453,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;
@@ -934,22 +962,26 @@ 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;
     this.stats = { requests: 0, cached: 0, degraded: 0, ok: 0, lastStatus: undefined };
     /** 按决策点分账：不分开统计就无法判断哪个点值得留。 */
     this.byPoint = new Map();
+    /**
+     * 记住「哪条路径真的能用」。
+     *
+     * 路径后缀由服务商决定（实测 SiliconFlow 只通 /systemone），而守卫是
+     * fail-open 的——路径踩空等于静默失效。404 时换另一条再试，并记住胜出的
+     * 那条，下次直接打它，省掉热路径上多余的一次往返。
+     */
+    this.endpointMemory = new EndpointMemory();
   }
 
   /** 取（或建）某个决策点的计数器。 */
@@ -1022,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 回填为实际使用的模型）。
@@ -1055,37 +1083,57 @@ 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;
     counter.requests += 1;
+    // 请求体只构造一次：换路径重试时内容必须完全相同，否则第二次请求
+    // 与第一次不可比（缓存键也随之失配）。
+    const bodyText = JSON.stringify(
+      buildRequestBody(provider, {
+        state: call.state,
+        questions: call.questions,
+        thinkMode: cfg.thinkMode,
+      }),
+    );
+    // 候选端点：主路径优先，404 时换另一条（实测 SiliconFlow 只通
+    // /systemone、bamboonode 两条都通）。记忆里验证过的路径会被提到最前，
+    // 因此只有第一次探测会多一次往返。
+    const candidates = this.endpointMemory.order(provider.baseUrl, provider.candidates ?? [endpoint]);
     let response;
+    let usedEndpoint = endpoint;
+    let attempts = [];
     try {
-      response = await this.fetchFn(endpoint, {
-        method: "POST",
-        // 鉴权与请求头同样由 provider 构造：custom 可以带额外头，
-        // 但 authorization / content-type 永远由本插件决定。
-        headers: buildHeaders(provider, key),
-        body: JSON.stringify(
-          buildRequestBody(provider, {
-            state: call.state,
-            questions: call.questions,
-            thinkMode: cfg.thinkMode,
-          }),
-        ),
-        signal,
+      const result = await sendWithEndpointFallback(candidates, async (target) => {
+        usedEndpoint = target;
+        return this.fetchFn(target, {
+          method: "POST",
+          // 鉴权与请求头同样由 provider 构造：custom 可以带额外头，
+          // 但 authorization / content-type 永远由本插件决定。
+          headers: buildHeaders(provider, key),
+          body: bodyText,
+          signal,
+        });
       });
+      response = result.response;
+      usedEndpoint = result.endpoint;
+      attempts = result.attempts;
+      // 探测到可用路径：记住它，下次直接打（省掉一次多余往返）。
+      if (response?.ok === true) {
+        const style = styleOfEndpoint(usedEndpoint);
+        if (style !== undefined) this.endpointMemory.record(provider.baseUrl, usedEndpoint, style);
+      }
     } catch (error) {
       if (call.signal?.aborted) return degrade("caller-aborted");
       if (timer.aborted || error?.name === "AbortError") {
         this.noteFailure();
-        return degrade("timeout", { budgetMs: budget, endpoint });
+        return degrade("timeout", { timeoutMs, endpoint: usedEndpoint });
       }
       this.noteFailure();
       return degrade("network-error", {
-        endpoint,
+        endpoint: usedEndpoint,
         message: error instanceof Error ? error.message : String(error),
       });
     }
@@ -1106,14 +1154,31 @@ class StartluxClient {
       if (response.status === 401 || response.status === 403) {
         return degrade("auth-failed", {
           provider: provider.id,
-          endpoint,
+          endpoint: usedEndpoint,
           status: response.status,
           keyEnv: provider.apiKeyEnv,
           body: bodyText,
           hint: `鉴权被拒（HTTP ${response.status}）：检查 ${provider.id} 的 API key 是否有效、是否与地址匹配`,
         });
       }
-      return degrade(`http-${response.status}`, { provider: provider.id, endpoint, model, body: bodyText });
+      // 404 且两条路径都试过：路径风格不对是最常见的原因，必须说清楚
+      // 试过哪两条——否则用户只看到「HTTP 404」，完全猜不到是路径选错。
+      const tried = attempts.map((item) => item.endpoint);
+      const allMissing = response.status === 404 && attempts.length > 1;
+      return degrade(`http-${response.status}`, {
+        provider: provider.id,
+        endpoint: usedEndpoint,
+        model,
+        body: bodyText,
+        ...(tried.length > 1 ? { tried } : {}),
+        ...(allMissing
+          ? {
+              hint:
+                `路径不存在（HTTP 404）：已试过 ${tried.join(" 与 ")}。` +
+                `若该服务用的是另一条路径，请在配置页把「端点风格」改成对应的那条。`,
+            }
+          : {}),
+      });
     }
 
     let body;
@@ -1121,15 +1186,17 @@ class StartluxClient {
       body = await response.json();
     } catch {
       this.noteFailure();
-      return degrade("invalid-json", { endpoint });
+      return degrade("invalid-json", { endpoint: usedEndpoint });
     }
     if (body === null || typeof body !== "object") {
       this.noteFailure();
-      return degrade("invalid-response", { endpoint });
+      return degrade("invalid-response", { endpoint: usedEndpoint });
     }
 
     const answers = body.answers;
-    if (answers === null || typeof answers !== "object") return degrade("missing-answers", { endpoint });
+    if (answers === null || typeof answers !== "object") {
+      return degrade("missing-answers", { endpoint: usedEndpoint });
+    }
 
     const usage = typeof body.usage === "object" && body.usage !== null ? body.usage : {};
     const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : undefined;
@@ -1148,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);
@@ -1320,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;
@@ -1499,7 +1568,7 @@ export function apply(ctx, config) {
   // ---- 其余八个决策点 ----------------------------------------------------
   //
   // 与工具授权不同，这八个点共用一条 execution 链路（engine.js）：模式判断、
-  // 预算、冷却、答案校验、遥测都由 runner.ask() 统一处理，适配器只负责
+  // 冷却、答案校验、遥测都由 runner.ask() 统一处理，适配器只负责
   // 「给出 state」与「落地副作用」。这样任何一处降级逻辑都不会漏。
   const runner = createDecisionRunner({
     getConfig,
@@ -1592,43 +1661,73 @@ 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();
     try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: buildHeaders(provider, key),
-        // 与 classify 保持一致：同一个 buildRequestBody，探测不可能与实际
-        // 请求形状不同步（这正是「测试通过但守卫不工作」的经典来源）。
-        body: JSON.stringify(
-          buildRequestBody(provider, {
-            state: { probe: true, cwd: process.cwd() },
-            questions: { alive: { type: "noul", instructions: "Is this request well formed?" } },
-            thinkMode: cfg.thinkMode,
-          }),
-        ),
-        signal: AbortSignal.timeout(Math.max(5000, cfg.timeoutMs)),
-      });
+      // 探测与实际决策走**同一套**候选顺序与 404 回退：否则会出现
+      // 「测试通过但守卫不工作」或反之。实测 SiliconFlow 只通 /systemone，
+      // 而 /v1/decisions 回 404——只试一条路径必然误报。
+      const bodyText = JSON.stringify(
+        buildRequestBody(provider, {
+          state: { probe: true, cwd: process.cwd() },
+          questions: { alive: { type: "noul", instructions: "Is this request well formed?" } },
+          thinkMode: cfg.thinkMode,
+        }),
+      );
+      const candidates = client.endpointMemory.order(provider.baseUrl, provider.candidates ?? [endpoint]);
+      const result = await sendWithEndpointFallback(candidates, (target) =>
+        fetch(target, {
+          method: "POST",
+          headers: buildHeaders(provider, key),
+          // 与 classify 保持一致：同一个 buildRequestBody，探测不可能与实际
+          // 请求形状不同步（这正是「测试通过但守卫不工作」的经典来源）。
+          body: bodyText,
+          signal: AbortSignal.timeout(Math.max(5000, cfg.timeoutMs)),
+        }),
+      );
+      const response = result.response;
       const elapsed = Date.now() - started;
-      const requestId = response.headers.get("x-oneapi-request-id") ?? "(无)";
-      let bodyText = "";
+      // 追踪 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 {
-        bodyText = (await response.text()).slice(0, 300);
+        bodyTextOut = (await response.text()).slice(0, 300);
       } catch {
         /* 忽略 */
       }
+      // 探测成功即记住胜出的路径：下次决策直接打它。
+      if (response?.ok === true) {
+        const style = styleOfEndpoint(result.endpoint);
+        if (style !== undefined) client.endpointMemory.record(provider.baseUrl, result.endpoint, style);
+      }
+      // 换过路径就要说出来：用户需要知道「实际打的是哪条」。
+      const triedText =
+        result.attempts.length > 1
+          ? `尝试过的路径: ${result.attempts.map((item) => `${item.endpoint} → ${item.status}`).join("，")}\n`
+          : "";
       return {
-        ok: response.ok,
+        ok: response?.ok === true,
         text:
           `provider: ${provider.label}（${provider.id}）\n` +
-          `POST ${endpoint}\n` +
+          `POST ${result.endpoint}\n` +
           `model: ${(provider.model ?? "").trim().length > 0 ? provider.model : "自动（服务端默认）"}\n` +
-          `HTTP ${response.status}　耗时 ${elapsed}ms\n` +
+          `HTTP ${response?.status ?? "(无响应)"}　耗时 ${elapsed}ms\n` +
           `x-oneapi-request-id: ${requestId}\n` +
-          `响应: ${bodyText}`,
+          (triedText.length > 0 ? `${triedText}` : "") +
+          `响应: ${bodyTextOut}`,
       };
     } catch (error) {
       return {
@@ -1750,9 +1849,36 @@ 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",
+        // 实际用得通的那条路径（探测出来的）。路径后缀由服务商决定，
+        // 实测 SiliconFlow 只通 /systemone；界面必须显示「实际打哪」，
+        // 否则用户看到 404 完全猜不到是路径选错了。
+        detectedEndpoint: client.endpointMemory.get(provider.baseUrl)?.endpoint ?? "",
+        detectedEndpointStyle: client.endpointMemory.get(provider.baseUrl)?.style ?? "",
         customModel: cfg.customModel ?? "",
         customHeaders: cfg.customHeaders ?? "",
         customApiKeyEnv: cfg.customApiKeyEnv ?? "",
@@ -1779,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,
       };
     };
@@ -1804,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) {
@@ -1877,7 +2002,7 @@ export function apply(ctx, config) {
      * 决策点总览与切换。
      *
      * GET  返回注册表 + 当前模式 + 分账实测数据。
-     * PUT  改模式与自身预算。
+     * PUT  改模式。
      *
      * 合成一个注册项按 method 分支，而不是同路径注册两次：
      * DSH 的 fetch 注册表以 path 为键，重复注册会互相覆盖（实测踩过）。
@@ -1921,7 +2046,6 @@ export function apply(ctx, config) {
           };
         }),
         modes: POINT_MODES,
-        budget: client.budget.report,
         cache: client.cache.report,
       };
     };
@@ -1961,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。
@@ -2013,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) {
@@ -2031,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()),
@@ -2053,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({
@@ -2131,6 +2263,24 @@ function stripUndefined(source) {
   return out;
 }
 
+/**
+ * 从完整端点里取出它的路径风格（`decisions` / `systemone`）。
+ *
+ * 端点一定来自 buildEndpoint，理论上必然是合法 URL；但这里仍然做保护——
+ * 它在**请求失败后的降级路径**上被调用，一个解析异常不该把整次决策变成
+ * 未捕获异常（那会让守卫从「降级放行」变成「抛错」，行为倒退）。
+ *
+ * @param endpoint - 完整端点。
+ * @returns 路径风格；无法识别时返回 undefined。
+ */
+function styleOfEndpoint(endpoint) {
+  try {
+    return endpointStyleOfPath(new URL(endpoint).pathname);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * 供测试与运维脚本使用的导出。
  *