pi-web-ui 0.59.1 → 0.61.0

package/dist/server/agent-service.js

@@ -27,7 +27,7 @@ import { ModelAdminService } from "./model-admin.js";
 import { FilesService, workspacePath } from "./files-service.js";
 import { isExtensionDisabled, ClientStateStore, } from "./client-state.js";
 import { saveUpload } from "./uploads.js";
-import { makePersistentTerminalTools, makeTerminalBashTool, stripAnsi, TERMINAL_TOOLS_GUIDANCE, TERMINAL_TOOL_NAMES, } from "./terminals.js";
+import { applyHeadTail, makePersistentTerminalTools, makeTerminalBashTool, stripAnsi, TERMINAL_TOOLS_GUIDANCE, TERMINAL_TOOL_NAMES, } from "./terminals.js";
 import { WebUIContext } from "./webui-context.js";
 import { buildAttachmentMessages, parseModelSpec, } from "./attachments.js";
 import { serializeMessage, serializeStreamingMessage, } from "./serialize.js";
@@ -82,14 +82,14 @@ export class QuiesceRejectedError extends Error {
  *  programs wait for input that never comes. Legacy Chinese files are often
  *  GBK/GB2312 — read them with the right encoding, never paste mojibake into
  *  reasoning/answers. */
-const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
-
-
-
-- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
-- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
-- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
-
+const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
+
+
+
+- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
+- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
+- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
+
 Many legacy Chinese text files (.html/.txt/.md/.log, exported documents) are GBK/GB2312 encoded: the read tool decodes UTF-8 only and will show mojibake (乱码) for them. If a file's content looks garbled, read it through the terminal instead: in Git Bash use \`cat file | iconv -f GBK -t UTF-8\` (or \`iconv -f GBK -t UTF-8 file\`); in cmd use \`chcp 65001 && type file\`; in PowerShell use \`Get-Content -Encoding Default file\`. Never paste mojibake into your reasoning or answer — describe the decoded content instead.`;
 /** bash 工具输出限制/过滤管道引导：模型习惯套 `| tail/-n`、`| head`、`| grep`、`| less`
  *  等限输出。这些管道在持久终端里会①缓冲（可见终端全程哑火、看不到实时进度）②把退出码
@@ -97,13 +97,14 @@ Many legacy Chinese text files (.html/.txt/.md/.log, exported documents) are GBK
  *  让模型改用 bash 的 `tail` 参数限输出；长驻/交互任务改走持久终端工具。 */
 const PIPELESS_BASH_GUIDANCE = `Bash tool output-limiting/filtering: do NOT chain shell pipes to trim or filter output. Avoid \`| tail\`, \`| head\`, \`| grep\`, \`| less\`, \`| more\`, \`| cat\`, \`| sort\`, \`| awk\`, \`| sed\`. They buffer output (so the visible terminal shows nothing live), turn the real exit code into the last pipe command's (tail always 0, grep 1 when no match — hiding the actual failure), and can hang a long-running or failing command until timeout. Instead:\n- To limit returned output use the bash \`tail\` parameter (e.g. \`bash(command=..., tail=20)\`) — the underlying command still streams live to the visible terminal.\n- For a long-running server / watcher / interactive program, use the persistent terminal tools (terminal_create then terminal_read / terminal_input / terminal_key / terminal_wait) instead of piping through bash.\nThe bash tool auto-detects a trailing \`| tail\`/\`| grep\` etc. and runs the underlying command directly so it never hides a failure — but you should still prefer the \`tail\` parameter.`;
 /**
- * Killable bash tool: wraps the SDK bash tool with operations that register
- * their own AbortController into a client-level set. abortBash() aborts only
- * those controllers → the command's process tree is killed while the agent
- * run and the conversation continue (the tool returns an aborted error and
- * the model moves on). Injected as a customTool overriding the builtin bash.
+ * Killable bash tool: wraps the SDK bash tool (native process spawn, NO terminal).
+ * Used when the「默认 bash 覆盖」setting is OFF. Registers its own AbortController
+ * into a client-level set (kills) so abortBash() kills only these commands while the
+ * agent run and the conversation continue. Exposes persist (ignored — native has no
+ * terminal) plus head/tail (post-processed on the returned output) so the parameter
+ * schema stays consistent with the terminal-backed tool.
  */
-function makeKillableBashTool(cwd, kills) {
+export function makeKillableBashTool(cwd, kills) {
     const base = createLocalBashOperations();
     const tool = createBashTool(cwd, {
         operations: {
@@ -127,20 +128,50 @@ function makeKillableBashTool(cwd, kills) {
     return {
         name: tool.name,
         label: tool.label,
-        description: tool.description,
-        parameters: tool.parameters,
+        description: "Run a shell command natively (process spawn, no terminal) and return its full output plus exit code — the SDK's plain bash tool. persist is ignored here (no terminal); use head/tail to trim the returned output.",
+        parameters: Type.Object({
+            command: Type.String({ description: "The shell command to run" }),
+            timeout: Type.Optional(Type.Number({ description: "Optional timeout in seconds" })),
+            persist: Type.Optional(Type.Boolean({
+                description: "Ignored in native mode (no terminal). Only meaningful when the terminal-backed bash is active.",
+            })),
+            head: Type.Optional(Type.Integer({
+                minimum: 1,
+                maximum: 5000,
+                description: "Only return the FIRST N lines of output (like `| head -N`).",
+            })),
+            tail: Type.Optional(Type.Integer({
+                minimum: 1,
+                maximum: 5000,
+                description: "Only return the LAST N lines of output (like `| tail -N`).",
+            })),
+        }),
         prepareArguments: tool.prepareArguments,
         executionMode: tool.executionMode,
-        execute: (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
+        execute: async (toolCallId, params, signal, onUpdate) => {
+            const result = (await tool.execute(toolCallId, params, signal, onUpdate));
+            // head/tail 后处理（native 无终端，直接截返回行即可）。
+            const p = params;
+            if ((p?.head || p?.tail) && result?.content?.[0]?.text != null) {
+                result.content[0].text = applyHeadTail(result.content[0].text, p.head, p.tail);
+            }
+            return result;
+        },
     };
 }
 /**
- * 动态分流 bash：调用时按设置决定走哪套实现——「终端接管 bash」开关因此
- * 即时生效（customTools 在 runtime 创建时固定，不能在创建时二选一）。
+ * 动态分流 bash：按「默认 bash 覆盖」设置（terminalBash）在调用时决定走哪套——
+ * 关 = 原生 SDK bash（纯进程、不开终端）；开 = 终端接管 bash（persist 决定一次性/
+ * 持久）。开关因此即时生效（customTools 固定于 runtime 创建，不能在创建时二选一）。
  */
-function makeAdaptiveBashTool(killable, terminalBacked, useTerminal) {
+export function makeAdaptiveBashTool(killable, terminalBacked, useTerminal) {
     return {
         ...killable,
+        description: "Run a shell command and return its full output plus exit code. Behavior depends on the「default bash override」setting (terminalBash):\n" +
+            "Setting OFF → runs natively (process spawn, no terminal) — the SDK's plain bash tool. persist has no effect.\n" +
+            "Setting ON → runs in a visible terminal. persist=true keeps that terminal alive ('ai-bash': shell state such as cd/venv/ssh retained across calls, silent commands move to the background and notify when done); persist=false (default in terminal mode) creates a one-shot terminal that exits when the command finishes while its output stays for review.\n" +
+            "Run the bare command — do NOT pipe through head/tail/more/less (use the head/tail parameters to trim the returned output instead; piping also hides live progress in the visible terminal). For interactive commands (REPLs, prompts, installers asking y/n) set persist=true (terminal mode) and drive them with terminal_input / terminal_key.",
+        promptSnippet: "run shell commands",
         execute: (id, params, signal, onUpdate, ctx) => (useTerminal() ? terminalBacked : killable).execute(id, params, signal, onUpdate, ctx),
     };
 }
@@ -702,6 +733,8 @@ export class ClientSession {
             }
         }
         await cs.bindSession();
+        await cs.restoreProjectProviderKeysForCwd(cwd);
+        await cs.restoreProjectModelForCwd(cwd);
         return cs;
     }
     /**
@@ -772,21 +805,20 @@ export class ClientSession {
             const created = await createAgentSessionFromServices({
                 services,
                 sessionManager,
-                // 可手动停止的 bash 工具：覆盖 SDK 内置 bash（customTools 按 name
-                // 覆盖），执行时把自己的 AbortController 注册进客户端集合——
-                // abortBash() 只杀这些命令，agent run 与对话继续。
+                // 覆盖 SDK 内置 bash（customTools 按 name 覆盖）。双实现分流：
+                // 「默认 bash 覆盖」开关（terminalBash）关 → 原生 SDK bash（纯进程、不开终端）；
+                // 开 → 终端接管 bash（persist 决定一次性/持久，可静默自动转后台）。
                 customTools: [
-                    // bash 双实现动态分流：「终端接管」开启时命令跑进持久可见终端
-                    // （保留 shell 状态、静默自动转后台），关闭时是原生 killable bash。
                     makeAdaptiveBashTool(makeKillableBashTool(effectiveCwd, this.bashKills), makeTerminalBashTool(terminals, {
                         cwd: effectiveCwd,
-                        idleMs: () => this.settingsSvc.current.terminalBash
-                            ? Math.max(0, Math.floor(this.settingsSvc.current.terminalBashIdleMs) ||
-                                0)
-                            : 0,
+                        // 设置开 = 用终端；此分支里 persist 未显式给时默认一次性（false）。
+                        defaultPersist: () => false,
+                        idleMs: () => Math.max(0, Math.floor(this.settingsSvc.current.terminalBashIdleMs) || 0),
                         kills: this.bashKills,
                         notifyBackgroundDone: (info) => this.notifyTerminalBashDone(terminals, info),
-                    }), () => this.settingsSvc.current.terminalBash),
+                    }), 
+                    // 设置关 → 原生 bash；开 → 终端 bash。
+                    () => this.settingsSvc.current.terminalBash),
                     ...makePersistentTerminalTools(terminals, effectiveCwd),
                     // 插件注册的 AI 工具（创建时刻的实时快照；后续注册经
                     // refreshPluginTools 动态补入已有会话）。
@@ -898,6 +930,9 @@ export class ClientSession {
         // Reconnect: push the background-task list — it must survive reconnects
         // and outlive the conversation that started the tasks.
         this.bg.push();
+        // Reconnect: push the built-in provider key list (multi-key grouping in the
+        // model picker needs it even before the client asks).
+        this.modelAdmin.listProviderKeys();
         // PTYs are conversation-owned and survive a socket reconnect.
         this.pushTerminals();
     }
@@ -1783,6 +1818,120 @@ export class ClientSession {
     deleteModelConfig(providerId) {
         return this.modelAdmin.deleteModelConfig(providerId);
     }
+    listProviderKeys() {
+        return this.modelAdmin.listProviderKeys();
+    }
+    async addProviderKey(provider, apiKey, name) {
+        await this.modelAdmin.addProviderKey(provider, apiKey, name);
+        const active = this.modelAdmin.getActiveKeyName(provider);
+        if (active)
+            this.stateStore.saveProjectProviderKey(this.clientId, this.cwd, provider, active);
+    }
+    async activateProviderKey(provider, keyName) {
+        await this.modelAdmin.activateProviderKey(provider, keyName);
+        this.stateStore.saveProjectProviderKey(this.clientId, this.cwd, provider, keyName);
+    }
+    async removeProviderKey(provider, keyName) {
+        await this.modelAdmin.removeProviderKey(provider, keyName);
+        const saved = this.stateStore.getProjectProviderKey(this.clientId, this.cwd, provider);
+        if (saved === keyName) {
+            const active = this.modelAdmin.getActiveKeyName(provider);
+            if (active)
+                this.stateStore.saveProjectProviderKey(this.clientId, this.cwd, provider, active);
+            else
+                this.stateStore.deleteProjectProviderKey(this.clientId, this.cwd, provider);
+        }
+    }
+    /** Restore per-project provider keys when entering a project. For each
+     *  provider that has a saved key for `cwd`, activate it if it differs from
+     *  the current global active. Silent — no notice spam on project switch. */
+    async restoreProjectProviderKeysForCwd(cwd) {
+        const saved = this.stateStore.getProjectProviderKeys(this.clientId, cwd);
+        if (!saved)
+            return;
+        for (const [provider, keyName] of Object.entries(saved)) {
+            const cur = this.modelAdmin.getActiveKeyName(provider);
+            if (cur === keyName)
+                continue;
+            try {
+                await this.modelAdmin.activateProviderKey(provider, keyName);
+            }
+            catch {
+                // saved key may have been deleted — ignore
+            }
+        }
+    }
+    /** When a model is set, ensure its provider's per-project key is restored. */
+    async restoreKeyForModel(modelId, cwd) {
+        const slash = modelId.indexOf("/");
+        if (slash <= 0)
+            return;
+        const provider = modelId.slice(0, slash);
+        const saved = this.stateStore.getProjectProviderKey(this.clientId, cwd, provider);
+        if (!saved)
+            return;
+        const cur = this.modelAdmin.getActiveKeyName(provider);
+        if (cur === saved)
+            return;
+        try {
+            await this.modelAdmin.activateProviderKey(provider, saved);
+        }
+        catch { }
+    }
+    /** Remember the just-selected model (and the key that was active for its
+     *  provider) for the current project. Called IMMEDIATELY on model selection —
+     *  not only after a turn — so switching back to the project restores the exact
+     *  {model, key} left behind, even for a fresh conversation with no assistant
+     *  message yet (the SDK only flushes a model_change to disk once one exists). */
+    rememberProjectModel(modelId) {
+        const cwd = this.cwd;
+        this.stateStore.saveProjectModel(this.clientId, cwd, modelId);
+        const slash = modelId.indexOf("/");
+        if (slash <= 0)
+            return;
+        const provider = modelId.slice(0, slash);
+        const active = this.modelAdmin.getActiveKeyName(provider);
+        if (active)
+            this.stateStore.saveProjectProviderKey(this.clientId, cwd, provider, active);
+    }
+    /** Restore the project's remembered model (and its provider's key) onto the
+     *  ACTIVE conversation — but ONLY for a conversation the user hasn't really
+     *  started (no messages yet). A conversation that already has content keeps its
+     *  own per-session model: switching back to a RUNNING / completed chat must not
+     *  silently overwrite its model with the project default. So a fresh chat in the
+     *  project gets the remembered model; an in-progress one keeps what it had and
+     *  the user switches via the picker. Silent on failure (model no longer in catalog). */
+    async restoreProjectModelForCwd(cwd) {
+        const savedModel = this.stateStore.getProjectModel(this.clientId, cwd);
+        if (!savedModel)
+            return;
+        try {
+            if (this.conv.session.getSessionStats().totalMessages > 0)
+                return;
+        }
+        catch {
+            return;
+        }
+        try {
+            const mr = this.runtime.services.modelRuntime;
+            const slash = savedModel.indexOf("/");
+            if (slash <= 0 || slash === savedModel.length - 1)
+                return;
+            const model = mr.getModel(savedModel.slice(0, slash), savedModel.slice(slash + 1));
+            if (!model)
+                return;
+            const cur = this.session.model;
+            const curId = cur ? `${cur.provider}/${cur.id}` : null;
+            // Restore the model's provider key first so setModel's auth check passes.
+            await this.restoreKeyForModel(savedModel, cwd);
+            if (curId === savedModel)
+                return;
+            await this.session.setModel(model);
+        }
+        catch {
+            // model no longer resolvable / key gone — keep the conversation default
+        }
+    }
     // ---------------------------------------------------------------------------
     // Settings (system prompt / skills / extensions / presets)
     // ---------------------------------------------------------------------------
@@ -2056,8 +2205,8 @@ export class ClientSession {
     }
     /** Kill only the running bash command(s) — the agent run itself continues
      *  (the bash tool returns an aborted error and the model moves on). Uses
-     *  the per-client AbortController set registered by
-     *  makeKillableBashTool. */
+     *  the per-client AbortController set registered by the bash tool paths
+     *  ({@link makeKillableBashTool} / {@link makeTerminalBashTool}). */
     async abortBash() {
         if (this.bashKills.size === 0) {
             this.emit({
@@ -2236,6 +2385,9 @@ export class ClientSession {
             if (prevModel && this.sharedModelRuntime) {
                 try {
                     await this.session.setModel(prevModel);
+                    const p = prevModel.provider;
+                    const mid = `${p}/${prevModel.id}`;
+                    await this.restoreKeyForModel(mid, this.cwd);
                 }
                 catch {
                     // model no longer resolvable — keep the default
@@ -2333,6 +2485,8 @@ export class ClientSession {
         void this.pushSlashCommands();
         if (cwdChanged) {
             this.cwd = newCwd;
+            await this.restoreProjectProviderKeysForCwd(newCwd);
+            await this.restoreProjectModelForCwd(newCwd);
             // Mirror set_cwd's project-switch side-effects so the whole UI follows
             // the new workspace, not just the chat pane.
             try {
@@ -2615,6 +2769,8 @@ export class ClientSession {
                 this.removeConversation(displaced.id);
             await this.bindSession();
             this.cwd = targetCwd;
+            await this.restoreProjectProviderKeysForCwd(targetCwd);
+            await this.restoreProjectModelForCwd(targetCwd);
             this.conv.lastActiveAt = Date.now();
             this.webUi.refresh();
             this.emitConversations();
@@ -2716,6 +2872,8 @@ export class ClientSession {
             if (prevModel && this.sharedModelRuntime) {
                 try {
                     await this.session.setModel(prevModel);
+                    const pm = prevModel;
+                    await this.restoreKeyForModel(`${pm.provider}/${pm.id}`, this.cwd);
                 }
                 catch {
                     // model no longer resolvable — keep the default
@@ -2831,7 +2989,13 @@ export class ClientSession {
     }
     async cycleModel() {
         try {
-            await this.session.cycleModel();
+            const result = await this.session.cycleModel();
+            if (result?.model) {
+                const mid = `${result.model.provider}/${result.model.id}`;
+                await this.restoreKeyForModel(mid, this.cwd);
+                // Remember per-project like setModel — cycling is also a model switch.
+                this.rememberProjectModel(mid);
+            }
         }
         catch (err) {
             this.emit({
@@ -2912,6 +3076,8 @@ export class ClientSession {
             this.conv.promptedSinceActive = false;
             this.conv.lastActiveAt = Date.now();
             this.cwd = abs;
+            await this.restoreProjectProviderKeysForCwd(abs);
+            await this.restoreProjectModelForCwd(abs);
             // 工作区跟随型插件（编辑器文件树等）同步切根。
             try {
                 this.onCwdChanged?.(abs);
@@ -3011,6 +3177,11 @@ export class ClientSession {
             if (!model)
                 throw new Error(`模型不存在：${modelId}`);
             await this.session.setModel(model);
+            await this.restoreKeyForModel(modelId, this.cwd);
+            // Immediately remember the model + the key it uses for the current
+            // project (not only after a turn). This is what makes project switching
+            // restore both the model and the provider key.
+            this.rememberProjectModel(modelId);
         }
         catch (err) {
             this.emit({

package/dist/server/attachments.js

@@ -448,9 +448,9 @@ export async function buildAttachmentMessages(ctx, attachments) {
                         content: [
                             {
                                 type: "text",
-                                text: `
-<vision-bridge>
-${transcript}
+                                text: `
+<vision-bridge>
+${transcript}
 </vision-bridge>`,
                             },
                             ...(pathImg

package/dist/server/client-state.js

@@ -231,4 +231,56 @@ export class ClientStateStore {
         state.presets = presets;
         this.save();
     }
+    /** Get per-project provider keys for a cwd, or undefined. */
+    getProjectProviderKeys(clientId, cwd) {
+        return this.load()[clientId]?.projectProviderKeys?.[cwd];
+    }
+    /** Get a single provider's saved key for a project. */
+    getProjectProviderKey(clientId, cwd, provider) {
+        return this.load()[clientId]?.projectProviderKeys?.[cwd]?.[provider];
+    }
+    /** Remember which key was last used for a provider in a project. */
+    saveProjectProviderKey(clientId, cwd, provider, keyName) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        const map = (state.projectProviderKeys ??= {});
+        const inner = (map[cwd] ??= {});
+        inner[provider] = keyName;
+        this.save();
+    }
+    /** Delete a per-project provider key (e.g. when the key is removed). */
+    deleteProjectProviderKey(clientId, cwd, provider) {
+        const all = this.load();
+        const inner = all[clientId]?.projectProviderKeys?.[cwd];
+        if (!inner || !(provider in inner))
+            return;
+        delete inner[provider];
+        if (Object.keys(inner).length === 0) {
+            delete all[clientId].projectProviderKeys[cwd];
+        }
+        this.save();
+    }
+    /** Get the model the user last selected in a project, or undefined. */
+    getProjectModel(clientId, cwd) {
+        return this.load()[clientId]?.projectModels?.[cwd];
+    }
+    /** Remember the model last selected in a project (immediate, not after a turn). */
+    saveProjectModel(clientId, cwd, modelId) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        (state.projectModels ??= {})[cwd] = modelId;
+        this.save();
+    }
+    /** Drop the per-project model memory for a project (e.g. when the model is
+     *  removed from the catalog). */
+    deleteProjectModel(clientId, cwd) {
+        const all = this.load();
+        const map = all[clientId]?.projectModels;
+        if (!map || !(cwd in map))
+            return;
+        delete map[cwd];
+        if (Object.keys(map).length === 0)
+            delete all[clientId].projectModels;
+        this.save();
+    }
 }

package/dist/server/dsh/dsh-agent-service.js

@@ -2526,6 +2526,18 @@ export class DshClientSession {
             ],
         });
     }
+    listProviderKeys() {
+        this.emit({ type: "provider_keys", keys: {} });
+    }
+    async addProviderKey(provider, apiKey, name) {
+        this.emit({ type: "notice", level: "warning", text: "DSH 引擎不支持多密钥" });
+    }
+    async activateProviderKey(provider, keyName) {
+        this.emit({ type: "notice", level: "warning", text: "DSH 引擎不支持多密钥" });
+    }
+    async removeProviderKey(provider, keyName) {
+        this.emit({ type: "notice", level: "warning", text: "DSH 引擎不支持多密钥" });
+    }
     async fetchModelsList(reqId, baseUrl, apiKey, authHeader, api) {
         this.emit({ type: "fetch_models_result", reqId, ok: false, error: "DSH 引擎不支持自定义 provider 探测" });
     }
@@ -2533,7 +2545,9 @@ export class DshClientSession {
         this.emit({ type: "refresh_provider_result", reqId, ok: false, error: "DSH 引擎不支持自定义 provider" });
     }
     async cloneProvider(provider, reqId) {
-        this.emit({ type: "clone_provider_result", reqId, ok: false, error: "DSH 引擎不支持自定义 provider" });
+        const error = "DSH 引擎不支持自定义 provider";
+        this.emit({ type: "notice", level: "error", text: error });
+        this.emit({ type: "clone_provider_result", reqId, ok: false, error });
     }
     // -----------------------------------------------------------------------
     // 其他