dsh-decision-engine 0.6.0 → 0.6.1

package/README.md

@@ -159,7 +159,7 @@ content-type: application/json
 | 字段 | 必填 | 说明 |
 |---|---|---|
 | `Base URL` | **是** | 必须是 `http://` 或 `https://` 地址。不支持其它协议（`ftp:` 等会被拒绝），不带 scheme 也会被拒绝——自定义地址必须显式，避免猜错协议。不能含空格、换行或查询串。 |
-| `端点风格` | 否 | `auto`（默认）/ `decisions` / `systemone`。`auto` 在地址已带 `/decisions` 或 `/systemone` 时原样使用。 |
+| `端点风格` | 否 | `auto`（默认）/ `decisions` / `systemone`。这是**首选**路径，不是唯一路径：首选返回 404 时插件会自动改用另一条再试一次（见下）。 |
 | `附加请求头` | 否 | 格式 `名称: 值`，多项用分号分隔，如 `X-Tenant: team-a; X-Trace: dsh`。`authorization` / `content-type` / `host` 由插件固定，写了也会被忽略。 |
 | `密钥变量名` | 否 | 填了就从该环境变量或 `~/.dsh/.credentials.yaml` 的 `refs:` 段取 key；也可以直接在 API Key 输入框粘贴。 |
 | `模型` | 否 | 留空 = 由服务端选默认；实测留空比发空串安全（发 `"model": ""` 会被 400）。 |
@@ -177,6 +177,31 @@ content-type: application/json
 
 拼接是幂等的：对结果再拼一次不会变成 `/v1/v1/decisions` 或 `//decisions`。
 
+### 端点路径由服务商决定，不由模型决定
+
+这是本插件最容易踩空的一处，因此**实测**过（2026-10-25，真实 key 打真实端点）：
+
+| 服务商 | 模型 | `/v1/decisions` | `/v1/systemone` |
+|---|---|---|---|
+| SiliconFlow | `Kev-4B` | **404 Not Found** | **200 ✅** |
+| bamboonode | `startlux-decision-27b-autothink` | 200 ✅ | 200 ✅ |
+
+也就是说，`Kev-4B` 并不是「只能用 `/systemone` 的模型」——**路径由服务商决定**。
+同一个 `Kev-4B` 换一个服务商，路径就得跟着换。
+
+**因此 `端点风格` 只是「首选」**：
+
+1. 先打首选路径；
+2. 收到 **404**（= 路径不存在）时，自动改用另一条再试一次；
+3. 试通的那条会被**记住**（按 base URL 区分），下次直接打它，不再多一次往返；
+4. 两条都 404 时，遥测与「测试端点」会**列出试过的两个地址**并提示改端点风格。
+
+只有 404 会触发换路径：400（模型/内容不合法）、401（key 不对）、5xx 都与路径无关，
+换路径只是多烧一次请求。配置页的「生效端点」下方会显示「已验证可用：…」。
+
+> 旧版本没有回退：路径踩空就是 404，而守卫是 fail-open 的——**静默失效**。
+> 现场证据：`telemetry.jsonl` 里 2026-10-25 13:16–13:41 有 8 次 `http-404` 降级。
+
 ### 持久化与切换行为
 
 - 所有 provider 的配置**并列**存在 `config.yml` 里，互不覆盖：

package/config.example.yml

@@ -71,10 +71,17 @@ systemoneModel: ""
 # 允许省略 scheme，custom 不允许——自定义地址必须显式，避免猜错协议）。
 # customBaseUrl: https://api.example.com/v1
 #
-# 端点风格：
-#   auto       地址已带 /decisions 或 /systemone 就原样用，否则按 decisions 拼
-#   decisions  POST <base>/decisions
-#   systemone  POST <base>/systemone
+# 端点风格（**首选**路径，不是唯一路径）：
+#   auto       地址已带 /decisions 或 /systemone 就原样用，否则先试 decisions
+#   decisions  先试 POST <base>/decisions
+#   systemone  先试 POST <base>/systemone
+#
+# 路径后缀由**服务商**决定，不由模型决定。实测（2026-10-25，真实端点）：
+#   SiliconFlow 的 Kev-4B   /v1/decisions → 404，/v1/systemone → 200
+#   bamboonode 的决策模型     两条路径都 200
+#
+# 所以首选路径返回 404 时，插件会自动改用另一条再试一次，并记住试通的那条。
+# 只有 404 会触发换路径：400（模型/内容不合法）与 401（key 不对）都跟路径无关。
 customEndpointStyle: auto
 #
 # custom 自己的模型（留空 = 服务端默认）。与内置预设的 model 分开存，

package/lib/client.js

@@ -521,6 +521,8 @@ window.__ModuleLoader__.load({
         providerError: "",
         providerCatalog: [],
         baseUrl: "",
+        // 探测出的可用路径：status 失败时留空（界面不显示那一行）。
+        detectedEndpoint: "",
         model: "",
         timeoutMs: 20000,
         keyConfigured: false,
@@ -924,11 +926,24 @@ window.__ModuleLoader__.load({
             ? "由上方 base URL + 端点风格拼接；已带 /decisions 或 /systemone 时原样使用"
             : "内置预设的默认地址（可用 config.yml 的 baseUrl 覆盖 bamboonode）",
           h(
-            "span",
-            { style: { ...S.v, fontSize: "11px", opacity: 0.75, maxWidth: "300px" } },
-            view.providerValid === false
-              ? "配置不可用"
-              : view.baseUrl || "(服务端未返回)",
+            "div",
+            { style: { display: "flex", flexDirection: "column", gap: "3px", maxWidth: "320px" } },
+            h(
+              "span",
+              { style: { ...S.v, fontSize: "11px", opacity: 0.75, wordBreak: "break-all" } },
+              view.providerValid === false
+                ? "配置不可用"
+                : view.baseUrl || "(服务端未返回)",
+            ),
+            // 探测出的实际可用路径：路径后缀由服务商决定（实测 SiliconFlow
+            // 只通 /systemone），必须让用户看见「最后打的是哪条」。
+            typeof view.detectedEndpoint === "string" && view.detectedEndpoint.length > 0
+              ? h(
+                  "span",
+                  { style: { ...S.v, fontSize: "11px", opacity: 0.85, color: "#7dd3a0" } },
+                  `已验证可用：${view.detectedEndpoint}`,
+                )
+              : null,
           ),
           "endpoint",
         ),
@@ -1126,7 +1141,8 @@ window.__ModuleLoader__.load({
               ),
               row(
                 "端点风格",
-                "auto：地址已带 /decisions 或 /systemone 就原样用，否则按 /decisions 拼；也可强制指定",
+                "路径后缀由服务商决定（实测 SiliconFlow 只通 /systemone，bamboonode 两条都通）。" +
+                  "这里是「首选」：若首选路径返回 404，插件会自动改用另一条再试一次",
                 h(
                   "select",
                   {
@@ -1139,7 +1155,7 @@ window.__ModuleLoader__.load({
                       scheduleSave({ providerDraft: next }, true);
                     },
                   },
-                  h("option", { value: "auto" }, "auto（自动）"),
+                  h("option", { value: "auto" }, "auto（先 /decisions）"),
                   h("option", { value: "decisions" }, "decisions"),
                   h("option", { value: "systemone" }, "systemone"),
                 ),

package/lib/endpoint-fallback.js

@@ -0,0 +1,143 @@
+/**
+ * 端点回退：404 表示「这条路径不存在」，换另一条再试。
+ *
+ * 为什么需要它（2026-10-25 真实端点实测）：
+ *
+ *   路径后缀（`/decisions` 还是 `/systemone`）由**服务商**决定，**不由模型决定**：
+ *
+ *     SiliconFlow    Kev-4B                   /v1/decisions → 404    /v1/systemone → 200 ✅
+ *     bamboonode     startlux-decision-27b-…  两者都 200
+ *
+ *   旧实现只有一条路径：`customEndpointStyle: auto` 的真实含义是「按
+ *   decisions 拼」。配到只认 `/systemone` 的服务上就得到 404，而守卫是
+ *   fail-open 的——于是它**静默地什么也没做**（现场证据：telemetry.jsonl
+ *   里 2026-10-25 13:16–13:41 有 8 次 `http-404` 降级）。
+ *
+ *   404 与 400 必须区分：实测 404 = 路径不存在（换路径有用），400 = 请求
+ *   内容或模型不合法（换路径没用）。因此**只有 404 触发回退**。
+ *
+ * 本模块**零依赖**：只做「依次尝试候选端点」这一件事，因此可以在裸 Node
+ * 下直接单测（见 test/endpoint-fallback.test.js）。
+ *
+ * @module dsh-decision-engine/endpoint-fallback
+ */
+
+/**
+ * 「路径不存在」的状态码。
+ *
+ * 实测两类网关一致：SiliconFlow 与 bamboonode 对不存在的路径都回 404
+ * （SiliconFlow 甚至回纯文本 `Not Found` 而非 JSON 错误体），而路径存在
+ * 但内容/模型不合法时回 400。
+ */
+export const PATH_MISS_STATUS = 404;
+
+/**
+ * 依次尝试候选端点，直到出现一个「不是路径不存在」的响应。
+ *
+ * 只有 404 会触发换下一条：其它状态码（400 模型/内容不合法、401 key 不对、
+ * 5xx 服务端故障）都与路径无关，换路径只会多烧一次请求。
+ *
+ * 网络异常（fetch 抛错）**直接上抛**，不换路径重试：DNS/连接失败对所有候选
+ * 是一样的，重试只是把一次失败变成两次。调用方据此降级。
+ *
+ * @param candidates - 候选端点，按优先级排列。
+ * @param send - `(endpoint) => Promise<Response>`：发一次请求。
+ * @returns `{ endpoint, response, attempts }`：
+ *   - `endpoint`：实际使用的端点（最后一次尝试的）。
+ *   - `response`：该端点的响应（候选为空时为 undefined）。
+ *   - `attempts`：每次尝试的 `{ endpoint, status }`，供遥测解释「换过路径」。
+ */
+export async function sendWithEndpointFallback(candidates, send) {
+  const list = (Array.isArray(candidates) ? candidates : []).filter(
+    (item) => typeof item === "string" && item.length > 0,
+  );
+  const attempts = [];
+  if (list.length === 0) return { endpoint: "", response: undefined, attempts };
+  for (let index = 0; index < list.length; index += 1) {
+    const endpoint = list[index];
+    // 网络异常在此上抛：调用方按「network-error / timeout」降级。
+    const response = await send(endpoint);
+    const status = typeof response?.status === "number" ? response.status : 0;
+    attempts.push({ endpoint, status });
+    const hasNext = index + 1 < list.length;
+    if (status === PATH_MISS_STATUS && hasNext) {
+      // 换下一条前先丢弃这次的响应体：不消费它会让连接被挂住，
+      // 高频决策下会逐渐耗尽连接池。
+      try {
+        await response?.body?.cancel?.();
+      } catch {
+        /* 取消失败无所谓：响应体最终会被 GC */
+      }
+      continue;
+    }
+    return { endpoint, response, attempts };
+  }
+  // 理论上到不了这里（最后一轮必定 return），但保持返回结构完整。
+  return { endpoint: list[list.length - 1], response: undefined, attempts };
+}
+
+/**
+ * 记住「哪条路径真的能用」。
+ *
+ * 为什么要记：auto 风格下每次都先打一条错路径、再打对路径，等于每次请求
+ * 多一次往返（决策热路径上这是实打实的延迟）。记住之后，下次直接打对的那条。
+ *
+ * 作用域限**单个 base URL**：换了地址就重新探测——否则「A 服务商的结论」
+ * 会被套用到 B 服务商上，那正是本插件最忌讳的「配置漂移」。
+ */
+export class EndpointMemory {
+  constructor() {
+    /** @type {Map<string, { endpoint: string, style: string }>} */
+    this.entries = new Map();
+  }
+
+  /**
+   * 记下某条路径可用。
+   *
+   * @param baseUrl - base URL（探测的适用范围）。
+   * @param endpoint - 实际可用的端点。
+   * @param style - 该端点的路径风格（`decisions` / `systemone`）。
+   */
+  record(baseUrl, endpoint, style) {
+    if (typeof baseUrl !== "string" || baseUrl.length === 0) return;
+    if (typeof endpoint !== "string" || endpoint.length === 0) return;
+    this.entries.set(baseUrl, { endpoint, style });
+  }
+
+  /**
+   * 取某个 base URL 记住的端点。
+   *
+   * @param baseUrl - base URL。
+   * @returns `{ endpoint, style }` 或 undefined。
+   */
+  get(baseUrl) {
+    if (typeof baseUrl !== "string" || baseUrl.length === 0) return undefined;
+    return this.entries.get(baseUrl);
+  }
+
+  /**
+   * 把记住的端点提到候选列表最前面。
+   *
+   * 只在它**确实还在候选里**时才提升：候选由配置决定，配置改了（比如换端点
+   * 风格）就说明用户有了新决定，此时旧的探测结果不该再插队。
+   *
+   * @param baseUrl - base URL。
+   * @param candidates - 候选端点列表。
+   * @returns 调整顺序后的新数组（不改原数组）。
+   */
+  order(baseUrl, candidates) {
+    const list = [...(Array.isArray(candidates) ? candidates : [])];
+    const remembered = this.get(baseUrl);
+    if (remembered === undefined) return list;
+    const index = list.indexOf(remembered.endpoint);
+    if (index <= 0) return list;
+    list.splice(index, 1);
+    list.unshift(remembered.endpoint);
+    return list;
+  }
+
+  /** 清空记忆（配置变了、或探测结果不再适用时）。 */
+  clear() {
+    this.entries.clear();
+  }
+}

package/lib/index.js

@@ -37,6 +37,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 +50,7 @@ import {
   buildEndpoint,
   buildHeaders,
   buildRequestBody,
+  endpointStyleOfPath,
   normalizeBaseUrl,
   normalizeThinkMode,
   parseCustomHeaders,
@@ -950,6 +952,14 @@ class StartluxClient {
     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();
   }
 
   /** 取（或建）某个决策点的计数器。 */
@@ -1061,31 +1071,51 @@ class StartluxClient {
 
     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", { budgetMs: budget, endpoint: usedEndpoint });
       }
       this.noteFailure();
       return degrade("network-error", {
-        endpoint,
+        endpoint: usedEndpoint,
         message: error instanceof Error ? error.message : String(error),
       });
     }
@@ -1106,14 +1136,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 +1168,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;
@@ -1598,37 +1647,56 @@ export function apply(ctx, config) {
     }
     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 = "";
+      const requestId = response?.headers?.get?.("x-oneapi-request-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 {
@@ -1753,6 +1821,11 @@ export function apply(ctx, config) {
         // 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 ?? "",
@@ -2131,6 +2204,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;
+  }
+}
+
 /**
  * 供测试与运维脚本使用的导出。
  *

package/lib/providers.js

@@ -44,15 +44,26 @@ export const DEFAULT_PROVIDER = "bamboonode";
 /**
  * 自定义 base URL 的端点风格。
  *
- *   auto       已指向 /decisions 或 /systemone 就原样用，否则按 decisions 补
+ *   auto       已指向 /decisions 或 /systemone 就原样用，否则先试 decisions
  *   decisions  POST <base>/decisions
  *   systemone  POST <base>/systemone
+ *
+ * 注意：这是**首选**路径，不是唯一路径。路径后缀由服务商决定（实测
+ * SiliconFlow 的 Kev-4B 只通 /v1/systemone，bamboonode 两条都通），
+ * 因此 404 时会换另一条再试——见 endpointCandidates()。
  */
 export const ENDPOINT_STYLES = ["auto", "decisions", "systemone"];
 
 /** 端点风格 → 追加的路径段。 */
 const STYLE_SEGMENT = { decisions: "decisions", systemone: "systemone" };
 
+/**
+ * 两条路径风格互为「另一条」。
+ *
+ * 用于 404 回退：路径不存在时换另一条再试一次。
+ */
+const ALTERNATE_STYLE = { decisions: "systemone", systemone: "decisions" };
+
 /**
  * 合法的思考模式（与 startlux 服务的 `think_mode` 取值一致）。
  *
@@ -259,6 +270,61 @@ export function buildEndpoint(baseUrl, style = "decisions") {
   return url.toString();
 }
 
+/**
+ * 列出「同一个 base URL 下所有值得一试的端点」，按优先级排列。
+ *
+ * 背景（2026-10-25 实测）：路径后缀由**服务商**决定，不由模型决定——
+ * SiliconFlow 的 Kev-4B 只认 `/v1/systemone`（`/v1/decisions` 回 404），
+ * 而 bamboonode 的决策模型两条路径都能用。因此「只拼一条路径」在换服务商
+ * 时必然踩空，而守卫是 fail-open 的，踩空表现为**静默失效**。
+ *
+ * 候选规则：
+ *
+ *   - 地址**已自带**端点段（`.../v1/decisions` 或 `.../v1/systemone`）→
+ *     只返回它自己。用户填了完整端点就是明确决定，不该被自动改写。
+ *   - `auto` → 先试 `decisions`（与历史行为一致），再试 `systemone`。
+ *   - 显式 `decisions` / `systemone` → 先试它自己，**再试另一条**。
+ *
+ * 最后一条是关键：显式指定只是「首选」，不是「唯一」。显式指定错路径时
+ * 同样会 404，届时仍应回退到另一条——否则「选错了就只能手动改」这种
+ * 死胡同会被用户当成插件的 bug。
+ *
+ * @param baseUrl - base URL。
+ * @param style - `decisions` / `systemone` / `auto`。
+ * @returns 候选端点数组（去重，优先级从高到低）。
+ */
+export function endpointCandidates(baseUrl, style = "auto") {
+  const normalized = normalizeBaseUrl(baseUrl);
+  if (normalized.length === 0) return [];
+  // 用户填了完整端点：原样用，不追加任何候选。
+  let path = "";
+  try {
+    path = new URL(normalized).pathname.replace(/\/+$/, "");
+  } catch {
+    // 非法 URL：交给调用方去报错，这里不构造候选。
+    return [];
+  }
+  if (endpointStyleOfPath(path) !== undefined) {
+    return [buildEndpoint(normalized, style)];
+  }
+  const primary = style === "auto" ? "decisions" : style === "systemone" ? "systemone" : "decisions";
+  const secondary = ALTERNATE_STYLE[primary];
+  const out = [buildEndpoint(normalized, primary)];
+  const other = buildEndpoint(normalized, secondary);
+  if (!out.includes(other)) out.push(other);
+  return out;
+}
+
+/**
+ * 端点风格 → 它对应的路径段（用于回显「当前用的是哪条路径」）。
+ *
+ * @param style - 风格取值。
+ * @returns `decisions` / `systemone`；无法识别时返回 "decisions"。
+ */
+export function styleSegment(style) {
+  return STYLE_SEGMENT[style] ?? "decisions";
+}
+
 /**
  * 解析 `customHeaders` 配置。
  *
@@ -324,6 +390,8 @@ export function resolveProvider(cfg = {}) {
       source: "custom",
       baseUrl,
       endpoint: checked.ok ? buildEndpoint(baseUrl, style) : "",
+      // 候选端点（按优先级）：404 时按顺序换下一条再试。
+      candidates: checked.ok ? endpointCandidates(baseUrl, style) : [],
       endpointStyle: style,
       model,
       defaultModel: "",
@@ -371,6 +439,9 @@ export function resolveProvider(cfg = {}) {
     source: legacyBase.length > 0 ? "legacy" : "preset",
     baseUrl: checked.ok ? checked.value : baseUrl,
     endpoint: checked.ok ? buildEndpoint(baseUrl, preset.endpointStyle) : "",
+    // 候选端点（按优先级）：预设自己的路径优先，404 时换另一条再试。
+    // 实测 bamboonode 两条路径都通，SiliconFlow 只通 /systemone。
+    candidates: checked.ok ? endpointCandidates(baseUrl, preset.endpointStyle) : [],
     endpointStyle: preset.endpointStyle,
     model,
     defaultModel: preset.defaultModel,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-decision-engine",
-  "version": "0.6.0",
+  "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).",
   "icon": "./icon.svg",
   "type": "module",