@huyooo/ai-chat-bridge-electron 0.1.6 → 0.2.0

package/dist/main/index.js

@@ -1,66 +1,149 @@
 // src/main/index.ts
-import { ipcMain } from "electron";
+import { ipcMain, shell } from "electron";
+import * as fs from "fs";
+import * as path from "path";
 import {
   HybridAgent,
-  AVAILABLE_MODELS
+  MODELS,
+  DEFAULT_MODEL
 } from "@huyooo/ai-chat-core";
+import { createSearchElectronBridge } from "@huyooo/ai-search/bridge/electron";
 import {
-  createStorage,
-  getDefaultStoragePath
+  createStorage
 } from "@huyooo/ai-chat-storage";
 async function createElectronBridge(options) {
   const {
     channelPrefix = "ai-chat",
-    storagePath,
+    dataDir,
     defaultContext = {},
     ...agentConfig
   } = options;
-  const agent = new HybridAgent(agentConfig);
+  const resolvedStoragePath = path.join(dataDir, "db.sqlite");
+  createSearchElectronBridge({
+    ipcMain,
+    channelPrefix
+  }).init();
+  const pendingApprovals = /* @__PURE__ */ new Map();
+  const toolApprovalCallback = async (toolCall) => {
+    console.log("[Main] \u5DE5\u5177\u6279\u51C6\u56DE\u8C03\u88AB\u8C03\u7528:", toolCall.name);
+    const currentWebContents = global.currentWebContents;
+    if (!currentWebContents) {
+      console.log("[Main] \u8B66\u544A: \u6CA1\u6709 webContents\uFF0C\u9ED8\u8BA4\u6279\u51C6");
+      return true;
+    }
+    return new Promise((resolve2, reject) => {
+      pendingApprovals.set(toolCall.id, {
+        resolve: resolve2,
+        reject,
+        webContents: currentWebContents
+      });
+      console.log("[Main] \u53D1\u9001\u5DE5\u5177\u6279\u51C6\u8BF7\u6C42\u5230\u524D\u7AEF:", toolCall.name);
+      currentWebContents.send(`${channelPrefix}:toolApprovalRequest`, {
+        id: toolCall.id,
+        name: toolCall.name,
+        args: toolCall.args
+      });
+    });
+  };
   const storage = await createStorage({
     type: "sqlite",
-    sqlitePath: storagePath || getDefaultStoragePath()
+    sqlitePath: resolvedStoragePath
   });
   const getContext = () => defaultContext;
+  const getAutoRunConfig = async () => {
+    try {
+      const configJson = await storage.getUserSetting("autoRunConfig", getContext());
+      if (configJson) {
+        return JSON.parse(configJson);
+      }
+    } catch (error) {
+      console.error("[Main] \u83B7\u53D6 autoRunConfig \u5931\u8D25:", error);
+    }
+    return void 0;
+  };
+  const agent = new HybridAgent({
+    ...agentConfig,
+    // tools 直接传递 ToolConfigItem[]，HybridAgent 会在 asyncInit 中解析
+    tools: options.tools,
+    onToolApprovalRequest: toolApprovalCallback,
+    getAutoRunConfig
+  });
   ipcMain.handle(`${channelPrefix}:models`, () => {
-    return AVAILABLE_MODELS;
+    return MODELS;
   });
   ipcMain.handle(`${channelPrefix}:send`, async (event, params) => {
     const webContents = event.sender;
     const { message, images, options: options2 = {}, sessionId } = params;
+    global.currentWebContents = webContents;
     console.log("[AI-Chat] \u6536\u5230\u6D88\u606F:", { message, options: options2, images: images?.length || 0, sessionId });
+    console.log("[AI-Chat] autoRunConfig:", JSON.stringify(options2.autoRunConfig, null, 2));
     try {
-      for await (const progress of agent.chat(message, options2, images)) {
+      for await (const chatEvent of agent.chat(message, options2, images)) {
         console.log(
-          "[AI-Chat] \u8FDB\u5EA6:",
-          progress.type,
-          progress.type === "text_delta" ? progress.data.slice(0, 20) : progress.type === "thinking" ? JSON.stringify(progress.data) : progress.type === "search_result" ? `\u641C\u7D22\u5B8C\u6210 ${progress.data.results?.length || 0} \u6761` : JSON.stringify(progress.data).slice(0, 100)
+          "[AI-Chat] \u4E8B\u4EF6:",
+          chatEvent.type,
+          chatEvent.type === "text_delta" ? chatEvent.data.content.slice(0, 20) : chatEvent.type === "thinking_delta" ? chatEvent.data.content.slice(0, 20) : chatEvent.type === "search_result" ? `\u641C\u7D22\u5B8C\u6210 ${chatEvent.data.results?.length || 0} \u6761` : JSON.stringify(chatEvent.data).slice(0, 100)
         );
         if (!webContents.isDestroyed()) {
-          webContents.send(`${channelPrefix}:progress`, progress);
+          webContents.send(`${channelPrefix}:progress`, { ...chatEvent, sessionId });
         }
       }
       console.log("[AI-Chat] \u5B8C\u6210");
     } catch (error) {
       console.error("[AI-Chat] \u9519\u8BEF:", error);
+      if (error instanceof Error) {
+        console.error("[AI-Chat] \u9519\u8BEF\u8BE6\u60C5:", {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        });
+      }
       if (!webContents.isDestroyed()) {
+        const errorData = error instanceof Error ? {
+          category: "api",
+          message: error.message || String(error),
+          cause: error.stack
+        } : {
+          category: "api",
+          message: String(error)
+        };
         webContents.send(`${channelPrefix}:progress`, {
           type: "error",
-          data: String(error)
+          data: errorData,
+          sessionId
         });
       }
+    } finally {
+      delete global.currentWebContents;
+    }
+  });
+  ipcMain.handle(`${channelPrefix}:toolApprovalResponse`, (_event, params) => {
+    const { id, approved } = params;
+    const pending = pendingApprovals.get(id);
+    if (pending) {
+      pendingApprovals.delete(id);
+      pending.resolve(approved);
     }
   });
   ipcMain.handle(`${channelPrefix}:cancel`, () => {
     agent.abort();
   });
-  ipcMain.handle(`${channelPrefix}:clearAgentHistory`, () => {
-    agent.clearHistory();
+  ipcMain.handle(`${channelPrefix}:settings:get`, async (_event, key) => {
+    return storage.getUserSetting(key, getContext());
   });
-  ipcMain.handle(`${channelPrefix}:agentHistory`, () => {
-    return agent.getHistory();
+  ipcMain.handle(`${channelPrefix}:settings:set`, async (_event, key, value) => {
+    await storage.setUserSetting(key, value, getContext());
+    return { success: true };
+  });
+  ipcMain.handle(`${channelPrefix}:settings:getAll`, async () => {
+    return storage.getUserSettings(getContext());
   });
-  ipcMain.handle(`${channelPrefix}:setWorkingDir`, (_event, dir) => {
-    agent.setWorkingDir(dir);
+  ipcMain.handle(`${channelPrefix}:settings:delete`, async (_event, key) => {
+    await storage.deleteUserSetting(key, getContext());
+    return { success: true };
+  });
+  ipcMain.handle(`${channelPrefix}:setCwd`, (_event, dir) => {
+    agent.setCwd(dir);
   });
   ipcMain.handle(`${channelPrefix}:config`, () => {
     return agent.getConfig();
@@ -75,8 +158,11 @@ async function createElectronBridge(options) {
     const input = {
       id: params.id || crypto.randomUUID(),
       title: params.title || "\u65B0\u5BF9\u8BDD",
-      model: params.model || "doubao-seed-1-6-251015",
-      mode: params.mode || "agent"
+      model: params.model || DEFAULT_MODEL,
+      mode: params.mode || "agent",
+      webSearchEnabled: params.webSearchEnabled ?? true,
+      thinkingEnabled: params.thinkingEnabled ?? true,
+      hidden: params.hidden ?? false
     };
     return storage.createSession(input, getContext());
   });
@@ -93,17 +179,26 @@ async function createElectronBridge(options) {
   });
   ipcMain.handle(`${channelPrefix}:messages:save`, async (_event, params) => {
     const input = {
-      id: crypto.randomUUID(),
+      id: params.id || crypto.randomUUID(),
       sessionId: params.sessionId,
       role: params.role,
       content: params.content,
-      thinking: params.thinking || null,
-      toolCalls: params.toolCalls || null,
-      searchResults: params.searchResults || null,
+      model: params.model || null,
+      mode: params.mode || null,
+      webSearchEnabled: params.webSearchEnabled ?? null,
+      thinkingEnabled: params.thinkingEnabled ?? null,
+      steps: params.steps || null,
       operationIds: params.operationIds || null
     };
     return storage.saveMessage(input, getContext());
   });
+  ipcMain.handle(`${channelPrefix}:messages:update`, async (_event, params) => {
+    await storage.updateMessage(params.id, {
+      content: params.content,
+      steps: params.steps
+    }, getContext());
+    return { success: true };
+  });
   ipcMain.handle(`${channelPrefix}:messages:deleteAfter`, async (_event, sessionId, timestamp) => {
     await storage.deleteMessagesAfter(sessionId, new Date(timestamp), getContext());
     return { success: true };
@@ -117,9 +212,123 @@ async function createElectronBridge(options) {
   ipcMain.handle(`${channelPrefix}:trash:restore`, async (_event, id) => {
     return storage.restoreFromTrash?.(id, getContext());
   });
+  ipcMain.handle(`${channelPrefix}:openExternal`, async (_event, url) => {
+    return shell.openExternal(url);
+  });
+  ipcMain.handle(`${channelPrefix}:fs:listDir`, async (_event, dirPath) => {
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const files = [];
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = path.join(dirPath, entry.name);
+        try {
+          const stats = fs.statSync(fullPath);
+          files.push({
+            name: entry.name,
+            path: fullPath,
+            isDirectory: entry.isDirectory(),
+            size: stats.size,
+            modifiedAt: stats.mtime,
+            extension: entry.isDirectory() ? "" : path.extname(entry.name).toLowerCase()
+          });
+        } catch {
+        }
+      }
+      return files.sort((a, b) => {
+        if (a.isDirectory && !b.isDirectory) return -1;
+        if (!a.isDirectory && b.isDirectory) return 1;
+        return a.name.localeCompare(b.name);
+      });
+    } catch (error) {
+      console.error("[AI-Chat] \u5217\u51FA\u76EE\u5F55\u5931\u8D25:", error);
+      return [];
+    }
+  });
+  ipcMain.handle(`${channelPrefix}:fs:exists`, async (_event, filePath) => {
+    return fs.existsSync(filePath);
+  });
+  ipcMain.handle(`${channelPrefix}:fs:stat`, async (_event, filePath) => {
+    try {
+      const stats = fs.statSync(filePath);
+      return {
+        name: path.basename(filePath),
+        path: filePath,
+        isDirectory: stats.isDirectory(),
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        extension: stats.isDirectory() ? "" : path.extname(filePath).toLowerCase()
+      };
+    } catch {
+      return null;
+    }
+  });
+  ipcMain.handle(`${channelPrefix}:fs:readFile`, async (_event, filePath) => {
+    try {
+      return fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  });
+  ipcMain.handle(`${channelPrefix}:fs:readFileBase64`, async (_event, filePath) => {
+    try {
+      const buffer = fs.readFileSync(filePath);
+      return buffer.toString("base64");
+    } catch {
+      return null;
+    }
+  });
+  ipcMain.handle(`${channelPrefix}:fs:homeDir`, async () => {
+    return process.env.HOME || process.env.USERPROFILE || "/";
+  });
+  ipcMain.handle(`${channelPrefix}:fs:resolvePath`, async (_event, inputPath) => {
+    if (inputPath.startsWith("~")) {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || "/";
+      return path.join(homeDir, inputPath.slice(1));
+    }
+    return path.resolve(inputPath);
+  });
+  ipcMain.handle(`${channelPrefix}:fs:parentDir`, async (_event, dirPath) => {
+    return path.dirname(dirPath);
+  });
+  const activeWatchers = /* @__PURE__ */ new Map();
+  ipcMain.handle(`${channelPrefix}:fs:watchDir`, async (event, dirPath) => {
+    const webContents = event.sender;
+    if (activeWatchers.has(dirPath)) {
+      activeWatchers.get(dirPath)?.close();
+      activeWatchers.delete(dirPath);
+    }
+    try {
+      const watcher = fs.watch(dirPath, { persistent: false }, (eventType, filename) => {
+        if (!webContents.isDestroyed()) {
+          webContents.send(`${channelPrefix}:fs:dirChange`, {
+            dirPath,
+            eventType,
+            filename
+          });
+        }
+      });
+      watcher.on("error", (error) => {
+        console.error("[AI-Chat] Watch error:", error);
+        activeWatchers.delete(dirPath);
+      });
+      activeWatchers.set(dirPath, watcher);
+      return true;
+    } catch (error) {
+      console.error("[AI-Chat] Failed to watch directory:", error);
+      return false;
+    }
+  });
+  ipcMain.handle(`${channelPrefix}:fs:unwatchDir`, async (_event, dirPath) => {
+    const watcher = activeWatchers.get(dirPath);
+    if (watcher) {
+      watcher.close();
+      activeWatchers.delete(dirPath);
+    }
+  });
   return { agent, storage };
 }
 export {
-  AVAILABLE_MODELS,
+  MODELS,
   createElectronBridge
 };

package/dist/preload/index.cjs

@@ -31,9 +31,8 @@ function exposeElectronBridge(options = {}) {
     getModels: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:models`),
     send: (params) => import_electron.ipcRenderer.invoke(`${channelPrefix}:send`, params),
     cancel: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:cancel`),
-    clearAgentHistory: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:clearAgentHistory`),
-    getAgentHistory: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:agentHistory`),
-    setWorkingDir: (dir) => import_electron.ipcRenderer.invoke(`${channelPrefix}:setWorkingDir`, dir),
+    // 无状态架构：历史通过 ChatOptions.history 传入
+    setCwd: (dir) => import_electron.ipcRenderer.invoke(`${channelPrefix}:setCwd`, dir),
     getConfig: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:config`),
     onProgress: (callback) => {
       const handler = (_event, progress) => {
@@ -44,6 +43,16 @@ function exposeElectronBridge(options = {}) {
         import_electron.ipcRenderer.removeListener(`${channelPrefix}:progress`, handler);
       };
     },
+    onToolApprovalRequest: (callback) => {
+      const handler = (_event, request) => {
+        callback(request);
+      };
+      import_electron.ipcRenderer.on(`${channelPrefix}:toolApprovalRequest`, handler);
+      return () => {
+        import_electron.ipcRenderer.removeListener(`${channelPrefix}:toolApprovalRequest`, handler);
+      };
+    },
+    respondToolApproval: (id, approved) => import_electron.ipcRenderer.invoke(`${channelPrefix}:toolApprovalResponse`, { id, approved }),
     // ============ Sessions API ============
     getSessions: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:sessions:list`),
     getSession: (id) => import_electron.ipcRenderer.invoke(`${channelPrefix}:sessions:get`, id),
@@ -53,12 +62,57 @@ function exposeElectronBridge(options = {}) {
     // ============ Messages API ============
     getMessages: (sessionId) => import_electron.ipcRenderer.invoke(`${channelPrefix}:messages:list`, sessionId),
     saveMessage: (params) => import_electron.ipcRenderer.invoke(`${channelPrefix}:messages:save`, params),
+    updateMessage: (params) => import_electron.ipcRenderer.invoke(`${channelPrefix}:messages:update`, params),
     deleteMessagesAfter: (sessionId, timestamp) => import_electron.ipcRenderer.invoke(`${channelPrefix}:messages:deleteAfter`, sessionId, timestamp),
     // ============ Operations API ============
     getOperations: (sessionId) => import_electron.ipcRenderer.invoke(`${channelPrefix}:operations:list`, sessionId),
     // ============ Trash API ============
     getTrashItems: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:trash:list`),
-    restoreFromTrash: (id) => import_electron.ipcRenderer.invoke(`${channelPrefix}:trash:restore`, id)
+    restoreFromTrash: (id) => import_electron.ipcRenderer.invoke(`${channelPrefix}:trash:restore`, id),
+    // ============ System API ============
+    openExternal: (url) => import_electron.ipcRenderer.invoke(`${channelPrefix}:openExternal`, url),
+    // ============ File System API ============
+    listDir: (dirPath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:listDir`, dirPath),
+    exists: (filePath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:exists`, filePath),
+    stat: (filePath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:stat`, filePath),
+    readFile: (filePath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:readFile`, filePath),
+    readFileBase64: (filePath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:readFileBase64`, filePath),
+    homeDir: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:homeDir`),
+    resolvePath: (inputPath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:resolvePath`, inputPath),
+    parentDir: (dirPath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:parentDir`, dirPath),
+    watchDir: (dirPath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:watchDir`, dirPath),
+    unwatchDir: (dirPath) => import_electron.ipcRenderer.invoke(`${channelPrefix}:fs:unwatchDir`, dirPath),
+    onDirChange: (callback) => {
+      const handler = (_event, data) => {
+        callback(data);
+      };
+      import_electron.ipcRenderer.on(`${channelPrefix}:fs:dirChange`, handler);
+      return () => {
+        import_electron.ipcRenderer.removeListener(`${channelPrefix}:fs:dirChange`, handler);
+      };
+    },
+    // ============ Settings API ============
+    getSetting: (key) => import_electron.ipcRenderer.invoke(`${channelPrefix}:settings:get`, key),
+    setSetting: (key, value) => import_electron.ipcRenderer.invoke(`${channelPrefix}:settings:set`, key, value),
+    getAllSettings: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:settings:getAll`),
+    deleteSetting: (key) => import_electron.ipcRenderer.invoke(`${channelPrefix}:settings:delete`, key),
+    // ============ Index API ============
+    getIndexStats: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:getStats`),
+    getIndexStatus: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:status`),
+    syncIndex: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:sync`),
+    cancelIndex: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:cancel`),
+    deleteIndex: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:delete`),
+    registerIndexListener: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:registerListener`),
+    unregisterIndexListener: () => import_electron.ipcRenderer.invoke(`${channelPrefix}:index:unregisterListener`),
+    onIndexProgress: (callback) => {
+      const handler = (_event, progress) => {
+        callback(progress);
+      };
+      import_electron.ipcRenderer.on(`${channelPrefix}:index:progress`, handler);
+      return () => {
+        import_electron.ipcRenderer.removeListener(`${channelPrefix}:index:progress`, handler);
+      };
+    }
   };
   import_electron.contextBridge.exposeInMainWorld(exposeName, bridge);
 }

package/dist/preload/index.d.cts

@@ -18,13 +18,15 @@ interface SendMessageParams {
     };
 }
 /** 模型配置 */
-interface ModelConfig {
-    provider: string;
-    model: string;
+interface ModelOption {
+    modelId: string;
     displayName: string;
-    supportsTools: boolean;
-    supportsWebSearch: boolean;
-    supportedThinkingModes: string[];
+    /** 分组名称（由后端决定，前端只负责渲染，必填） */
+    group: string;
+    /** 是否来自 OpenRouter（保留用于兼容，后续可能移除） */
+    isOpenRouter?: boolean;
+    /** 提供商名称（保留用于兼容，后续可能移除） */
+    provider?: string;
 }
 /** 会话记录 */
 interface SessionRecord {
@@ -34,6 +36,10 @@ interface SessionRecord {
     title: string;
     model: string;
     mode: 'agent' | 'plan' | 'ask';
+    webSearchEnabled: boolean;
+    thinkingEnabled: boolean;
+    /** 是否在 tab 栏隐藏（关闭但不删除） */
+    hidden: boolean;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -43,9 +49,16 @@ interface MessageRecord {
     sessionId: string;
     role: 'user' | 'assistant';
     content: string;
-    thinking?: string | null;
-    toolCalls?: string | null;
-    searchResults?: string | null;
+    /** 生成此消息时使用的模型 */
+    model?: string | null;
+    /** 生成此消息时使用的模式 (ask/agent) */
+    mode?: string | null;
+    /** 生成此消息时是否启用 web 搜索 */
+    webSearchEnabled?: boolean | null;
+    /** 生成此消息时是否启用深度思考 */
+    thinkingEnabled?: boolean | null;
+    /** 执行步骤列表 JSON */
+    steps?: string | null;
     operationIds?: string | null;
     timestamp: Date;
 }
@@ -69,19 +82,24 @@ interface TrashRecord {
     deletedAt: Date;
     autoDeleteAt: Date;
 }
+/** 文件信息 */
+interface FileInfo {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    size: number;
+    modifiedAt: Date;
+    extension: string;
+}
 interface AiChatBridge {
     /** 获取可用模型 */
-    getModels(): Promise<ModelConfig[]>;
+    getModels(): Promise<ModelOption[]>;
     /** 发送消息 */
     send(params: SendMessageParams): Promise<void>;
     /** 取消当前请求 */
     cancel(): Promise<void>;
-    /** 清空 Agent 内存历史 */
-    clearAgentHistory(): Promise<void>;
-    /** 获取 Agent 内存历史 */
-    getAgentHistory(): Promise<unknown[]>;
-    /** 设置工作目录 */
-    setWorkingDir(dir: string): Promise<void>;
+    /** 设置当前工作目录 */
+    setCwd(dir: string): Promise<void>;
     /** 获取配置 */
     getConfig(): Promise<unknown>;
     /** 监听进度事件 */
@@ -95,12 +113,18 @@ interface AiChatBridge {
         title?: string;
         model?: string;
         mode?: string;
+        webSearchEnabled?: boolean;
+        thinkingEnabled?: boolean;
+        hidden?: boolean;
     }): Promise<SessionRecord>;
     /** 更新会话 */
     updateSession(id: string, data: {
         title?: string;
         model?: string;
         mode?: string;
+        webSearchEnabled?: boolean;
+        thinkingEnabled?: boolean;
+        hidden?: boolean;
     }): Promise<SessionRecord | null>;
     /** 删除会话 */
     deleteSession(id: string): Promise<{
@@ -110,14 +134,31 @@ interface AiChatBridge {
     getMessages(sessionId: string): Promise<MessageRecord[]>;
     /** 保存消息 */
     saveMessage(params: {
+        /** 消息 ID（可选，如果不传则自动生成） */
+        id?: string;
         sessionId: string;
         role: 'user' | 'assistant';
         content: string;
-        thinking?: string;
-        toolCalls?: string;
-        searchResults?: string;
+        /** 生成此消息时使用的模型 */
+        model?: string;
+        /** 生成此消息时使用的模式 (ask/agent) */
+        mode?: string;
+        /** 生成此消息时是否启用 web 搜索 */
+        webSearchEnabled?: boolean;
+        /** 生成此消息时是否启用深度思考 */
+        thinkingEnabled?: boolean;
+        /** 执行步骤列表 JSON */
+        steps?: string;
         operationIds?: string;
     }): Promise<MessageRecord>;
+    /** 更新消息（增量保存） */
+    updateMessage(params: {
+        id: string;
+        content?: string;
+        steps?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
     /** 删除指定时间之后的消息（用于分叉） */
     deleteMessagesAfter(sessionId: string, timestamp: number): Promise<{
         success: boolean;
@@ -128,6 +169,98 @@ interface AiChatBridge {
     getTrashItems(): Promise<TrashRecord[]>;
     /** 恢复回收站项目 */
     restoreFromTrash(id: string): Promise<TrashRecord | undefined>;
+    /** 在系统默认浏览器中打开链接 */
+    openExternal(url: string): Promise<void>;
+    /** 列出目录内容 */
+    listDir(dirPath: string): Promise<FileInfo[]>;
+    /** 检查路径是否存在 */
+    exists(filePath: string): Promise<boolean>;
+    /** 获取文件信息 */
+    stat(filePath: string): Promise<FileInfo | null>;
+    /** 读取文件内容（文本） */
+    readFile(filePath: string): Promise<string | null>;
+    /** 读取文件为 base64 */
+    readFileBase64(filePath: string): Promise<string | null>;
+    /** 获取用户主目录 */
+    homeDir(): Promise<string>;
+    /** 解析路径（处理 ~） */
+    resolvePath(inputPath: string): Promise<string>;
+    /** 获取父目录 */
+    parentDir(dirPath: string): Promise<string>;
+    /** 监听目录变化 */
+    watchDir(dirPath: string): Promise<boolean>;
+    /** 停止监听目录 */
+    unwatchDir(dirPath: string): Promise<void>;
+    /** 监听目录变化事件 */
+    onDirChange(callback: (data: {
+        dirPath: string;
+        eventType: string;
+        filename: string | null;
+    }) => void): () => void;
+    /** 获取用户设置 */
+    getSetting(key: string): Promise<string | null>;
+    /** 设置用户设置 */
+    setSetting(key: string, value: string): Promise<{
+        success: boolean;
+    }>;
+    /** 获取所有用户设置 */
+    getAllSettings(): Promise<Record<string, string>>;
+    /** 删除用户设置 */
+    deleteSetting(key: string): Promise<{
+        success: boolean;
+    }>;
+    /** 获取索引统计信息 */
+    getIndexStats(): Promise<{
+        totalDocuments: number;
+        indexSize: number;
+        lastUpdated: string | null;
+    }>;
+    /** 检查索引状态 */
+    getIndexStatus(): Promise<{
+        isIndexing: boolean;
+        lastProgress: {
+            indexed: number;
+            total: number;
+            currentFile?: string;
+            stage: string;
+        } | null;
+    }>;
+    /** 同步索引（重新索引工作空间） */
+    syncIndex(): Promise<{
+        success: boolean;
+    }>;
+    /** 取消索引 */
+    cancelIndex(): Promise<{
+        success: boolean;
+    }>;
+    /** 删除索引 */
+    deleteIndex(): Promise<{
+        success: boolean;
+    }>;
+    /** 注册索引进度监听器 */
+    registerIndexListener(): Promise<{
+        success: boolean;
+    }>;
+    /** 注销索引进度监听器 */
+    unregisterIndexListener(): Promise<{
+        success: boolean;
+    }>;
+    /** 监听索引进度 */
+    onIndexProgress(callback: (progress: {
+        indexed: number;
+        total: number;
+        currentFile?: string;
+        stage: string;
+        error?: string;
+    }) => void): () => void;
+    /** 监听工具批准请求（manual 模式） */
+    onToolApprovalRequest(callback: (request: {
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    }) => void): () => void;
+    /** 响应工具批准请求 */
+    respondToolApproval(id: string, approved: boolean): Promise<void>;
 }
 interface ExposeOptions {
     /** IPC channel 前缀 */