@lobehub/lobehub 2.0.0-next.3 → 2.0.0-next.30

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,
@@ -99,8 +98,8 @@ export const chatPlugin: StateCreator<
       topicId: get().activeTopicId, // if there is activeTopicId，then add it to topicId
     };
 
-    await messageService.createMessage(newMessage);
-    await get().refreshMessages();
+    const result = await messageService.createNewMessage(newMessage);
+    get().replaceMessages(result.messages);
   },
 
   fillPluginMessageContent: async (id, content, triggerAiMessage) => {
@@ -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;
 
@@ -187,7 +144,7 @@ export const chatPlugin: StateCreator<
 
     // if the plugin settings is not valid, then set the message with error type
     if (!result.valid) {
-      await messageService.updateMessageError(id, {
+      const updateResult = await messageService.updateMessageError(id, {
         body: {
           error: result.errors,
           message: '[plugin] your settings is invalid with plugin manifest setting schema',
@@ -196,7 +153,9 @@ export const chatPlugin: StateCreator<
         type: PluginErrorType.PluginSettingsInvalid as any,
       });
 
-      await get().refreshMessages();
+      if (updateResult?.success && updateResult.messages) {
+        get().replaceMessages(updateResult.messages);
+      }
       return;
     }
   },
@@ -271,15 +230,15 @@ export const chatPlugin: StateCreator<
         groupId: message.groupId, // Propagate groupId from parent message for group chat
       };
 
-      const id = await get().internal_createMessage(toolMessage);
-      if (!id) return;
+      const result = await get().internal_createMessage(toolMessage);
+      if (!result) return;
 
       // trigger the plugin call
-      const data = await get().internal_invokeDifferentTypePlugin(id, payload);
+      const data = await get().internal_invokeDifferentTypePlugin(result.id, payload);
 
       if (data && !['markdown', 'standalone'].includes(payload.type)) {
         shouldCreateMessage = true;
-        latestToolId = id;
+        latestToolId = result.id;
       }
     });
 
@@ -295,13 +254,19 @@ export const chatPlugin: StateCreator<
     await get().triggerAIMessage({ traceId, threadId, inPortalThread, inSearchWorkflow });
   },
   updatePluginState: async (id, value) => {
-    const { refreshMessages } = get();
+    const { replaceMessages } = get();
 
     // optimistic update
     get().internal_dispatchMessage({ id, type: 'updateMessage', value: { pluginState: value } });
 
-    await messageService.updateMessagePluginState(id, value);
-    await refreshMessages();
+    const result = await messageService.updateMessagePluginState(id, value, {
+      sessionId: get().activeId,
+      topicId: get().activeTopicId,
+    });
+
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
   },
 
   updatePluginArguments: async (id, value, replace = false) => {
@@ -379,18 +344,26 @@ export const chatPlugin: StateCreator<
     const message = chatSelectors.getMessageById(id)(get());
     if (!message || !message.tools) return;
 
-    const { internal_toggleMessageLoading, refreshMessages } = get();
+    const { internal_toggleMessageLoading, replaceMessages } = get();
 
     internal_toggleMessageLoading(true, id);
-    await messageService.updateMessage(id, { tools: message.tools });
+    const result = await messageService.updateMessage(
+      id,
+      { tools: message.tools },
+      {
+        sessionId: get().activeId,
+        topicId: get().activeTopicId,
+      },
+    );
     internal_toggleMessageLoading(false, id);
 
-    await refreshMessages();
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
   },
 
   internal_callPluginApi: async (id, payload) => {
-    const { internal_updateMessageContent, refreshMessages, internal_togglePluginApiCalling } =
-      get();
+    const { internal_updateMessageContent, internal_togglePluginApiCalling } = get();
     let data: string;
 
     try {
@@ -418,8 +391,10 @@ export const chatPlugin: StateCreator<
 
       // ignore the aborted request error
       if (!err.message.includes('The user aborted a request.')) {
-        await messageService.updateMessageError(id, error as any);
-        await refreshMessages();
+        const result = await messageService.updateMessageError(id, error as any);
+        if (result?.success && result.messages) {
+          get().replaceMessages(result.messages);
+        }
       }
 
       data = '';
@@ -461,7 +436,6 @@ export const chatPlugin: StateCreator<
   invokeMCPTypePlugin: async (id, payload) => {
     const {
       internal_updateMessageContent,
-      refreshMessages,
       internal_togglePluginApiCalling,
       internal_constructToolsCallingContext,
     } = get();
@@ -487,8 +461,10 @@ export const chatPlugin: StateCreator<
 
       // ignore the aborted request error
       if (!err.message.includes('The user aborted a request.')) {
-        await messageService.updateMessageError(id, error as any);
-        await refreshMessages();
+        const result = await messageService.updateMessageError(id, error as any);
+        if (result?.success && result.messages) {
+          get().replaceMessages(result.messages);
+        }
       }
     }
 
@@ -530,11 +506,20 @@ export const chatPlugin: StateCreator<
     return toolNameResolver.resolve(toolCalls, manifests);
   },
   internal_updatePluginError: async (id, error) => {
-    const { refreshMessages } = get();
+    const { replaceMessages } = get();
 
     get().internal_dispatchMessage({ id, type: 'updateMessage', value: { error } });
-    await messageService.updateMessage(id, { error });
-    await refreshMessages();
+    const result = await messageService.updateMessage(
+      id,
+      { error },
+      {
+        sessionId: get().activeId,
+        topicId: get().activeTopicId,
+      },
+    );
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
   },
 
   internal_constructToolsCallingContext: (id: string) => {

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

@@ -764,7 +764,7 @@ describe('thread action', () => {
 
         const createMessageSpy = vi
           .spyOn(result.current, 'internal_createMessage')
-          .mockResolvedValue('new-msg-id');
+          .mockResolvedValue({ id: 'new-msg-id', messages: [] });
         const coreProcessSpy = vi
           .spyOn(result.current, 'internal_coreProcessMessage')
           .mockResolvedValue();
@@ -803,7 +803,10 @@ describe('thread action', () => {
           });
         });
 
-        vi.spyOn(result.current, 'internal_createMessage').mockResolvedValue('new-msg-id');
+        vi.spyOn(result.current, 'internal_createMessage').mockResolvedValue({
+          id: 'new-msg-id',
+          messages: [],
+        });
         vi.spyOn(result.current, 'internal_coreProcessMessage').mockResolvedValue();
         vi.spyOn(result.current, 'internal_createTmpMessage').mockReturnValue('temp-msg-id');
         vi.spyOn(result.current, 'internal_toggleMessageLoading');
@@ -833,7 +836,10 @@ describe('thread action', () => {
           });
         });
 
-        vi.spyOn(result.current, 'internal_createMessage').mockResolvedValue('new-msg-id');
+        vi.spyOn(result.current, 'internal_createMessage').mockResolvedValue({
+          id: 'new-msg-id',
+          messages: [],
+        });
         vi.spyOn(result.current, 'internal_coreProcessMessage').mockResolvedValue();
         vi.spyOn(result.current, 'internal_createTmpMessage').mockReturnValue('temp-msg-id');
         vi.spyOn(result.current, 'internal_toggleMessageLoading');
@@ -855,7 +861,10 @@ describe('thread action', () => {
         });
 
         vi.spyOn(result.current, 'internal_shouldUseRAG').mockReturnValue(true);
-        vi.spyOn(result.current, 'internal_createMessage').mockResolvedValue('new-msg-id');
+        vi.spyOn(result.current, 'internal_createMessage').mockResolvedValue({
+          id: 'new-msg-id',
+          messages: [],
+        });
         vi.spyOn(result.current, 'internal_createTmpMessage').mockReturnValue('temp-msg-id');
         vi.spyOn(result.current, 'internal_toggleMessageLoading');
 

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

@@ -158,7 +158,9 @@ export const chatThreadMessage: StateCreator<
       tempMessageId = get().internal_createTmpMessage(newMessage);
       get().internal_toggleMessageLoading(true, tempMessageId);
 
-      parentMessageId = await get().internal_createMessage(newMessage, { tempMessageId });
+      const result = await get().internal_createMessage(newMessage, { tempMessageId });
+      if (!result) return;
+      parentMessageId = result.id;
     }
 
     get().internal_toggleMessageLoading(false, tempMessageId);

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

@@ -254,7 +254,7 @@ describe('topic action', () => {
 
       const updateFavoriteSpy = vi
         .spyOn(topicService, 'updateTopic')
-        .mockResolvedValue({ success: 1 });
+        .mockResolvedValue(undefined as any);
 
       const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
 

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

@@ -15,7 +15,6 @@ import { useClientDataSWR } from '@/libs/swr';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
-import { CreateTopicParams } from '@/services/topic/type';
 import type { ChatStore } from '@/store/chat';
 import type { ChatStoreState } from '@/store/chat/initialState';
 import { messageMapKey } from '@/store/chat/utils/messageMapKey';
@@ -24,7 +23,7 @@ import { useSessionStore } from '@/store/session';
 import { sessionSelectors } from '@/store/session/selectors';
 import { useUserStore } from '@/store/user';
 import { systemAgentSelectors } from '@/store/user/selectors';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, CreateTopicParams } from '@/types/topic';
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
 

package/src/store/chat/slices/topic/reducer.ts

@@ -1,7 +1,6 @@
 import { produce } from 'immer';
 
-import { CreateTopicParams } from '@/services/topic/type';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, CreateTopicParams } from '@/types/topic';
 
 interface AddChatTopicAction {
   type: 'addTopic';

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

@@ -4,7 +4,6 @@ import { StateCreator } from 'zustand/vanilla';
 import { notification } from '@/components/AntdStaticMethods';
 import { FILE_UPLOAD_BLACKLIST } from '@/const/file';
 import { fileService } from '@/services/file';
-import { ServerService } from '@/services/file/server';
 import { ragService } from '@/services/rag';
 import { UPLOAD_NETWORK_ERROR } from '@/services/upload';
 import {
@@ -21,8 +20,6 @@ import { FileStore } from '../../store';
 
 const n = setNamespace('chat');
 
-const serverFileService = new ServerService();
-
 export interface FileAction {
   clearChatUploadFileList: () => void;
   dispatchChatUploadFileList: (payload: UploadFileListDispatch) => void;
@@ -71,7 +68,7 @@ export const createFileSlice: StateCreator<
       let fileItem: FileListItem | undefined = undefined;
 
       try {
-        fileItem = await serverFileService.getFileItem(id);
+        fileItem = await fileService.getFileItem(id);
       } catch (e) {
         console.error('getFileItem Error:', e);
         continue;

package/src/store/file/slices/fileManager/action.ts

@@ -4,8 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { useClientDataSWR } from '@/libs/swr';
-import { fileService } from '@/services/file';
-import { ServerService } from '@/services/file/server';
+import { fileService , FileService } from '@/services/file';
 import { ragService } from '@/services/rag';
 import {
   UploadFileListDispatch,
@@ -18,7 +17,7 @@ import { unzipFile } from '@/utils/unzipFile';
 import { FileStore } from '../../store';
 import { fileManagerSelectors } from './selectors';
 
-const serverFileService = new ServerService();
+const serverFileService = new FileService();
 
 export interface FileManageAction {
   dispatchDockFileList: (payload: UploadFileListDispatch) => void;

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/session/slices/sessionGroup/action.test.ts

@@ -42,7 +42,7 @@ describe('createSessionGroupSlice', () => {
     it('should clear session groups and refresh sessions', async () => {
       const spyOn = vi
         .spyOn(sessionService, 'removeSessionGroups')
-        .mockResolvedValueOnce(undefined);
+        .mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -59,7 +59,7 @@ describe('createSessionGroupSlice', () => {
   describe('removeSessionGroup', () => {
     it('should remove a session group and refresh sessions', async () => {
       const mockId = 'mock-id';
-      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -77,7 +77,7 @@ describe('createSessionGroupSlice', () => {
     it('should update a session group id and refresh sessions', async () => {
       const mockSessionId = 'session-id';
       const mockGroupId = 'group-id';
-      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -98,7 +98,7 @@ describe('createSessionGroupSlice', () => {
       const mockId = 'mock-id';
       const mockName = 'New Name';
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
-      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined as any);
 
       const { result } = renderHook(() => useSessionStore());
 
@@ -117,7 +117,7 @@ describe('createSessionGroupSlice', () => {
         { id: 'id1', sort: 0 },
         { id: 'id2', sort: 1 },
       ];
-      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());

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'));
   },