@lobehub/lobehub 2.0.0-next.72 → 2.0.0-next.74

package/src/store/chat/slices/builtinTool/actions/__tests__/localSystem.test.ts

@@ -50,18 +50,17 @@ describe('localFileSlice', () => {
 
   describe('internal_triggerLocalFileToolCalling', () => {
     it('should handle successful calling', async () => {
-      const mockContent = { foo: 'bar' };
+      const mockContent = 'result content';
       const mockState = { state: 'test' };
-      const mockService = vi.fn().mockResolvedValue({ content: mockContent, state: mockState });
+      const mockService = vi
+        .fn()
+        .mockResolvedValue({ content: mockContent, state: mockState, success: true });
 
       await store.internal_triggerLocalFileToolCalling('test-id', mockService);
 
       expect(mockStore.toggleLocalFileLoading).toBeCalledWith('test-id', true);
       expect(mockStore.optimisticUpdatePluginState).toBeCalledWith('test-id', mockState);
-      expect(mockStore.optimisticUpdateMessageContent).toBeCalledWith(
-        'test-id',
-        JSON.stringify(mockContent),
-      );
+      expect(mockStore.optimisticUpdateMessageContent).toBeCalledWith('test-id', mockContent);
       expect(mockStore.toggleLocalFileLoading).toBeCalledWith('test-id', false);
     });
 

package/src/store/chat/slices/builtinTool/actions/__tests__/search.test.ts

@@ -6,7 +6,7 @@ import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { searchService } from '@/services/search';
 import { useChatStore } from '@/store/chat';
-import { chatSelectors } from '@/store/chat/selectors';
+import { dbMessageSelectors } from '@/store/chat/selectors';
 import { CRAWL_CONTENT_LIMITED_COUNT } from '@/tools/web-browsing/const';
 
 // Mock services
@@ -18,8 +18,8 @@ vi.mock('@/services/search', () => ({
 }));
 
 vi.mock('@/store/chat/selectors', () => ({
-  chatSelectors: {
-    getMessageById: vi.fn(),
+  dbMessageSelectors: {
+    getDbMessageById: vi.fn(),
   },
 }));
 
@@ -38,6 +38,9 @@ describe('search actions', () => {
       optimisticAddToolToAssistantMessage: vi.fn(),
       openToolUI: vi.fn(),
     });
+
+    // Default mock for dbMessageSelectors - returns undefined to use activeId/activeTopicId
+    vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(() => () => undefined);
   });
 
   describe('search', () => {
@@ -90,6 +93,8 @@ describe('search actions', () => {
       expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         searchResultsPrompt(expectedContent),
+        undefined,
+        { sessionId: undefined, topicId: undefined },
       );
     });
 
@@ -126,6 +131,8 @@ describe('search actions', () => {
       expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         searchResultsPrompt([]),
+        undefined,
+        { sessionId: undefined, topicId: undefined },
       );
     });
 
@@ -145,15 +152,21 @@ describe('search actions', () => {
         await search(messageId, query);
       });
 
-      expect(result.current.optimisticUpdateMessagePluginError).toHaveBeenCalledWith(messageId, {
-        body: error,
-        message: 'Search failed',
-        type: 'PluginServerError',
-      });
+      expect(result.current.optimisticUpdateMessagePluginError).toHaveBeenCalledWith(
+        messageId,
+        {
+          body: error,
+          message: 'Search failed',
+          type: 'PluginServerError',
+        },
+        { sessionId: undefined, topicId: undefined },
+      );
       expect(result.current.searchLoading[messageId]).toBe(false);
       expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         'Search failed',
+        undefined,
+        { sessionId: undefined, topicId: undefined },
       );
     });
   });
@@ -193,6 +206,8 @@ describe('search actions', () => {
       expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         crawlResultsPrompt(expectedContent as any),
+        undefined,
+        { sessionId: undefined, topicId: undefined },
       );
     });
 
@@ -219,6 +234,8 @@ describe('search actions', () => {
       expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         crawlResultsPrompt(mockResponse.results),
+        undefined,
+        { sessionId: undefined, topicId: undefined },
       );
     });
   });
@@ -250,6 +267,8 @@ describe('search actions', () => {
       const mockMessage: Partial<UIChatMessage> = {
         id: messageId,
         parentId,
+        sessionId: undefined,
+        topicId: undefined,
         content: 'test content',
         plugin: {
           identifier: 'search',
@@ -264,7 +283,7 @@ describe('search actions', () => {
         meta: {},
       };
 
-      vi.spyOn(chatSelectors, 'getMessageById').mockImplementation(
+      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(
         () => () => mockMessage as UIChatMessage,
       );
 
@@ -282,7 +301,10 @@ describe('search actions', () => {
           plugin: mockMessage.plugin,
           pluginState: mockMessage.pluginState,
           role: 'tool',
+          sessionId: 'session-id',
+          topicId: 'topic-id',
         }),
+        { sessionId: 'session-id', topicId: 'topic-id' },
       );
 
       expect(result.current.optimisticAddToolToAssistantMessage).toHaveBeenCalledWith(
@@ -291,11 +313,12 @@ describe('search actions', () => {
           identifier: 'search',
           type: 'default',
         }),
+        { sessionId: undefined, topicId: undefined },
       );
     });
 
     it('should not save if message not found', async () => {
-      vi.spyOn(chatSelectors, 'getMessageById').mockImplementation(() => () => undefined);
+      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(() => () => undefined);
 
       const { result } = renderHook(() => useChatStore());
       const { saveSearchResult } = result.current;
@@ -327,4 +350,175 @@ describe('search actions', () => {
       expect(result.current.searchLoading[messageId]).toBe(false);
     });
   });
+
+  describe('OptimisticUpdateContext isolation', () => {
+    it('search should pass context to optimistic methods', async () => {
+      const mockResponse: UniformSearchResponse = {
+        results: [
+          {
+            title: 'Test',
+            content: 'Content',
+            url: 'https://test.com',
+            category: 'general',
+            engines: ['google'],
+            parsedUrl: 'test.com',
+            score: 1,
+          },
+        ],
+        costTime: 1,
+        resultNumbers: 1,
+        query: 'test',
+      };
+
+      (searchService.webSearch as Mock).mockResolvedValue(mockResponse);
+
+      const messageId = 'test-message-id';
+      const contextSessionId = 'context-session-id';
+      const contextTopicId = 'context-topic-id';
+
+      const mockMessage: Partial<UIChatMessage> = {
+        id: messageId,
+        sessionId: contextSessionId,
+        topicId: contextTopicId,
+        role: 'tool',
+        content: '',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        meta: {},
+      };
+
+      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(
+        () => () => mockMessage as UIChatMessage,
+      );
+
+      const { result } = renderHook(() => useChatStore());
+      const query: SearchQuery = { query: 'test' };
+
+      await act(async () => {
+        await result.current.search(messageId, query);
+      });
+
+      expect(result.current.optimisticUpdatePluginState).toHaveBeenCalledWith(
+        messageId,
+        expect.any(Object),
+        { sessionId: contextSessionId, topicId: contextTopicId },
+      );
+      expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
+        messageId,
+        expect.any(String),
+        undefined,
+        { sessionId: contextSessionId, topicId: contextTopicId },
+      );
+    });
+
+    it('crawlMultiPages should pass context to optimistic methods', async () => {
+      const mockResponse = {
+        results: [
+          {
+            data: {
+              content: 'Test content',
+              title: 'Test',
+            },
+            crawler: 'naive',
+            originalUrl: 'https://test.com',
+          },
+        ],
+      };
+
+      (searchService.crawlPages as Mock).mockResolvedValue(mockResponse);
+
+      const messageId = 'test-message-id';
+      const contextSessionId = 'context-session-id';
+      const contextTopicId = 'context-topic-id';
+
+      const mockMessage: Partial<UIChatMessage> = {
+        id: messageId,
+        sessionId: contextSessionId,
+        topicId: contextTopicId,
+        role: 'tool',
+        content: '',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        meta: {},
+      };
+
+      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(
+        () => () => mockMessage as UIChatMessage,
+      );
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.crawlMultiPages(messageId, { urls: ['https://test.com'] });
+      });
+
+      expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
+        messageId,
+        expect.any(String),
+        undefined,
+        { sessionId: contextSessionId, topicId: contextTopicId },
+      );
+      expect(result.current.optimisticUpdatePluginState).toHaveBeenCalledWith(
+        messageId,
+        expect.any(Object),
+        { sessionId: contextSessionId, topicId: contextTopicId },
+      );
+    });
+
+    it('saveSearchResult should pass context to optimistic methods', async () => {
+      const messageId = 'test-message-id';
+      const parentId = 'parent-message-id';
+      const contextSessionId = 'context-session-id';
+      const contextTopicId = 'context-topic-id';
+
+      const mockMessage: Partial<UIChatMessage> = {
+        id: messageId,
+        parentId,
+        sessionId: contextSessionId,
+        topicId: contextTopicId,
+        content: 'test content',
+        plugin: {
+          identifier: 'search',
+          arguments: '{}',
+          apiName: 'search',
+          type: 'default',
+        },
+        pluginState: {},
+        role: 'tool',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        meta: {},
+      };
+
+      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(
+        () => () => mockMessage as UIChatMessage,
+      );
+
+      (useChatStore.getState().optimisticCreateMessage as Mock).mockResolvedValue({
+        id: 'new-message-id',
+      });
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.saveSearchResult(messageId);
+      });
+
+      expect(result.current.optimisticAddToolToAssistantMessage).toHaveBeenCalledWith(
+        parentId,
+        expect.objectContaining({
+          identifier: 'search',
+          type: 'default',
+        }),
+        { sessionId: contextSessionId, topicId: contextTopicId },
+      );
+      expect(result.current.optimisticCreateMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionId: contextSessionId,
+          topicId: contextTopicId,
+        }),
+        { sessionId: contextSessionId, topicId: contextTopicId },
+      );
+    });
+  });
 });

package/src/store/chat/slices/builtinTool/actions/localSystem.ts

@@ -5,7 +5,6 @@ import {
   GrepContentParams,
   KillCommandParams,
   ListLocalFileParams,
-  LocalMoveFilesResultItem,
   LocalReadFileParams,
   LocalReadFilesParams,
   LocalSearchFilesParams,
@@ -16,28 +15,14 @@ import {
 } from '@lobechat/electron-client-ipc';
 import { StateCreator } from 'zustand/vanilla';
 
-import { localFileService } from '@/services/electron/localFileService';
 import { ChatStore } from '@/store/chat/store';
-import {
-  EditLocalFileState,
-  GetCommandOutputState,
-  GlobFilesState,
-  GrepContentState,
-  KillCommandState,
-  LocalFileListState,
-  LocalFileSearchState,
-  LocalMoveFilesState,
-  LocalReadFileState,
-  LocalReadFilesState,
-  LocalRenameFileState,
-  RunCommandState,
-} from '@/tools/local-system/type';
+import { LocalSystemExecutionRuntime } from '@/tools/local-system/ExecutionRuntime';
 
 /* eslint-disable typescript-sort-keys/interface */
 export interface LocalFileAction {
-  internal_triggerLocalFileToolCalling: <T = any>(
+  internal_triggerLocalFileToolCalling: (
     id: string,
-    callingService: () => Promise<{ content: any; state?: T }>,
+    callingService: () => Promise<{ content: string; error?: any; state?: any; success: boolean }>,
   ) => Promise<boolean>;
 
   // File Operations
@@ -63,6 +48,8 @@ export interface LocalFileAction {
 }
 /* eslint-enable typescript-sort-keys/interface */
 
+const runtime = new LocalSystemExecutionRuntime();
+
 /* eslint-disable sort-keys-fix/sort-keys-fix */
 export const localSystemSlice: StateCreator<
   ChatStore,
@@ -72,148 +59,49 @@ export const localSystemSlice: StateCreator<
 > = (set, get) => ({
   // ==================== File Editing ====================
   editLocalFile: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<EditLocalFileState>(id, async () => {
-      const result = await localFileService.editLocalFile(params);
-
-      const message = result.success
-        ? `Successfully replaced ${result.replacements} occurrence(s) in ${params.file_path}`
-        : `Edit failed: ${result.error}`;
-
-      const state: EditLocalFileState = { message, result };
-
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.editLocalFile(params);
     });
   },
 
   writeLocalFile: async (id, params) => {
     return get().internal_triggerLocalFileToolCalling(id, async () => {
-      const result = await localFileService.writeFile(params);
-
-      let content: { message: string; success: boolean };
-
-      if (result.success) {
-        content = {
-          message: `成功写入文件 ${params.path}`,
-          success: true,
-        };
-      } else {
-        const errorMessage = result.error;
-
-        content = { message: errorMessage || '写入文件失败', success: false };
-      }
-      return { content };
+      return await runtime.writeLocalFile(params);
     });
   },
   moveLocalFiles: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<LocalMoveFilesState>(id, async () => {
-      const results: LocalMoveFilesResultItem[] = await localFileService.moveLocalFiles(params);
-
-      // 检查所有文件是否成功移动以更新消息内容
-      const allSucceeded = results.every((r) => r.success);
-      const someFailed = results.some((r) => !r.success);
-      const successCount = results.filter((r) => r.success).length;
-      const failedCount = results.length - successCount;
-
-      let message = '';
-
-      if (allSucceeded) {
-        message = `Successfully moved ${results.length} item(s).`;
-      } else if (someFailed) {
-        message = `Moved ${successCount} item(s) successfully. Failed to move ${failedCount} item(s).`;
-      } else {
-        // 所有都失败了？
-        message = `Failed to move all ${results.length} item(s).`;
-      }
-
-      const state: LocalMoveFilesState = { results, successCount, totalCount: results.length };
-
-      return { content: { message, results }, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.moveLocalFiles(params);
     });
   },
   renameLocalFile: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<LocalRenameFileState>(id, async () => {
-      const { path: currentPath, newName } = params;
-
-      // Basic validation for newName (can be done here or backend, maybe better in backend)
-      if (
-        !newName ||
-        newName.includes('/') ||
-        newName.includes('\\') ||
-        newName === '.' ||
-        newName === '..' ||
-        /["*/:<>?\\|]/.test(newName)
-      ) {
-        throw new Error(
-          'Invalid new name provided. It cannot be empty, contain path separators, or invalid characters.',
-        );
-      }
-
-      const result = await localFileService.renameLocalFile({ newName, path: currentPath }); // Call the specific service
-
-      let state: LocalRenameFileState;
-      let content: { message: string; success: boolean };
-
-      if (result.success) {
-        state = { newPath: result.newPath!, oldPath: currentPath, success: true };
-        // Simplified message
-        content = {
-          message: `Successfully renamed file ${currentPath} to ${newName}.`,
-          success: true,
-        };
-      } else {
-        const errorMessage = result.error;
-        state = {
-          error: errorMessage,
-          newPath: '',
-          oldPath: params.path,
-          success: false,
-        };
-        content = { message: errorMessage, success: false };
-      }
-      return { content, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.renameLocalFile(params);
     });
   },
 
   // ==================== Search & Find ====================
   grepContent: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<GrepContentState>(id, async () => {
-      const result = await localFileService.grepContent(params);
-
-      const message = result.success
-        ? `Found ${result.total_matches} matches in ${result.matches.length} locations`
-        : 'Search failed';
-
-      const state: GrepContentState = { message, result };
-
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.grepContent(params);
     });
   },
 
   globLocalFiles: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<GlobFilesState>(id, async () => {
-      const result = await localFileService.globFiles(params);
-
-      const message = result.success ? `Found ${result.total_files} files` : 'Glob search failed';
-
-      const state: GlobFilesState = { message, result };
-
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.globLocalFiles(params);
     });
   },
 
   searchLocalFiles: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<LocalFileSearchState>(id, async () => {
-      const result = await localFileService.searchLocalFiles(params);
-      const state: LocalFileSearchState = { searchResults: result };
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.searchLocalFiles(params);
     });
   },
 
   listLocalFiles: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<LocalFileListState>(id, async () => {
-      const result = await localFileService.listLocalFiles(params);
-      const state: LocalFileListState = { listResults: result };
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.listLocalFiles(params);
     });
   },
 
@@ -226,67 +114,31 @@ export const localSystemSlice: StateCreator<
   },
 
   readLocalFile: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<LocalReadFileState>(id, async () => {
-      const result = await localFileService.readLocalFile(params);
-      const state: LocalReadFileState = { fileContent: result };
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.readLocalFile(params);
     });
   },
 
   readLocalFiles: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<LocalReadFilesState>(id, async () => {
-      const results = await localFileService.readLocalFiles(params);
-      const state: LocalReadFilesState = { filesContent: results };
-      return { content: results, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.readLocalFiles(params);
     });
   },
 
   // ==================== Shell Commands ====================
   runCommand: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<RunCommandState>(id, async () => {
-      const result = await localFileService.runCommand(params);
-
-      let message: string;
-
-      if (result.success) {
-        if (result.shell_id) {
-          message = `Command started in background with shell_id: ${result.shell_id}`;
-        } else {
-          message = `Command completed successfully.`;
-        }
-      } else {
-        message = `Command failed: ${result.error}`;
-      }
-
-      const state: RunCommandState = { message, result };
-
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.runCommand(params);
     });
   },
   killCommand: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<KillCommandState>(id, async () => {
-      const result = await localFileService.killCommand(params);
-
-      const message = result.success
-        ? `Successfully killed shell: ${params.shell_id}`
-        : `Failed to kill shell: ${result.error}`;
-
-      const state: KillCommandState = { message, result };
-
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.killCommand(params);
     });
   },
   getCommandOutput: async (id, params) => {
-    return get().internal_triggerLocalFileToolCalling<GetCommandOutputState>(id, async () => {
-      const result = await localFileService.getCommandOutput(params);
-
-      const message = result.success
-        ? `Output retrieved. Running: ${result.running}`
-        : `Failed: ${result.error}`;
-
-      const state: GetCommandOutputState = { message, result };
-
-      return { content: result, state };
+    return get().internal_triggerLocalFileToolCalling(id, async () => {
+      return await runtime.getCommandOutput(params);
     });
   },
 
@@ -305,11 +157,22 @@ export const localSystemSlice: StateCreator<
   internal_triggerLocalFileToolCalling: async (id, callingService) => {
     get().toggleLocalFileLoading(id, true);
     try {
-      const { state, content } = await callingService();
-      if (state) {
-        await get().optimisticUpdatePluginState(id, state as any);
+      const { state, content, success, error } = await callingService();
+
+      if (success) {
+        if (state) {
+          await get().optimisticUpdatePluginState(id, state);
+        }
+        await get().optimisticUpdateMessageContent(id, content);
+      } else {
+        await get().optimisticUpdateMessagePluginError(id, {
+          body: error,
+          message: error?.message || 'Operation failed',
+          type: 'PluginServerError',
+        });
+        // Still update content even if failed, to show error message
+        await get().optimisticUpdateMessageContent(id, content);
       }
-      await get().optimisticUpdateMessageContent(id, JSON.stringify(content));
     } catch (error) {
       await get().optimisticUpdateMessagePluginError(id, {
         body: error,