dsh-decision-engine 0.5.2 → 0.6.1

package/lib/client.js

@@ -83,7 +83,7 @@ window.__ModuleLoader__.load({
         background: "#fff",
         transition: "transform .15s ease",
       },
-      /** 保存按钮。 */
+      /** 小按钮（获取模型 / 测试端点 / 重试）。 */
       saveBtn: {
         padding: "6px 14px",
         borderRadius: "6px",
@@ -216,13 +216,164 @@ window.__ModuleLoader__.load({
       return data;
     }
 
-    /** 主面板：配置 + 状态 + 一键测试 + 最近决策。 */
+    /**
+     * 自动保存的防抖时长：文本框停手多久之后落盘。
+     *
+     * 太短会把打字过程中的半截值写进 yml（每个字符一次请求），太长则
+     * 「改完立刻关掉面板」会丢改动。700ms 是这两者之间的常见折中。
+     */
+    const AUTOSAVE_DELAY_MS = 700;
+
+    /**
+     * 自定义 base URL 的问题描述，空串表示可用。
+     *
+     * 规则与服务端 `validateProviderPatch` 一致：本地先判，是为了让「打字打到一半
+     * 的非法地址」停在本地（显示红字），而不是每停一下就发一次注定 400 的请求。
+     *
+     * @param rawUrl - 用户填写的地址（未 trim）。
+     * @param provider - 当前 provider；只有 custom 时空地址才是「必填缺失」。
+     */
+    function customUrlProblem(rawUrl, provider) {
+      const url = (rawUrl ?? "").trim();
+      if (url.length === 0) {
+        return provider === "custom" ? "必填：请填写 system-one 风格服务的 base URL" : "";
+      }
+      if (/\s/.test(url)) return "不能包含空格或换行";
+      if (!/^https?:\/\//i.test(url)) return "必须以 http:// 或 https:// 开头";
+      try {
+        const parsed = new URL(url);
+        if (parsed.search.length > 0) return "不要带查询串（? 之后的部分）";
+      } catch {
+        return "不是合法地址（示例：https://api.example.com/v1）";
+      }
+      return "";
+    }
+
+    /**
+     * 待落盘的决策点/预算改动，没有改动时返回 null。
+     *
+     * 与 `/decisions` 的 PUT body 同形（`{ points?, budgetTokens? }`）：
+     * 服务端对空 body 直接 400，所以「没改动就不发」必须由调用方保证。
+     */
+    function pendingDecisions(values, decisions) {
+      const changed = {};
+      for (const [id, mode] of Object.entries(values.pointsDraft ?? {})) {
+        const original = (decisions?.points ?? []).find((item) => item.id === id);
+        if (original !== undefined && original.mode !== mode) changed[id] = mode;
+      }
+      const limit = decisions?.budget?.limit ?? 0;
+      const budget =
+        values.budgetDraft !== null && values.budgetDraft !== undefined && values.budgetDraft !== limit
+          ? values.budgetDraft
+          : null;
+      const hasPoints = Object.keys(changed).length > 0;
+      if (hasPoints !== true && budget === null) return null;
+      const body = {};
+      if (hasPoints === true) body.points = changed;
+      if (budget !== null) body.budgetTokens = budget;
+      return body;
+    }
+
+    /**
+     * 由「当前值」拼出 `/config` 的 PUT patch。
+     *
+     * 与旧版「点保存」时提交的内容逐字一致，只是取值来源从渲染闭包换成了
+     * `valuesRef`（setState 是异步的，自动保存必须读到刚改完的值）。
+     *
+     * @param values - `{ draft, providerDraft, keyInputs, storageDraft }`。
+     * @param keyCommit - 用户明确提交密钥的 provider（失焦/回车），否则 null。
+     */
+    function configPatchOf(values, keyCommit) {
+      const draft = values.draft;
+      const provider = values.providerDraft;
+      const patch = {
+        enabled: draft.enabled === true,
+        mode: draft.mode,
+        // 思考模式总是提交：它是全局项（与 provider 无关），服务端还会再校验一次。
+        thinkMode: draft.thinkMode ?? "never",
+        // 模型字段只写当前 provider 自己那一格（model / systemoneModel /
+        // customModel）。混写会让「切过去再切回来」丢掉原值，也会把
+        // bamboonode 的模型名发给别的服务。
+        ...(provider.provider === "custom"
+          ? { customModel: (provider.customModel ?? "").trim() }
+          : provider.provider === "systemone"
+            ? { systemoneModel: (draft.systemoneModel ?? "").trim() }
+            : { model: (draft.model ?? "").trim() }),
+        provider: provider.provider,
+        customEndpointStyle: provider.customEndpointStyle ?? "auto",
+        // custom 的字段总是带上：用户可能先填地址再切 provider，
+        // 分开提交会让中间状态被当成最终配置。
+        customHeaders: (provider.customHeaders ?? "").trim(),
+        customApiKeyEnv: (provider.customApiKeyEnv ?? "").trim(),
+      };
+      // customBaseUrl 只在**合法**时提交。空串对内置 provider 是合法的
+      //（等于不覆盖），对 custom 则是必填缺失——那种情况整笔延后，见 flush()。
+      // 不合法的值一律不发：服务端会拒，而打字途中的每一次拒绝都是噪音。
+      const url = (provider.customBaseUrl ?? "").trim();
+      if (customUrlProblem(url, provider.provider) === "") patch.customBaseUrl = url;
+      // 保存位置：只在用户改过时才提交，避免每次保存都覆盖。
+      if (values.storageDraft !== null && values.storageDraft !== undefined) {
+        patch.keyStorage = values.storageDraft;
+      }
+      // 密钥：只有用户明确提交（失焦 / 回车）且长度够时才带上。
+      // 否则打字过程中每停一下都会把半截 key 写进凭据文件。
+      if (keyCommit !== null && keyCommit !== undefined) {
+        const raw = (values.keyInputs[keyCommit] ?? "").trim();
+        if (raw.length >= 10) {
+          if (keyCommit === "systemone") patch.systemoneApiKey = raw;
+          else if (keyCommit === "custom") patch.customApiKey = raw;
+          else patch.bamboonodeApiKey = raw;
+        }
+      }
+      return patch;
+    }
+
+    /**
+     * patch 是否真的与服务端当前状态不同。
+     *
+     * 自动保存会频繁调用：不做这个比较，用户改一个决策点也会重写一次
+     * config.yml（白改 mtime、白触发一次热加载）。比较对象是 status 回显，
+     * 也就是「服务端认为的值」——与旧版「保存按钮的可用条件」同一语义。
+     *
+     * @param patch - `configPatchOf` 拼出的 patch。
+     * @param view - `/status` 回显（缺字段时用安全默认）。
+     */
+    function patchDiffersFromServer(patch, view) {
+      const pairs = [
+        ["enabled", view.enabled === true],
+        ["mode", view.mode ?? "shadow"],
+        ["thinkMode", view.thinkMode ?? "never"],
+        ["provider", view.provider ?? "bamboonode"],
+        ["customBaseUrl", view.customBaseUrl ?? ""],
+        ["customEndpointStyle", view.customEndpointStyle ?? "auto"],
+        ["customModel", view.customModel ?? ""],
+        ["model", view.rawModel ?? ""],
+        ["systemoneModel", view.rawSystemoneModel ?? ""],
+        ["customHeaders", view.customHeaders ?? ""],
+        ["customApiKeyEnv", view.customApiKeyEnv ?? ""],
+        ["keyStorage", view.keyStorage ?? "credentials"],
+      ];
+      for (const [key, server] of pairs) {
+        if (Object.hasOwn(patch, key) && String(patch[key] ?? "") !== String(server ?? "")) return true;
+      }
+      // 密钥字段一出现就代表「有新 key 要写」：服务端只回传掩码，没法比较，
+      // 而且重复写同一个 key 是无害的（幂等覆盖）。
+      return ["systemoneApiKey", "bamboonodeApiKey", "customApiKey"].some((key) => Object.hasOwn(patch, key));
+    }
+
     /**
      * 配置页：仿照内置 dsh-rewind-plugin 的卡片布局——
-     * 每行左侧是「标题 + 灰色说明」，右侧是开关；底部一个「保存」按钮。
+     * 每行左侧是「标题 + 灰色说明」，右侧是控件。
+     *
+     * **改完即保存，没有「保存」按钮**：
+     *   - 开关 / 下拉 / 分段控件：点一下就落盘；
+     *   - 文本框（地址、请求头、预算）：停手 `AUTOSAVE_DELAY_MS` 后落盘，失焦立刻落盘；
+     *   - API Key：失焦或回车才落盘（见 `commitKey`）。
+     * 落盘状态显示在底部一行（保存中 / 已保存 / 失败原因 + 重试），
+     * 取代了原来那个按钮。
      *
      * 数据全部走本插件自己的 `/api/decision-engine/*`，**不用** settings 服务
-     *（旧插件死在 `settings.installSection` 上）。保存即改写 config.yml。
+     *（旧插件死在 `settings.installSection` 上）。落盘即改写 config.yml。
      *
      * @param props - 槽位属性；`view === "summary"` 时只渲染一行摘要文本。
      */
@@ -238,7 +389,6 @@ window.__ModuleLoader__.load({
       // 而不是在这里写一份硬编码默认：否则「status 已回来但 useEffect 还没跑」
       // 的那一帧会显示错的值（例如把 custom 显示成 bamboonode）。
       const [draftState, setDraft] = react.useState(null);
-      const [dirty, setDirty] = react.useState(false);
       // provider 草稿：与主配置分开保存，因为 custom 的五个字段是「先填后切」，
       // 混进主 draft 会让「只切 provider」也顺手把没填完的 custom 值写进去。
       const [providerDraftState, setProviderDraft] = react.useState(null);
@@ -255,11 +405,35 @@ window.__ModuleLoader__.load({
       const [pointsDraft, setPointsDraft] = react.useState({});
       const [budgetDraft, setBudgetDraft] = react.useState(null);
 
-      // 用 ref 保存「用户是否有未保存改动」，使 refresh 不因 dirty 变化而重建。
-      // 否则保存时 setDirty(false) → refresh 换新引用 → useEffect 再跑一次，
-      // 与 save 里的 setStatus 竞争，可能用旧值把刚保存的开关覆盖回去（表现为回弹）。
+      // 用 ref 保存「用户是否有未保存改动」，使 refresh 不因状态变化而重建。
+      // 否则落盘时 setDirty(false) → refresh 换新引用 → useEffect 再跑一次，
+      // 与 flush 里的 setStatus 竞争，可能用旧值把刚保存的开关覆盖回去（表现为回弹）。
       const dirtyRef = react.useRef(false);
       const savingRef = react.useRef(false);
+      // 落盘状态：null（无提示）| "saving" | "saved" | { error }。取代原来的保存按钮。
+      const [saveState, setSaveState] = react.useState(null);
+      /**
+       * 待落盘值的唯一真源。
+       *
+       * 不能用渲染闭包里的 `draft`：`setState` 是异步的，一次事件里改完立刻
+       * 发请求时闭包里还是旧值（会把改动存丢）。因此所有控件先同步写这里，
+       * 再 setState 触发重绘；flush 只读这里。
+       */
+      const valuesRef = react.useRef(null);
+      /** 每次改动自增：用来判断「响应回来时用户是否又改过」，避免旧快照覆盖新输入。 */
+      const editSeqRef = react.useRef(0);
+      /** 防抖计时器。 */
+      const timerRef = react.useRef(null);
+      /** 本次待落盘是否要连配置一起写（仅决策点改动时为 false）。 */
+      const pendingRef = react.useRef(null);
+      /**
+       * 明确提交密钥的 provider（失焦 / 回车）。
+       *
+       * 与普通改动分开：密钥不能随防抖自动提交，否则打字途中每停一下都会把
+       * 半截 key 写进凭据文件；这里记下「这一次是用户按下提交」，flush 时
+       * 才把它并进 patch，成功后清空。
+       */
+      const keyCommitRef = react.useRef(null);
 
       const refresh = react.useCallback(async () => {
         // 保存进行中不拉状态，避免用旧快照覆盖刚写入的结果。
@@ -347,6 +521,8 @@ window.__ModuleLoader__.load({
         providerError: "",
         providerCatalog: [],
         baseUrl: "",
+        // 探测出的可用路径：status 失败时留空（界面不显示那一行）。
+        detectedEndpoint: "",
         model: "",
         timeoutMs: 20000,
         keyConfigured: false,
@@ -363,7 +539,7 @@ window.__ModuleLoader__.load({
       const draft = draftState ?? {
         enabled: view.enabled === true,
         mode: view.mode ?? "shadow",
-        // 思考模式也走 draft：改完点保存才落盘，与开关语义一致。
+        // 思考模式也走 draft：与其它控件一致，改完即自动落盘。
         thinkMode: view.thinkMode ?? "never",
         model: view.rawModel ?? "",
         systemoneModel: view.rawSystemoneModel ?? "",
@@ -401,148 +577,185 @@ window.__ModuleLoader__.load({
           customApiKeyEnv: next.customApiKeyEnv ?? "",
         });
         setProviderError(next.providerValid === false ? next.providerError ?? "配置不可用" : "");
-        setDirty(false);
         dirtyRef.current = false;
       };
 
+      // 每次渲染把「当前值」同步进 ref：控件在事件里读它，flush 也读它。
+      // 放在渲染期赋值（而不是 useEffect）是必须的——useEffect 在提交之后才跑，
+      // 而事件处理器可能在它之前就读到 ref，那样拿到的还是上一次的值。
+      valuesRef.current = { draft, providerDraft, keyInputs, storageDraft, pointsDraft, budgetDraft };
+
       /**
-       * provider 相关改动是否待保存。
+       * 自动保存引擎。
+       *
+       * 三个动作：
+       *   - `scheduleSave(partial, immediate)`：控件改动后调用。先**同步**并入
+       *     `valuesRef`，再按需立即（开关/下拉）或防抖（文本框）落盘。
+       *   - `flush()`：真正发请求。串行、合并，按需分两次（`/config` + `/decisions`）。
+       *   - `commitKey(provider)`：密钥的「明确提交」（失焦 / 回车）。
        *
-       * 逐字段比较而不是维护一个独立的 dirty 标记：切到 custom 又切回来、
-       * 或者填了字又删掉，都应当回到「无改动」而不是永远亮着保存按钮。
+       * 三条不变量（都是这个界面反复踩过的坑）：
+       *
+       *   1. 同一时刻只有一个请求在飞（`savingRef`）。期间的改动只并入
+       *      `valuesRef`，等这次回来再发——并发保存会让两次快照互相覆盖。
+       *   2. 响应回来时若用户又改过（`editSeqRef` 变了），**不覆盖草稿**，
+       *      只刷新服务端状态。否则「保存中的输入被旧快照冲掉」= 回弹。
+       *   3. 失败不丢输入、也不自动重试：原因写进状态行，等用户改或点重试。
+       *      自动重试一个注定 400 的请求只会刷屏。
        */
-      const providerChanged = (() => {
-        const server = {
-          provider: view.provider ?? "bamboonode",
-          customBaseUrl: view.customBaseUrl ?? "",
-          customEndpointStyle: view.customEndpointStyle ?? "auto",
-          customModel: view.customModel ?? "",
-          customHeaders: view.customHeaders ?? "",
-          customApiKeyEnv: view.customApiKeyEnv ?? "",
-        };
-        const storageChanged = storageDraft !== null && storageDraft !== (view.keyStorage ?? "credentials");
-        const draftChanged = Object.keys(server).some(
-          (key) => (providerDraft[key] ?? "") !== (server[key] ?? ""),
-        );
-        return draftChanged || storageChanged;
-      })();
+      const flushRef = react.useRef(null);
 
-      const save = react.useCallback(
-        async (patch) => {
-          setBusy("save");
-          setMsg(null);
-          savingRef.current = true;
-          try {
-            const next = await call("/config", {
-              method: "PUT",
-              headers: { "content-type": "application/json" },
-              body: JSON.stringify(patch),
-            });
-            applyServerState(next);
-            setMsg({ ok: true, text: "已保存" });
-            if (Object.hasOwn(patch, "apiKey")) setKeyInput("");
-          } catch (error) {
-            // 校验失败（非法 URL / 缺必填）走这里：保留用户已填内容，
-            // 只把原因显示出来——清空表单会让用户重填一遍。
-            setMsg({ ok: false, text: error.message });
-            setProviderError(error.message);
-          } finally {
-            savingRef.current = false;
-            setBusy("");
-          }
-        },
-        [],
-      );
+      /** 同步记录一次改动，并安排落盘（`immediate` 用于离散控件）。 */
+      const scheduleSave = (partial, immediate) => {
+        valuesRef.current = { ...valuesRef.current, ...(partial ?? {}) };
+        editSeqRef.current += 1;
+        dirtyRef.current = true;
+        // 防抖窗口里就先把状态改成「待保存」：否则这一小段时间还挂着上一次的
+        // 「已保存」，用户会以为刚才那一下已经落盘了。
+        setSaveState("pending");
+        if (timerRef.current !== null) {
+          clearTimeout(timerRef.current);
+          timerRef.current = null;
+        }
+        if (immediate === true) {
+          void flushRef.current();
+          return;
+        }
+        // 文本框：停手 AUTOSAVE_DELAY_MS 之后再落盘，避免每敲一个字符一次请求。
+        timerRef.current = setTimeout(() => {
+          timerRef.current = null;
+          void flushRef.current();
+        }, AUTOSAVE_DELAY_MS);
+      };
 
-      // 决策点/预算是否有待保存改动。必须在 saveDecisions 之前算：
-      // useCallback 的依赖数组会在本次渲染立即求值，放到后面会踩 TDZ。
-      const pointsChanged = Object.keys(pointsDraft).some((id) => {
-        const original = (decisions?.points ?? []).find((item) => item.id === id);
-        return original !== undefined && pointsDraft[id] !== original.mode;
-      });
-      const budgetChanged = budgetDraft !== null && budgetDraft !== (decisions?.budget?.limit ?? 0);
-      const decisionsChanged = pointsChanged || budgetChanged;
+      /**
+       * 明确提交密钥（失焦 / 回车）。
+       *
+       * 密钥刻意**不**跟着防抖走：粘贴后停一下就把半截 key 写进凭据文件，
+       * 是比多点一次更糟的体验。这里只记「这一次是用户按下提交」。
+       */
+      const commitKey = (provider) => {
+        const raw = (valuesRef.current.keyInputs[provider] ?? "").trim();
+        // 留空 = 不修改（与旧版一致）；太短的多半是没贴完，不落盘，给一句提示。
+        if (raw.length === 0) return;
+        if (raw.length < 10) {
+          setSaveState({ error: "未保存：密钥太短（至少 10 个字符）" });
+          return;
+        }
+        keyCommitRef.current = provider;
+        editSeqRef.current += 1;
+        dirtyRef.current = true;
+        if (timerRef.current !== null) {
+          clearTimeout(timerRef.current);
+          timerRef.current = null;
+        }
+        void flushRef.current();
+      };
 
       /**
-       * 保存决策点与预算。
+       * 落盘一次。
        *
-       * 走独立的 `/decisions` 而不是复用 `/config`：那两份配置的校验规则不同
-       *（决策点要拒绝未实装的点、预算要 clamp），混在一起容易互相放宽。
+       * 决策点走独立的 `/decisions` 而不是复用 `/config`：那两份配置的校验规则
+       * 不同（决策点要拒绝未实装的点、预算要 clamp），混在一起容易互相放宽。
        */
-      const saveDecisions = react.useCallback(async () => {
-        const body = {};
-        if (pointsChanged) body.points = pointsDraft;
-        if (budgetChanged) body.budgetTokens = budgetDraft;
-        if (Object.keys(body).length === 0) return true;
-        const next = await call("/decisions", {
-          method: "PUT",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify(body),
-        });
-        setDecisions(next);
-        setPointsDraft({});
-        setBudgetDraft(null);
-        return true;
-      }, [pointsChanged, budgetChanged, pointsDraft, budgetDraft]);
+      const flush = async () => {
+        if (savingRef.current === true) return;
+        if (dirtyRef.current !== true) return;
+        const values = valuesRef.current;
+        const seq = editSeqRef.current;
+        const keyCommit = keyCommitRef.current;
+        const decisionsBody = pendingDecisions(values, decisions);
+        // 打字途中的非法地址：整笔延后（服务端必然拒绝，那一次 400 只是噪音）。
+        // 决策点与地址无关，仍然照常落盘——否则改个决策点也会被地址卡住。
+        const urlProblem = customUrlProblem(
+          values.providerDraft.customBaseUrl,
+          values.providerDraft.provider,
+        );
+        const configDeferred = urlProblem.length > 0;
+        if (configDeferred === true && decisionsBody === null) {
+          setSaveState({ error: `配置未保存：${urlProblem}` });
+          return;
+        }
+
+        const patch = configPatchOf(values, keyCommit);
+        // 只要带了 key 就必须写配置：key 不能因为「其它字段没变」被漏掉。
+        const keyWritten = ["systemoneApiKey", "bamboonodeApiKey", "customApiKey"].some((key) =>
+          Object.hasOwn(patch, key),
+        );
+        const configNeeded =
+          configDeferred !== true && (keyWritten === true || patchDiffersFromServer(patch, view) === true);
 
-      /** 一次点击提交两半：主配置 + 决策点。任一失败都要报错，不能静默半保存。 */
-      const saveAll = react.useCallback(async () => {
-        setBusy("save");
-        setMsg(null);
         savingRef.current = true;
+        setSaveState("saving");
+        setMsg(null);
         setProviderError("");
+        /** 失败的到底是哪一半：只有配置那一半才该显示成「provider 配置不可用」。 */
+        let failing = "config";
         try {
-          const patch = {
-            enabled: draft.enabled === true,
-            mode: draft.mode,
-            // 思考模式总是提交：它是全局项（与 provider 无关），
-            // 服务端还会再校验一次合法取值。
-            thinkMode: draft.thinkMode ?? "never",
-            // 模型字段只写当前 provider 自己那一格（model / systemoneModel /
-            // customModel）。混写会让「切过去再切回来」丢掉原值，也会把
-            // bamboonode 的模型名发给别的服务。
-            ...(providerDraft.provider === "custom"
-              ? { customModel: (providerDraft.customModel ?? "").trim() }
-              : providerDraft.provider === "systemone"
-                ? { systemoneModel: (draft.systemoneModel ?? "").trim() }
-                : { model: (draft.model ?? "").trim() }),
-            provider: providerDraft.provider,
-            // custom 的字段**总是**一起提交：用户可能先填地址再切 provider，
-            // 分两次保存会让中间状态被当成最终配置。值为空也照写，
-            // 便于用户清空后立刻纠正（服务端只在 provider=custom 时校验必填）。
-            customBaseUrl: (providerDraft.customBaseUrl ?? "").trim(),
-            customEndpointStyle: providerDraft.customEndpointStyle ?? "auto",
-            customHeaders: (providerDraft.customHeaders ?? "").trim(),
-            customApiKeyEnv: (providerDraft.customApiKeyEnv ?? "").trim(),
-          };
-          // 只提交「当前 provider」那一格：切过去时不会顺手存下别的 provider 的 key。
-          const activeKey = (keyInputs[providerDraft.provider] ?? "").trim();
-          if (activeKey.length >= 10) {
-            if (providerDraft.provider === "systemone") patch.systemoneApiKey = activeKey;
-            else if (providerDraft.provider === "custom") patch.customApiKey = activeKey;
-            else patch.bamboonodeApiKey = activeKey;
+          if (configNeeded === true) {
+            const next = await call("/config", {
+              method: "PUT",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify(patch),
+            });
+            // 用户又改过：只刷新服务端状态，草稿保留给下一次 flush。
+            if (seq === editSeqRef.current) applyServerState(next);
+            else setStatus(next);
           }
-          // 保存位置：只在用户改过时才提交，避免每次保存都覆盖。
-          if (storageDraft !== null) patch.keyStorage = storageDraft;
-          const next = await call("/config", {
-            method: "PUT",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(patch),
-          });
-          applyServerState(next);
-          if (Object.hasOwn(patch, "systemoneApiKey") || Object.hasOwn(patch, "bamboonodeApiKey") || Object.hasOwn(patch, "customApiKey")) {
-            setKeyInputs({ ...keyInputs, [providerDraft.provider]: "" });
+          failing = "decisions";
+          if (decisionsBody !== null) {
+            const next = await call("/decisions", {
+              method: "PUT",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify(decisionsBody),
+            });
+            setDecisions(next);
+            // 期间又有改动时不清草稿：那些改动还没落盘，清掉就等于吞了。
+            if (seq === editSeqRef.current) {
+              setPointsDraft({});
+              setBudgetDraft(null);
+            }
+          }
+          if (seq !== editSeqRef.current) {
+            // 期间的改动由 finally 接着发，这里保持「保存中」。
+            setSaveState("saving");
+          } else if (configDeferred === true) {
+            // 决策点存了，配置那一半还欠着（等地址补全）：**保持 dirty**，
+            // 否则地址改好之后没人会再发请求，改动就悄悄丢了。
+            dirtyRef.current = true;
+            setSaveState({ error: `配置未保存：${urlProblem}` });
+          } else {
+            dirtyRef.current = false;
+            if (keyWritten === true) {
+              keyCommitRef.current = null;
+              // 存完就清空输入框：与旧版「粘贴 → 保存 → 框变空」一致，
+              // 也让「已配置」的提示能立刻反映新值。
+              setKeyInputs({ ...values.keyInputs, [keyCommit]: "" });
+            }
+            setSaveState("saved");
           }
-          await saveDecisions();
-          setMsg({ ok: true, text: "已保存" });
         } catch (error) {
-          setMsg({ ok: false, text: error.message });
-          setProviderError(error.message);
+          const text = error instanceof Error ? error.message : String(error);
+          // 校验失败（非法 URL / 请求头格式）走这里：保留用户已填内容，
+          // 只把原因显示出来——清空表单会让用户重填一遍。
+          // dirty 保持 true：失败的那一半（可能是决策点）还没落盘，
+          // 重试按钮与后续编辑都要能把它带上。
+          dirtyRef.current = true;
+          setSaveState({ error: text });
+          if (failing === "config") setProviderError(text);
         } finally {
           savingRef.current = false;
-          setBusy("");
+          // 保存期间用户又改过：立刻再发一次，不等防抖（他已经停手了）。
+          if (dirtyRef.current === true && seq !== editSeqRef.current) void flush();
         }
-      }, [draft, keyInputs, storageDraft, providerDraft, saveDecisions]);
+      };
+      flushRef.current = flush;
+
+      /** 状态行的「重试」：把上一次失败的值原样再发一遍。 */
+      const retrySave = () => {
+        dirtyRef.current = true;
+        void flushRef.current();
+      };
 
       const runTest = react.useCallback(async () => {
         setBusy("test");
@@ -634,8 +847,15 @@ window.__ModuleLoader__.load({
         if (isCustom) setProviderDraft({ ...providerDraft, customModel: value });
         else if (isSystemOne) setDraft({ ...draft, systemoneModel: value });
         else setDraft({ ...draft, model: value });
-        setDirty(true);
-        dirtyRef.current = true;
+        // 下拉是离散控件：选完即存。
+        scheduleSave(
+          isCustom
+            ? { providerDraft: { ...providerDraft, customModel: value } }
+            : isSystemOne
+              ? { draft: { ...draft, systemoneModel: value } }
+              : { draft: { ...draft, model: value } },
+          true,
+        );
       };
 
       /**
@@ -651,23 +871,10 @@ window.__ModuleLoader__.load({
             : "";
 
       /**
-       * 本地预校验：与服务端同规则，只是为了让用户在点保存之前就看到问题。
-       * 服务端仍会独立校验（前端校验不可信），这里只求「早一点提示」。
+       * 本地预校验：与服务端同规则（见模块级 `customUrlProblem`），
+       * 只是为了让用户在落盘之前就看到问题。服务端仍会独立校验（前端校验不可信）。
        */
-      const customUrlError = (() => {
-        if (!isCustom) return "";
-        const raw = (providerDraft.customBaseUrl ?? "").trim();
-        if (raw.length === 0) return "必填：请填写 system-one 风格服务的 base URL";
-        if (/\s/.test(raw)) return "不能包含空格或换行";
-        if (!/^https?:\/\//i.test(raw)) return "必须以 http:// 或 https:// 开头";
-        try {
-          const url = new URL(raw);
-          if (url.search.length > 0) return "不要带查询串（? 之后的部分）";
-        } catch {
-          return "不是合法地址（示例：https://api.example.com/v1）";
-        }
-        return "";
-      })();
+      const customUrlError = isCustom ? customUrlProblem(providerDraft.customBaseUrl, "custom") : "";
 
       /** provider 提示文案：优先用服务端下发的说明，避免前端另写一份。 */
       const providerHint =
@@ -698,8 +905,10 @@ window.__ModuleLoader__.load({
                 // 切换 provider 只改「当前用哪个」，不动其它 provider 已保存的值：
                 // custom 的字段留在 providerDraft 里，切回来还在。
                 setProviderError("");
-                setDirty(true);
-                dirtyRef.current = true;
+                // 下拉是离散控件：选完即存。切到 custom 但地址还没填时，
+                // flush 会整笔延后并提示（见 flush 里的 urlProblem），
+                // 地址补全后自动落盘，不需要再点一次。
+                scheduleSave({ providerDraft: { ...providerDraft, provider: next } }, true);
               },
             },
             ...(catalog.length === 0
@@ -717,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",
         ),
@@ -732,8 +954,8 @@ window.__ModuleLoader__.load({
           toggle(draft.enabled === true, () => {
             const next = draft.enabled !== true;
             setDraft({ ...draft, enabled: next });
-            setDirty(true);
-            dirtyRef.current = true;
+            // 开关是离散控件：拨一下就落盘。
+            scheduleSave({ draft: { ...draft, enabled: next } }, true);
           }),
           "enabled",
         ),
@@ -744,8 +966,7 @@ window.__ModuleLoader__.load({
           toggle(draft.mode === "enforce", () => {
             const next = draft.mode === "enforce" ? "shadow" : "enforce";
             setDraft({ ...draft, mode: next });
-            setDirty(true);
-            dirtyRef.current = true;
+            scheduleSave({ draft: { ...draft, mode: next } }, true);
           }),
           "mode",
         ),
@@ -765,9 +986,10 @@ window.__ModuleLoader__.load({
               value: draft.thinkMode ?? "never",
               disabled: busy !== "",
               onChange: (event) => {
-                setDraft({ ...draft, thinkMode: event.target.value });
-                setDirty(true);
-                dirtyRef.current = true;
+                const next = { ...draft, thinkMode: event.target.value };
+                setDraft(next);
+                // 下拉是离散控件：选完即存。
+                scheduleSave({ draft: next }, true);
               },
             },
             // 选项由服务端下发（thinkModes），前端不硬编码取值，避免漂移。
@@ -830,7 +1052,9 @@ window.__ModuleLoader__.load({
           ),
           "model",
         ),
-        // 4) API Key：每个 provider 一格，各自保存各自的 key
+        // 4) API Key：每个 provider 一格，各自保存各自的 key。
+        //    密钥**只**在失焦或回车时落盘（commitKey）：打字途中自动保存会把
+        //    半截 key 写进凭据文件，比多一步确认更危险。
         row(
           `API Key${keyOk ? `（已配置 ${activeKeyStatus?.hint ?? view.keyHint ?? ""}）` : "（未配置）"}`,
           activeKeyStatus !== null
@@ -840,17 +1064,24 @@ window.__ModuleLoader__.load({
               // 混着说会让人去 .credentials.yaml 里找 key。
               ? `存到插件配置 config.yml 的 ${activeKeyStatus.keyField || "显式 key 字段"}（明文）`
               : `存到 .credentials.yaml 的 ${activeKeyStatus.refName}`
-            : "留空则不修改；粘贴新 key 后点保存",
+            : "留空则不修改；粘贴新 key 后失焦或回车即保存",
           h("input", {
             type: "password",
             style: S.input,
             placeholder: keyOk ? "sk-…（留空不改）" : "sk-…",
             value: keyInputs[providerDraft.provider] ?? "",
-            onChange: (event) =>
-              setKeyInputs({ ...keyInputs, [providerDraft.provider]: event.target.value }),
+            onChange: (event) => {
+              const next = { ...keyInputs, [providerDraft.provider]: event.target.value };
+              setKeyInputs(next);
+              // 同步进 ref：commitKey 读的是它。回车可能紧贴最后一次按键，
+              // 等重绘就来不及了。
+              valuesRef.current = { ...valuesRef.current, keyInputs: next };
+            },
+            // 密钥只在「明确提交」时落盘：失焦或回车。
+            onBlur: () => commitKey(providerDraft.provider),
             onKeyDown: (event) => {
               if (event.key !== "Enter") return;
-              if ((keyInputs[providerDraft.provider] ?? "").trim().length >= 10) void saveAll();
+              commitKey(providerDraft.provider);
             },
           }),
           "key",
@@ -869,8 +1100,8 @@ window.__ModuleLoader__.load({
               disabled: busy !== "",
               onChange: (event) => {
                 setStorageDraft(event.target.value);
-                setDirty(true);
-                dirtyRef.current = true;
+                // 下拉是离散控件：选完即存。
+                scheduleSave({ storageDraft: event.target.value }, true);
               },
             },
             h("option", { value: "credentials" }, ".credentials.yaml（默认）"),
@@ -898,29 +1129,33 @@ window.__ModuleLoader__.load({
                   placeholder: "https://api.example.com/v1",
                   value: providerDraft.customBaseUrl ?? "",
                   onChange: (event) => {
-                    setProviderDraft({ ...providerDraft, customBaseUrl: event.target.value });
+                    const next = { ...providerDraft, customBaseUrl: event.target.value };
+                    setProviderDraft(next);
                     setProviderError("");
-                    setDirty(true);
-                    dirtyRef.current = true;
+                    // 文本框：停手防抖落盘（打字途中的非法地址会被 flush 整笔延后）。
+                    scheduleSave({ providerDraft: next });
                   },
+                  onBlur: () => scheduleSave(null, true),
                 }),
                 "custom-url",
               ),
               row(
                 "端点风格",
-                "auto：地址已带 /decisions 或 /systemone 就原样用，否则按 /decisions 拼；也可强制指定",
+                "路径后缀由服务商决定（实测 SiliconFlow 只通 /systemone，bamboonode 两条都通）。" +
+                  "这里是「首选」：若首选路径返回 404，插件会自动改用另一条再试一次",
                 h(
                   "select",
                   {
                     style: { ...S.input, minWidth: "150px", flex: "none" },
                     value: providerDraft.customEndpointStyle ?? "auto",
                     onChange: (event) => {
-                      setProviderDraft({ ...providerDraft, customEndpointStyle: event.target.value });
-                      setDirty(true);
-                      dirtyRef.current = true;
+                      const next = { ...providerDraft, customEndpointStyle: event.target.value };
+                      setProviderDraft(next);
+                      // 下拉是离散控件：选完即存。
+                      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"),
                 ),
@@ -935,10 +1170,11 @@ window.__ModuleLoader__.load({
                   placeholder: "X-Tenant: team-a; X-Trace: dsh",
                   value: providerDraft.customHeaders ?? "",
                   onChange: (event) => {
-                    setProviderDraft({ ...providerDraft, customHeaders: event.target.value });
-                    setDirty(true);
-                    dirtyRef.current = true;
+                    const next = { ...providerDraft, customHeaders: event.target.value };
+                    setProviderDraft(next);
+                    scheduleSave({ providerDraft: next });
                   },
+                  onBlur: () => scheduleSave(null, true),
                 }),
                 "custom-headers",
               ),
@@ -951,10 +1187,11 @@ window.__ModuleLoader__.load({
                   placeholder: "MY_DECISION_API_KEY",
                   value: providerDraft.customApiKeyEnv ?? "",
                   onChange: (event) => {
-                    setProviderDraft({ ...providerDraft, customApiKeyEnv: event.target.value });
-                    setDirty(true);
-                    dirtyRef.current = true;
+                    const next = { ...providerDraft, customApiKeyEnv: event.target.value };
+                    setProviderDraft(next);
+                    scheduleSave({ providerDraft: next });
                   },
+                  onBlur: () => scheduleSave(null, true),
                 }),
                 "custom-env",
               ),
@@ -986,6 +1223,7 @@ window.__ModuleLoader__.load({
               h("div", { style: S.sectionTitle }, "决策模型参与点"),
               ...(decisions.points ?? []).map((point) => {
                 const current = Object.hasOwn(pointsDraft, point.id) ? pointsDraft[point.id] : point.mode;
+                // 点完即存：这个角标只在「请求还在路上」的那一小会儿出现。
                 const changed = Object.hasOwn(pointsDraft, point.id) && pointsDraft[point.id] !== point.mode;
                 const st = point.stats ?? {};
                 // 「可用」与「已挂载」是两件事：点已实装（available），但宿主
@@ -1034,7 +1272,12 @@ window.__ModuleLoader__.load({
                               type: "button",
                               key: mode,
                               disabled: busy !== "",
-                              onClick: () => setPointsDraft({ ...pointsDraft, [point.id]: mode }),
+                              onClick: () => {
+                                const next = { ...pointsDraft, [point.id]: mode };
+                                setPointsDraft(next);
+                                // 三态分段是离散控件：点一下就落盘。
+                                scheduleSave({ pointsDraft: next }, true);
+                              },
                               style: S.segItem(
                                 current === mode,
                                 mode === "enforce"
@@ -1048,7 +1291,7 @@ window.__ModuleLoader__.load({
                           ),
                         ),
                       ),
-                  changed ? h("span", { style: { ...S.badge, borderStyle: "solid", opacity: 0.9 } }, "待保存") : null,
+                  changed ? h("span", { style: { ...S.badge, borderStyle: "solid", opacity: 0.9 } }, "保存中") : null,
                 );
               }),
               // 自身预算：决策模型自己也烧 token，不设上限会变成主要消耗方。
@@ -1073,8 +1316,12 @@ window.__ModuleLoader__.load({
                   defaultValue: decisions.budget?.limit ?? 0,
                   onChange: (event) => {
                     const value = Number(event.target.value);
-                    setBudgetDraft(Number.isFinite(value) ? Math.max(0, Math.floor(value)) : null);
+                    const next = Number.isFinite(value) ? Math.max(0, Math.floor(value)) : null;
+                    setBudgetDraft(next);
+                    // 数字框是文本输入：停手防抖落盘。
+                    scheduleSave({ budgetDraft: next });
                   },
+                  onBlur: () => scheduleSave(null, true),
                 }),
               ),
               // 缓存命中：0 命中说明白名单外的调用每次都真发请求，是主要浪费。
@@ -1085,38 +1332,55 @@ window.__ModuleLoader__.load({
                   `同类复用 ${decisions.cache?.softHits ?? 0} · 命中率 ${Math.round((decisions.cache?.hitRate ?? 0) * 100)}%`,
               ),
             ),
-        // 4) 保存按钮（同时提交开关、provider 与 key）
+        // 4) 自动保存状态行：**没有「保存」按钮**，改动即落盘。
+        //    这一行回答的是「刚才那一下到底存没存」：进行中 / 已存 /
+        //    失败原因（附重试）。原来那个按钮的「保存中…」搬到这里。
         h(
           "div",
-          { style: { display: "flex", gap: "8px", margin: "14px 0 4px" }, key: "actions" },
+          { style: { display: "flex", gap: "8px", alignItems: "center", margin: "14px 0 4px" }, key: "actions" },
+          // 常驻说明：让第一次进来的人知道不需要找保存按钮。
           h(
-            "button",
-            {
-              type: "button",
-              // 保存按钮的可用条件必须包含 providerChanged 与 custom key：
-              // 少一项就会出现「改了 provider 但按钮是灰的」。
-              disabled:
-                busy !== "" ||
-                (dirty !== true &&
-                  (keyInputs[providerDraft.provider] ?? "").trim().length < 10 &&
-                  decisionsChanged !== true &&
-                  providerChanged !== true),
-              onClick: () => void saveAll(),
-              style: {
-                ...S.saveBtn,
-                opacity:
-                  busy !== "" ||
-                  (dirty !== true &&
-                    (keyInputs[providerDraft.provider] ?? "").trim().length < 10 &&
-                    decisionsChanged !== true &&
-                    providerChanged !== true)
-                    ? 0.5
-                    : 1,
-                cursor: busy !== "" ? "default" : "pointer",
-              },
-            },
-            busy === "save" ? "保存中…" : "保存",
+            "span",
+            { style: { ...S.meta, marginTop: 0, flex: 1, opacity: 0.55 } },
+            saveState === "pending"
+              ? "待保存…"
+              : saveState === "saving"
+                ? "保存中…"
+                : saveState === "saved"
+                  ? "已保存（改动即生效，无需点保存）"
+                  : saveState !== null && typeof saveState === "object" && typeof saveState.error === "string"
+                    ? null
+                    : "改动即保存",
           ),
+          // 失败：原因直接给出来，另配「重试」——不能让用户只看到「保存失败」
+          // 而不知道该改什么、能不能再试一次。
+          saveState !== null && typeof saveState === "object" && typeof saveState.error === "string"
+            ? h(
+                "span",
+                {
+                  style: {
+                    ...S.meta,
+                    marginTop: 0,
+                    flex: 1,
+                    color: "#f87171",
+                    opacity: 1,
+                  },
+                },
+                `未保存：${saveState.error}`,
+              )
+            : null,
+          saveState !== null && typeof saveState === "object" && typeof saveState.error === "string"
+            ? h(
+                "button",
+                {
+                  type: "button",
+                  disabled: busy !== "",
+                  onClick: retrySave,
+                  style: { ...S.saveBtn, flexShrink: 0, padding: "6px 10px" },
+                },
+                "重试",
+              )
+            : null,
           h(
             "button",
             {