@lobehub/lobehub 2.0.0-next.2 → 2.0.0-next.20

package/src/store/chat/slices/plugin/action.test.ts

@@ -171,7 +171,11 @@ describe('ChatPluginAction', () => {
       });
 
       // 验证 messageService.internal_updateMessageContent 是否被正确调用
-      expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { content: newContent });
+      expect(messageService.updateMessage).toHaveBeenCalledWith(
+        messageId,
+        { content: newContent },
+        { sessionId: 'inbox', topicId: null },
+      );
 
       // 验证 refreshMessages 是否被调用
       expect(result.current.refreshMessages).toHaveBeenCalled();
@@ -207,7 +211,11 @@ describe('ChatPluginAction', () => {
       });
 
       // 验证 messageService.internal_updateMessageContent 是否被正确调用
-      expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { content: newContent });
+      expect(messageService.updateMessage).toHaveBeenCalledWith(
+        messageId,
+        { content: newContent },
+        { sessionId: 'inbox', topicId: null },
+      );
 
       // 验证 refreshMessages 是否被调用
       expect(result.current.refreshMessages).toHaveBeenCalled();
@@ -246,9 +254,11 @@ describe('ChatPluginAction', () => {
         expect.any(String),
       );
       expect(runSpy).toHaveBeenCalledWith(pluginPayload, { signal: undefined, trace: {} });
-      expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, {
-        content: pluginApiResponse,
-      });
+      expect(messageService.updateMessage).toHaveBeenCalledWith(
+        messageId,
+        { content: pluginApiResponse },
+        { sessionId: 'inbox', topicId: null },
+      );
       expect(storeState.refreshMessages).toHaveBeenCalled();
       expect(storeState.internal_togglePluginApiCalling).toHaveBeenCalledWith(
         false,
@@ -602,24 +612,18 @@ describe('ChatPluginAction', () => {
   });
 
   describe('invokeBuiltinTool', () => {
-    it('should invoke a builtin tool and update message content ,then run text2image', async () => {
+    it('should invoke the builtin tool action with parsed arguments', async () => {
       const payload = {
-        apiName: 'text2image',
-        arguments: JSON.stringify({ key: 'value' }),
+        apiName: 'mockBuiltinAction',
+        arguments: JSON.stringify({ input: 'test', value: 123 }),
       } as ChatToolPayload;
 
       const messageId = 'message-id';
-      const toolResponse = JSON.stringify({ abc: 'data' });
-
-      useToolStore.setState({
-        transformApiArgumentsToAiState: vi.fn().mockResolvedValue(toolResponse),
-      });
+      const mockActionFn = vi.fn().mockResolvedValue(undefined);
 
       useChatStore.setState({
-        internal_togglePluginApiCalling: vi.fn(),
-        internal_updateMessageContent: vi.fn(),
-        text2image: vi.fn(),
-      });
+        mockBuiltinAction: mockActionFn,
+      } as any);
 
       const { result } = renderHook(() => useChatStore());
 
@@ -627,114 +631,39 @@ describe('ChatPluginAction', () => {
         await result.current.invokeBuiltinTool(messageId, payload);
       });
 
-      // Verify that the builtin tool was invoked with the correct arguments
-      expect(useToolStore.getState().transformApiArgumentsToAiState).toHaveBeenCalledWith(
-        payload.apiName,
-        JSON.parse(payload.arguments),
-      );
-
-      // Verify that the message content was updated with the tool response
-      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
-        messageId,
-        toolResponse,
-      );
-
-      // Verify that loading was toggled correctly
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenCalledTimes(2);
-
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenNthCalledWith(
-        1,
-        true,
-        messageId,
-        expect.any(String),
-      );
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenNthCalledWith(
-        2,
-        false,
-        messageId,
-        expect.any(String),
-      );
-      expect(useChatStore.getState().text2image).toHaveBeenCalled();
+      // Verify that the builtin action was called with correct arguments
+      expect(mockActionFn).toHaveBeenCalledWith(messageId, { input: 'test', value: 123 });
     });
 
-    it('should invoke a builtin tool and update message content', async () => {
+    it('should not invoke action if apiName does not exist in store', async () => {
       const payload = {
-        apiName: 'text2image',
+        apiName: 'nonExistentAction',
         arguments: JSON.stringify({ key: 'value' }),
       } as ChatToolPayload;
 
       const messageId = 'message-id';
-      const toolResponse = 'Builtin tool response';
-
-      act(() => {
-        useToolStore.setState({
-          transformApiArgumentsToAiState: vi.fn().mockResolvedValue(toolResponse),
-          text2image: vi.fn(),
-        });
 
-        useChatStore.setState({
-          internal_togglePluginApiCalling: vi.fn(),
-          text2image: vi.fn(),
-          internal_updateMessageContent: vi.fn(),
-        });
-      });
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
         await result.current.invokeBuiltinTool(messageId, payload);
       });
 
-      // Verify that the builtin tool was invoked with the correct arguments
-      expect(useToolStore.getState().transformApiArgumentsToAiState).toHaveBeenCalledWith(
-        payload.apiName,
-        JSON.parse(payload.arguments),
-      );
-
-      // Verify that the message content was updated with the tool response
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenCalledTimes(2);
-      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
-        messageId,
-        toolResponse,
-      );
-
-      // Verify that loading was toggled correctly
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenNthCalledWith(
-        1,
-        true,
-        messageId,
-        expect.any(String),
-      );
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenNthCalledWith(
-        2,
-        false,
-        messageId,
-        expect.any(String),
-      );
-      expect(useChatStore.getState().text2image).not.toHaveBeenCalled();
+      // Should not throw error, just return early
     });
 
-    it('should handle errors when transformApiArgumentsToAiState throw error', async () => {
-      const args = { key: 'value' };
+    it('should not invoke action if arguments cannot be parsed', async () => {
       const payload = {
-        apiName: 'builtinApi',
-        arguments: JSON.stringify(args),
+        apiName: 'mockBuiltinAction',
+        arguments: 'invalid json',
       } as ChatToolPayload;
 
       const messageId = 'message-id';
-
-      useToolStore.setState({
-        transformApiArgumentsToAiState: vi
-          .fn()
-          .mockRejectedValue({ error: 'transformApiArgumentsToAiState throw error' }),
-      });
+      const mockActionFn = vi.fn().mockResolvedValue(undefined);
 
       useChatStore.setState({
-        internal_togglePluginApiCalling: vi.fn(),
-        internal_updateMessageContent: vi.fn(),
-        internal_updatePluginError: vi.fn(),
-        text2image: vi.fn(),
-        refreshMessages: vi.fn(),
-      });
+        mockBuiltinAction: mockActionFn,
+      } as any);
 
       const { result } = renderHook(() => useChatStore());
 
@@ -742,35 +671,8 @@ describe('ChatPluginAction', () => {
         await result.current.invokeBuiltinTool(messageId, payload);
       });
 
-      expect(result.current.internal_updatePluginError).toHaveBeenCalledWith('message-id', {
-        type: 'PluginFailToTransformArguments',
-        body: {
-          message: expect.any(String),
-          stack: undefined,
-          arguments: args,
-          schema: undefined,
-        },
-        message: expect.any(String),
-      });
-      // Verify that loading was toggled correctly
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenNthCalledWith(
-        1,
-        true,
-        messageId,
-        expect.any(String),
-      );
-      expect(result.current.internal_togglePluginApiCalling).toHaveBeenNthCalledWith(
-        2,
-        false,
-        messageId,
-        expect.any(String),
-      );
-
-      // Verify that the message content was not updated
-      expect(result.current.internal_updateMessageContent).not.toHaveBeenCalled();
-
-      // Verify that messages were not refreshed
-      expect(useChatStore.getState().text2image).not.toHaveBeenCalled();
+      // Should not call the action if arguments can't be parsed
+      expect(mockActionFn).not.toHaveBeenCalled();
     });
   });
 

package/src/store/chat/slices/plugin/action.ts

@@ -1,7 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 import { ToolNameResolver } from '@lobechat/context-engine';
 import {
-  ChatErrorType,
   ChatMessageError,
   ChatToolPayload,
   CreateMessageParams,
@@ -111,54 +110,12 @@ export const chatPlugin: StateCreator<
     if (triggerAiMessage) await triggerAIMessage({ parentId: id });
   },
   invokeBuiltinTool: async (id, payload) => {
-    const {
-      internal_togglePluginApiCalling,
-      internal_updateMessageContent,
-      internal_updatePluginError,
-    } = get();
-    const params = JSON.parse(payload.arguments);
-    internal_togglePluginApiCalling(true, id, n('invokeBuiltinTool/start') as string);
-    let data;
-    try {
-      data = await useToolStore.getState().transformApiArgumentsToAiState(payload.apiName, params);
-    } catch (error) {
-      const err = error as Error;
-      console.error(err);
-
-      const tool = builtinTools.find((tool) => tool.identifier === payload.identifier);
-      const schema = tool?.manifest?.api.find((api) => api.name === payload.apiName)?.parameters;
-
-      await internal_updatePluginError(id, {
-        type: ChatErrorType.PluginFailToTransformArguments,
-        body: {
-          message:
-            "[plugin] fail to transform plugin arguments to ai state, it may due to model's limited tools calling capacity. You can refer to https://lobehub.com/docs/usage/tools-calling for more detail.",
-          stack: err.stack,
-          arguments: params,
-          schema,
-        },
-        message: '',
-      });
-    }
-    internal_togglePluginApiCalling(false, id, n('invokeBuiltinTool/end') as string);
-
-    if (!data) return;
-
-    await internal_updateMessageContent(id, data);
-
     // run tool api call
-    // postToolCalling
     // @ts-ignore
     const { [payload.apiName]: action } = get();
     if (!action) return;
 
-    let content;
-
-    try {
-      content = JSON.parse(data);
-    } catch {
-      /* empty block */
-    }
+    const content = safeParseJSON(payload.arguments);
 
     if (!content) return;
 

package/src/store/global/store.ts

@@ -4,25 +4,19 @@ import { createWithEqualityFn } from 'zustand/traditional';
 import { StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
-import { type GlobalClientDBAction, clientDBSlice } from './actions/clientDb';
 import { type GlobalGeneralAction, generalActionSlice } from './actions/general';
 import { type GlobalWorkspacePaneAction, globalWorkspaceSlice } from './actions/workspacePane';
 import { type GlobalState, initialState } from './initialState';
 
 //  ===============  聚合 createStoreFn ============ //
 
-export interface GlobalStore
-  extends GlobalState,
-    GlobalWorkspacePaneAction,
-    GlobalClientDBAction,
-    GlobalGeneralAction {
+export interface GlobalStore extends GlobalState, GlobalWorkspacePaneAction, GlobalGeneralAction {
   /* empty */
 }
 
 const createStore: StateCreator<GlobalStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
   ...globalWorkspaceSlice(...parameters),
-  ...clientDBSlice(...parameters),
   ...generalActionSlice(...parameters),
 });
 

package/src/store/tool/selectors/tool.test.ts

@@ -78,7 +78,7 @@ describe('toolSelectors', () => {
 
   describe('metaList and getMetaById', () => {
     it('should return the correct list of tool metadata', () => {
-      const result = toolSelectors.metaList()(mockState);
+      const result = toolSelectors.metaList(mockState);
       expect(result).toEqual([
         {
           type: 'builtin',

package/src/store/tool/selectors/tool.ts

@@ -53,18 +53,16 @@ const enabledSystemRoles =
     return '';
   };
 
-const metaList =
-  (showDalle?: boolean) =>
-  (s: ToolStoreState): LobeToolMeta[] => {
-    const pluginList = pluginSelectors.installedPluginMetaList(s) as LobeToolMeta[];
+const metaList = (s: ToolStoreState): LobeToolMeta[] => {
+  const pluginList = pluginSelectors.installedPluginMetaList(s) as LobeToolMeta[];
 
-    return builtinToolSelectors.metaList(showDalle)(s).concat(pluginList);
-  };
+  return builtinToolSelectors.metaList(s).concat(pluginList);
+};
 
 const getMetaById =
-  (id: string, showDalle: boolean = true) =>
+  (id: string) =>
   (s: ToolStoreState): MetaData | undefined => {
-    const item = metaList(showDalle)(s).find((m) => m.identifier === id);
+    const item = metaList(s).find((m) => m.identifier === id);
 
     if (!item) return;
 

package/src/store/tool/slices/builtin/action.test.ts

@@ -6,19 +6,20 @@ import { useToolStore } from '../../store';
 vi.mock('zustand/traditional');
 
 describe('createBuiltinToolSlice', () => {
-  describe('invokeBuiltinTool', () => {
-    it('should return if the tool is already loading', async () => {
+  describe('transformApiArgumentsToAiState', () => {
+    it('should return early if the tool is already loading', async () => {
       // Given
-      const key = 'text2image';
-      const params = {};
+      const key = 'mockTool';
+      const params = { test: 'data' };
 
       const mockFn = vi.fn();
       const { result } = renderHook(() => useToolStore());
 
       act(() => {
         useToolStore.setState({
-          text2image: mockFn,
-        });
+          builtinToolLoading: { [key]: true },
+          mockTool: mockFn,
+        } as any);
       });
 
       await act(async () => {
@@ -27,61 +28,108 @@ describe('createBuiltinToolSlice', () => {
         expect(data).toBeUndefined();
       });
 
-      // Then
-      expect(mockFn).toHaveBeenCalled();
+      // Then - should not call the action if already loading
+      expect(mockFn).not.toHaveBeenCalled();
     });
 
     it('should invoke the specified tool action and return the stringified result', async () => {
       // Given
-      const key = 'text2image';
-
-      const mockFn = vi.fn();
+      const key = 'mockTool';
+      const mockResult = { success: true, data: 'test result' };
+      const mockFn = vi.fn().mockResolvedValue(mockResult);
       const { result } = renderHook(() => useToolStore());
 
       const params = {
-        prompts: ['test prompt'],
-        size: '512x512',
-        quality: 'standard',
-        style: 'vivid',
+        input: 'test input',
+        option: 'value',
       };
 
       act(() => {
         useToolStore.setState({
           builtinToolLoading: { [key]: false },
-          text2image: mockFn,
+          mockTool: mockFn,
+        } as any);
+      });
+
+      // When
+      let resultData: string | undefined;
+      await act(async () => {
+        resultData = await result.current.transformApiArgumentsToAiState(key, params);
+      });
+
+      // Then
+      expect(mockFn).toHaveBeenCalledWith({
+        input: 'test input',
+        option: 'value',
+      });
+      expect(resultData).toBe(JSON.stringify(mockResult));
+    });
+
+    it('should return stringified params if action does not exist', async () => {
+      // Given
+      const key = 'nonExistentTool';
+      const params = { test: 'data' };
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        useToolStore.setState({
+          builtinToolLoading: {},
         });
       });
+
       // When
+      let resultData: string | undefined;
       await act(async () => {
-        await result.current.transformApiArgumentsToAiState(key, params);
+        resultData = await result.current.transformApiArgumentsToAiState(key, params);
       });
 
-      expect(mockFn).toBeCalledWith({
-        prompts: ['test prompt'],
-        quality: 'standard',
-        size: '512x512',
-        style: 'vivid',
+      // Then
+      expect(resultData).toBe(JSON.stringify(params));
+    });
+
+    it('should handle errors and toggle loading state', async () => {
+      // Given
+      const key = 'mockTool';
+      const params = { test: 'data' };
+      const error = new Error('Tool execution failed');
+      const mockFn = vi.fn().mockRejectedValue(error);
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        useToolStore.setState({
+          builtinToolLoading: { [key]: false },
+          mockTool: mockFn,
+        } as any);
+      });
+
+      // When/Then
+      await act(async () => {
+        await expect(result.current.transformApiArgumentsToAiState(key, params)).rejects.toThrow(
+          'Tool execution failed',
+        );
       });
+
+      // Should have toggled loading state back to false
+      expect(result.current.builtinToolLoading[key]).toBe(false);
     });
   });
 
-  describe('text2image', () => {
-    it('should map the prompts to DallEImageItem objects', () => {
-      // When
+  describe('toggleBuiltinToolLoading', () => {
+    it('should toggle the loading state for a tool', () => {
       const { result } = renderHook(() => useToolStore());
+      const key = 'testTool';
+
+      act(() => {
+        result.current.toggleBuiltinToolLoading(key, true);
+      });
+
+      expect(result.current.builtinToolLoading[key]).toBe(true);
 
-      const data = result.current.text2image({
-        prompts: ['prompt1', 'prompt2'],
-        size: '1024x1024',
-        quality: 'standard',
-        style: 'vivid',
+      act(() => {
+        result.current.toggleBuiltinToolLoading(key, false);
       });
 
-      // Then
-      expect(data).toEqual([
-        { prompt: 'prompt1', quality: 'standard', size: '1024x1024', style: 'vivid' },
-        { prompt: 'prompt2', quality: 'standard', size: '1024x1024', style: 'vivid' },
-      ]);
+      expect(result.current.builtinToolLoading[key]).toBe(false);
     });
   });
 });

package/src/store/tool/slices/builtin/action.ts

@@ -1,22 +1,15 @@
 import { StateCreator } from 'zustand/vanilla';
 
-import { OpenAIImagePayload } from '@/types/openai/image';
-import { DallEImageItem } from '@/types/tool/dalle';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { ToolStore } from '../../store';
 
 const n = setNamespace('builtinTool');
 
-interface Text2ImageParams extends Pick<OpenAIImagePayload, 'quality' | 'style' | 'size'> {
-  prompts: string[];
-}
-
 /**
  * 代理行为接口
  */
 export interface BuiltinToolAction {
-  text2image: (params: Text2ImageParams) => DallEImageItem[];
   toggleBuiltinToolLoading: (key: string, value: boolean) => void;
   transformApiArgumentsToAiState: (key: string, params: any) => Promise<string | undefined>;
 }
@@ -27,8 +20,6 @@ export const createBuiltinToolSlice: StateCreator<
   [],
   BuiltinToolAction
 > = (set, get) => ({
-  text2image: ({ prompts, size = '1024x1024' as const, quality = 'standard', style = 'vivid' }) =>
-    prompts.map((p) => ({ prompt: p, quality, size, style })),
   toggleBuiltinToolLoading: (key, value) => {
     set({ builtinToolLoading: { [key]: value } }, false, n('toggleBuiltinToolLoading'));
   },

package/src/store/tool/slices/builtin/selectors.test.ts

@@ -1,7 +1,5 @@
 import { describe, expect, it } from 'vitest';
 
-import { DalleManifest } from '@/tools/dalle';
-
 import { ToolStoreState, initialState } from '../../initialState';
 import { builtinToolSelectors } from './selectors';
 
@@ -10,34 +8,11 @@ describe('builtinToolSelectors', () => {
     it('should return meta list excluding Dalle when showDalle is false', () => {
       const state = {
         ...initialState,
-        builtinTools: [
-          { identifier: 'tool-1', manifest: { meta: { title: 'Tool 1' } } },
-          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
-        ],
-      } as ToolStoreState;
-      const result = builtinToolSelectors.metaList(false)(state);
-      expect(result).toEqual([
-        { author: 'LobeHub', identifier: 'tool-1', meta: { title: 'Tool 1' }, type: 'builtin' },
-      ]);
-    });
-
-    it('should include Dalle when showDalle is true', () => {
-      const state = {
-        ...initialState,
-        builtinTools: [
-          { identifier: 'tool-1', manifest: { meta: { title: 'Tool 1' } } },
-          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
-        ],
+        builtinTools: [{ identifier: 'tool-1', manifest: { meta: { title: 'Tool 1' } } }],
       } as ToolStoreState;
-      const result = builtinToolSelectors.metaList(true)(state);
+      const result = builtinToolSelectors.metaList(state);
       expect(result).toEqual([
         { author: 'LobeHub', identifier: 'tool-1', meta: { title: 'Tool 1' }, type: 'builtin' },
-        {
-          author: 'LobeHub',
-          identifier: DalleManifest.identifier,
-          meta: { title: 'Dalle' },
-          type: 'builtin',
-        },
       ]);
     });
 
@@ -46,10 +21,9 @@ describe('builtinToolSelectors', () => {
         ...initialState,
         builtinTools: [
           { identifier: 'tool-1', hidden: true, manifest: { meta: { title: 'Tool 1' } } },
-          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
         ],
       } as ToolStoreState;
-      const result = builtinToolSelectors.metaList(false)(state);
+      const result = builtinToolSelectors.metaList(state);
       expect(result).toEqual([]);
     });
 
@@ -58,7 +32,7 @@ describe('builtinToolSelectors', () => {
         ...initialState,
         builtinTools: [],
       };
-      const result = builtinToolSelectors.metaList(false)(state);
+      const result = builtinToolSelectors.metaList(state);
       expect(result).toEqual([]);
     });
   });

package/src/store/tool/slices/builtin/selectors.ts

@@ -1,32 +1,26 @@
 import { LobeToolMeta } from '@lobechat/types';
 
 import { shouldEnableTool } from '@/helpers/toolFilters';
-import { DalleManifest } from '@/tools/dalle';
 
 import type { ToolStoreState } from '../../initialState';
 
-const metaList =
-  (showDalle?: boolean) =>
-  (s: ToolStoreState): LobeToolMeta[] =>
-    s.builtinTools
-      .filter((item) => {
-        // Filter hidden tools
-        if (item.hidden) return false;
+const metaList = (s: ToolStoreState): LobeToolMeta[] =>
+  s.builtinTools
+    .filter((item) => {
+      // Filter hidden tools
+      if (item.hidden) return false;
 
-        // Filter Dalle if not enabled
-        if (!showDalle && item.identifier === DalleManifest.identifier) return false;
+      // Filter platform-specific tools (e.g., LocalSystem desktop-only)
+      if (!shouldEnableTool(item.identifier)) return false;
 
-        // Filter platform-specific tools (e.g., LocalSystem desktop-only)
-        if (!shouldEnableTool(item.identifier)) return false;
-
-        return true;
-      })
-      .map((t) => ({
-        author: 'LobeHub',
-        identifier: t.identifier,
-        meta: t.manifest.meta,
-        type: 'builtin',
-      }));
+      return true;
+    })
+    .map((t) => ({
+      author: 'LobeHub',
+      identifier: t.identifier,
+      meta: t.manifest.meta,
+      type: 'builtin',
+    }));
 
 export const builtinToolSelectors = {
   metaList,