@lobehub/chat 0.154.6 → 0.154.7

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 0.154.7](https://github.com/lobehub/lobe-chat/compare/v0.154.6...v0.154.7)
+
+<sup>Released on **2024-05-07**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor the message slice internal method name.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor the message slice internal method name, closes [#2407](https://github.com/lobehub/lobe-chat/issues/2407) ([8c70bdd](https://github.com/lobehub/lobe-chat/commit/8c70bdd))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 0.154.6](https://github.com/lobehub/lobe-chat/compare/v0.154.5...v0.154.6)
 
 <sup>Released on **2024-05-07**</sup>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "0.154.6",
+  "version": "0.154.7",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/src/features/Conversation/Error/APIKeyForm/index.tsx

@@ -19,7 +19,7 @@ interface APIKeyFormProps {
 const APIKeyForm = memo<APIKeyFormProps>(({ id, provider }) => {
   const { t } = useTranslation('error');
 
-  const [resend, deleteMessage] = useChatStore((s) => [s.internalResendMessage, s.deleteMessage]);
+  const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
 
   const apiKeyPlaceholder = useMemo(() => {
     switch (provider) {

package/src/features/Conversation/Error/AccessCodeForm.tsx

@@ -19,7 +19,7 @@ const AccessCodeForm = memo<AccessCodeFormProps>(({ id }) => {
     settingsSelectors.currentSettings(s).password,
     s.setSettings,
   ]);
-  const [resend, deleteMessage] = useChatStore((s) => [s.internalResendMessage, s.deleteMessage]);
+  const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
 
   return (
     <>

package/src/features/Conversation/Error/ClerkLogin/index.tsx

@@ -15,7 +15,7 @@ const ClerkLogin = memo<{ id: string }>(({ id }) => {
   const [openSignIn, isSignedIn] = useUserStore((s) => [s.openLogin, s.isSignedIn]);
   const greeting = useGreeting();
   const nickName = useUserStore(userProfileSelectors.nickName);
-  const [resend, deleteMessage] = useChatStore((s) => [s.internalResendMessage, s.deleteMessage]);
+  const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
 
   return (
     <ErrorActionContainer>

package/src/features/Conversation/Error/OAuthForm.tsx

@@ -16,7 +16,7 @@ const OAuthForm = memo<{ id: string }>(({ id }) => {
 
   const { user, isOAuthLoggedIn } = useOAuthSession();
 
-  const [resend, deleteMessage] = useChatStore((s) => [s.internalResendMessage, s.deleteMessage]);
+  const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
 
   const { message, modal } = App.useApp();
 

package/src/features/Conversation/Error/PluginSettings.tsx

@@ -23,7 +23,7 @@ const PluginSettings = memo<PluginSettingsProps>(({ id, plugin }) => {
   const { styles } = useStyles();
   const { t } = useTranslation('error');
   const theme = useTheme();
-  const [resend, deleteMessage] = useChatStore((s) => [s.internalResendMessage, s.deleteMessage]);
+  const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
   const pluginIdentifier = plugin?.identifier as string;
   const pluginMeta = useToolStore(pluginSelectors.getPluginMetaById(pluginIdentifier), isEqual);
   const manifest = useToolStore(pluginSelectors.getPluginManifestById(pluginIdentifier), isEqual);

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

@@ -49,7 +49,7 @@ export const chatEnhance: StateCreator<
     ...data,
   }),
   translateMessage: async (id, targetLang) => {
-    const { toggleChatLoading, updateMessageTranslate, dispatchMessage } = get();
+    const { internal_toggleChatLoading, updateMessageTranslate, internal_dispatchMessage } = get();
 
     const message = chatSelectors.getMessageById(id)(get());
     if (!message) return;
@@ -57,7 +57,7 @@ export const chatEnhance: StateCreator<
     // create translate extra
     await updateMessageTranslate(id, { content: '', from: '', to: targetLang });
 
-    toggleChatLoading(true, id, n('translateMessage(start)', { id }) as string);
+    internal_toggleChatLoading(true, id, n('translateMessage(start)', { id }) as string);
 
     let content = '';
     let from = '';
@@ -77,7 +77,7 @@ export const chatEnhance: StateCreator<
     // translate to target language
     await chatService.fetchPresetTaskResult({
       onMessageHandle: (text) => {
-        dispatchMessage({
+        internal_dispatchMessage({
           id,
           key: 'translate',
           type: 'updateMessageExtra',
@@ -93,7 +93,7 @@ export const chatEnhance: StateCreator<
 
     await updateMessageTranslate(id, { content, from, to: targetLang });
 
-    toggleChatLoading(false);
+    internal_toggleChatLoading(false);
   },
 
   ttsMessage: async (id, state = {}) => {

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

@@ -53,7 +53,7 @@ vi.mock('@/store/chat/selectors', () => ({
   },
 }));
 
-const realCoreProcessMessage = useChatStore.getState().coreProcessMessage;
+const realCoreProcessMessage = useChatStore.getState().internal_coreProcessMessage;
 const realRefreshMessages = useChatStore.getState().refreshMessages;
 // Mock state
 const mockState = {
@@ -62,7 +62,7 @@ const mockState = {
   messages: [],
   refreshMessages: vi.fn(),
   refreshTopic: vi.fn(),
-  coreProcessMessage: vi.fn(),
+  internal_coreProcessMessage: vi.fn(),
   saveToTopic: vi.fn(),
 };
 
@@ -191,7 +191,7 @@ describe('chatMessage actions', () => {
 
       expect(messageService.createMessage).not.toHaveBeenCalled();
       expect(result.current.refreshMessages).not.toHaveBeenCalled();
-      expect(result.current.coreProcessMessage).not.toHaveBeenCalled();
+      expect(result.current.internal_coreProcessMessage).not.toHaveBeenCalled();
     });
 
     it('should not send message if message is empty and there are no files', async () => {
@@ -204,7 +204,7 @@ describe('chatMessage actions', () => {
 
       expect(messageService.createMessage).not.toHaveBeenCalled();
       expect(result.current.refreshMessages).not.toHaveBeenCalled();
-      expect(result.current.coreProcessMessage).not.toHaveBeenCalled();
+      expect(result.current.internal_coreProcessMessage).not.toHaveBeenCalled();
     });
 
     it('should not send message if message is empty and there are empty files', async () => {
@@ -217,10 +217,10 @@ describe('chatMessage actions', () => {
 
       expect(messageService.createMessage).not.toHaveBeenCalled();
       expect(result.current.refreshMessages).not.toHaveBeenCalled();
-      expect(result.current.coreProcessMessage).not.toHaveBeenCalled();
+      expect(result.current.internal_coreProcessMessage).not.toHaveBeenCalled();
     });
 
-    it('should create message and call coreProcessMessage if message or files are provided', async () => {
+    it('should create message and call internal_coreProcessMessage if message or files are provided', async () => {
       const { result } = renderHook(() => useChatStore());
       const message = 'Test message';
       const files = [{ id: 'file-id', url: 'file-url' }];
@@ -240,7 +240,7 @@ describe('chatMessage actions', () => {
         topicId: mockState.activeTopicId,
       });
       expect(result.current.refreshMessages).toHaveBeenCalled();
-      expect(result.current.coreProcessMessage).toHaveBeenCalled();
+      expect(result.current.internal_coreProcessMessage).toHaveBeenCalled();
     });
 
     describe('auto-create topic', () => {
@@ -365,7 +365,7 @@ describe('chatMessage actions', () => {
     });
   });
 
-  describe('internalResendMessage action', () => {
+  describe('internal_resendMessage action', () => {
     it('should resend a message by id and refresh messages', async () => {
       const { result } = renderHook(() => useChatStore());
       const messageId = 'message-id';
@@ -377,15 +377,19 @@ describe('chatMessage actions', () => {
         // ... other messages
       ]);
 
-      // Mock the coreProcessMessage function to resolve immediately
-      mockState.coreProcessMessage.mockResolvedValue(undefined);
+      // Mock the internal_coreProcessMessage function to resolve immediately
+      mockState.internal_coreProcessMessage.mockResolvedValue(undefined);
 
       await act(async () => {
-        await result.current.internalResendMessage(messageId);
+        await result.current.internal_resendMessage(messageId);
       });
 
       expect(messageService.removeMessage).not.toHaveBeenCalledWith(messageId);
-      expect(mockState.coreProcessMessage).toHaveBeenCalledWith(expect.any(Array), messageId, {});
+      expect(mockState.internal_coreProcessMessage).toHaveBeenCalledWith(
+        expect.any(Array),
+        messageId,
+        {},
+      );
     });
 
     it('should not perform any action if the message id does not exist', async () => {
@@ -398,23 +402,23 @@ describe('chatMessage actions', () => {
       ]);
 
       await act(async () => {
-        await result.current.internalResendMessage(messageId);
+        await result.current.internal_resendMessage(messageId);
       });
 
       expect(messageService.removeMessage).not.toHaveBeenCalledWith(messageId);
-      expect(mockState.coreProcessMessage).not.toHaveBeenCalled();
+      expect(mockState.internal_coreProcessMessage).not.toHaveBeenCalled();
       expect(mockState.refreshMessages).not.toHaveBeenCalled();
     });
   });
 
-  describe('internalUpdateMessageContent action', () => {
-    it('should call messageService.internalUpdateMessageContent with correct parameters', async () => {
+  describe('internal_updateMessageContent action', () => {
+    it('should call messageService.internal_updateMessageContent with correct parameters', async () => {
       const { result } = renderHook(() => useChatStore());
       const messageId = 'message-id';
       const newContent = 'Updated content';
 
       await act(async () => {
-        await result.current.internalUpdateMessageContent(messageId, newContent);
+        await result.current.internal_updateMessageContent(messageId, newContent);
       });
 
       expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { content: newContent });
@@ -424,13 +428,13 @@ describe('chatMessage actions', () => {
       const { result } = renderHook(() => useChatStore());
       const messageId = 'message-id';
       const newContent = 'Updated content';
-      const dispatchMessageSpy = vi.spyOn(result.current, 'dispatchMessage');
+      const internal_dispatchMessageSpy = vi.spyOn(result.current, 'internal_dispatchMessage');
 
       await act(async () => {
-        await result.current.internalUpdateMessageContent(messageId, newContent);
+        await result.current.internal_updateMessageContent(messageId, newContent);
       });
 
-      expect(dispatchMessageSpy).toHaveBeenCalledWith({
+      expect(internal_dispatchMessageSpy).toHaveBeenCalledWith({
         id: messageId,
         key: 'content',
         type: 'updateMessage',
@@ -444,16 +448,16 @@ describe('chatMessage actions', () => {
       const newContent = 'Updated content';
 
       await act(async () => {
-        await result.current.internalUpdateMessageContent(messageId, newContent);
+        await result.current.internal_updateMessageContent(messageId, newContent);
       });
 
       expect(result.current.refreshMessages).toHaveBeenCalled();
     });
   });
 
-  describe('coreProcessMessage action', () => {
+  describe('internal_coreProcessMessage action', () => {
     it('should handle the core AI message processing', async () => {
-      useChatStore.setState({ coreProcessMessage: realCoreProcessMessage });
+      useChatStore.setState({ internal_coreProcessMessage: realCoreProcessMessage });
 
       const { result } = renderHook(() => useChatStore());
       const userMessage = {
@@ -473,7 +477,7 @@ describe('chatMessage actions', () => {
       (messageService.createMessage as Mock).mockResolvedValue('assistant-message-id');
 
       await act(async () => {
-        await result.current.coreProcessMessage(messages, userMessage.id);
+        await result.current.internal_coreProcessMessage(messages, userMessage.id);
       });
 
       // 验证是否创建了代表 AI 响应的消息
@@ -499,7 +503,7 @@ describe('chatMessage actions', () => {
   describe('stopGenerateMessage action', () => {
     it('should stop generating message and set loading states correctly', async () => {
       const { result } = renderHook(() => useChatStore());
-      const toggleChatLoadingSpy = vi.spyOn(result.current, 'toggleChatLoading');
+      const internal_toggleChatLoadingSpy = vi.spyOn(result.current, 'internal_toggleChatLoading');
       const abortController = new AbortController();
 
       act(() => {
@@ -511,7 +515,11 @@ describe('chatMessage actions', () => {
       });
 
       expect(abortController.signal.aborted).toBe(true);
-      expect(toggleChatLoadingSpy).toHaveBeenCalledWith(false, undefined, expect.any(String));
+      expect(internal_toggleChatLoadingSpy).toHaveBeenCalledWith(
+        false,
+        undefined,
+        expect.any(String),
+      );
     });
 
     it('should not do anything if there is no abortController', async () => {
@@ -598,7 +606,7 @@ describe('chatMessage actions', () => {
     });
   });
 
-  describe('fetchAIChatMessage', () => {
+  describe('internal_fetchAIChatMessage', () => {
     it('should fetch AI chat message and return content', async () => {
       const { result } = renderHook(() => useChatStore());
       const messages = [{ id: 'message-id', content: 'Hello', role: 'user' }] as ChatMessage[];
@@ -608,7 +616,10 @@ describe('chatMessage actions', () => {
       (fetch as Mock).mockResolvedValueOnce(new Response(aiResponse));
 
       await act(async () => {
-        const response = await result.current.fetchAIChatMessage(messages, assistantMessageId);
+        const response = await result.current.internal_fetchAIChatMessage(
+          messages,
+          assistantMessageId,
+        );
         expect(response.content).toEqual(aiResponse);
         expect(response.isFunctionCall).toEqual(false);
         expect(response.functionCallAtEnd).toEqual(false);
@@ -627,7 +638,10 @@ describe('chatMessage actions', () => {
       vi.mocked(fetch).mockResolvedValueOnce(new Response(aiResponse));
 
       await act(async () => {
-        const response = await result.current.fetchAIChatMessage(messages, assistantMessageId);
+        const response = await result.current.internal_fetchAIChatMessage(
+          messages,
+          assistantMessageId,
+        );
         expect(response.content).toEqual(aiResponse);
         expect(response.isFunctionCall).toEqual(true);
         expect(response.functionCallAtEnd).toEqual(false);
@@ -646,7 +660,10 @@ describe('chatMessage actions', () => {
       vi.mocked(fetch).mockResolvedValue(new Response(aiResponse));
 
       await act(async () => {
-        const response = await result.current.fetchAIChatMessage(messages, assistantMessageId);
+        const response = await result.current.internal_fetchAIChatMessage(
+          messages,
+          assistantMessageId,
+        );
         expect(response.content).toEqual(aiResponse);
         expect(response.isFunctionCall).toEqual(true);
         expect(response.functionCallAtEnd).toEqual(true);
@@ -667,19 +684,19 @@ describe('chatMessage actions', () => {
 
       await act(async () => {
         await expect(
-          result.current.fetchAIChatMessage(messages, assistantMessageId),
+          result.current.internal_fetchAIChatMessage(messages, assistantMessageId),
         ).rejects.toThrow(errorMessage);
       });
     });
   });
 
-  describe('toggleChatLoading', () => {
+  describe('internal_toggleChatLoading', () => {
     it('should set loading state and create an AbortController when loading is true', () => {
       const { result } = renderHook(() => useChatStore());
       const action = 'loading-action';
 
       act(() => {
-        result.current.toggleChatLoading(true, 'message-id', action);
+        result.current.internal_toggleChatLoading(true, 'message-id', action);
       });
 
       const state = useChatStore.getState();
@@ -693,12 +710,12 @@ describe('chatMessage actions', () => {
 
       // Set initial loading state
       act(() => {
-        result.current.toggleChatLoading(true, 'message-id', 'start-loading-action');
+        result.current.internal_toggleChatLoading(true, 'message-id', 'start-loading-action');
       });
 
       // Stop loading
       act(() => {
-        result.current.toggleChatLoading(false, undefined, action);
+        result.current.internal_toggleChatLoading(false, undefined, action);
       });
 
       const state = useChatStore.getState();
@@ -711,7 +728,7 @@ describe('chatMessage actions', () => {
       const addEventListenerSpy = vi.spyOn(window, 'addEventListener');
 
       act(() => {
-        result.current.toggleChatLoading(true, 'message-id', 'loading-action');
+        result.current.internal_toggleChatLoading(true, 'message-id', 'loading-action');
       });
 
       expect(addEventListenerSpy).toHaveBeenCalledWith('beforeunload', expect.any(Function));
@@ -723,8 +740,8 @@ describe('chatMessage actions', () => {
 
       // Start and then stop loading to trigger the removal of the event listener
       act(() => {
-        result.current.toggleChatLoading(true, 'message-id', 'start-loading-action');
-        result.current.toggleChatLoading(false, undefined, 'stop-loading-action');
+        result.current.internal_toggleChatLoading(true, 'message-id', 'start-loading-action');
+        result.current.internal_toggleChatLoading(false, undefined, 'stop-loading-action');
       });
 
       expect(removeEventListenerSpy).toHaveBeenCalledWith('beforeunload', expect.any(Function));
@@ -736,7 +753,7 @@ describe('chatMessage actions', () => {
 
       act(() => {
         useChatStore.setState({ abortController });
-        result.current.toggleChatLoading(true, 'message-id', 'loading-action');
+        result.current.internal_toggleChatLoading(true, 'message-id', 'loading-action');
       });
 
       const state = useChatStore.getState();

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

@@ -71,20 +71,26 @@ export interface ChatMessageAction {
   useFetchMessages: (sessionId: string, topicId?: string) => SWRResponse<ChatMessage[]>;
   stopGenerateMessage: () => void;
   copyMessage: (id: string, content: string) => Promise<void>;
+  refreshMessages: () => Promise<void>;
 
   // =========  ↓ Internal Method ↓  ========== //
   // ========================================== //
   // ========================================== //
-
+  internal_toggleChatLoading: (
+    loading: boolean,
+    id?: string,
+    action?: string,
+  ) => AbortController | undefined;
+  internal_toggleMessageLoading: (loading: boolean, id: string) => void;
   /**
    * update message at the frontend point
    * this method will not update messages to database
    */
-  dispatchMessage: (payload: MessageDispatch) => void;
+  internal_dispatchMessage: (payload: MessageDispatch) => void;
   /**
    * core process of the AI message (include preprocess and postprocess)
    */
-  coreProcessMessage: (
+  internal_coreProcessMessage: (
     messages: ChatMessage[],
     parentId: string,
     params?: ProcessMessageParams,
@@ -94,7 +100,7 @@ export interface ChatMessageAction {
    * @param messages - 聊天消息数组
    * @param options - 获取 SSE 选项
    */
-  fetchAIChatMessage: (
+  internal_fetchAIChatMessage: (
     messages: ChatMessage[],
     assistantMessageId: string,
     params?: ProcessMessageParams,
@@ -105,15 +111,8 @@ export interface ChatMessageAction {
     isFunctionCall: boolean;
     traceId?: string;
   }>;
-  toggleChatLoading: (
-    loading: boolean,
-    id?: string,
-    action?: string,
-  ) => AbortController | undefined;
-  toggleMessageLoading: (loading: boolean, id: string) => void;
-  refreshMessages: () => Promise<void>;
   // TODO: 后续 smoothMessage 实现考虑落到 sse 这一层
-  createSmoothMessage: (id: string) => {
+  internal_createSmoothMessage: (id: string) => {
     startAnimation: (speed?: number) => Promise<void>;
     stopAnimation: () => void;
     outputQueue: string[];
@@ -124,10 +123,10 @@ export interface ChatMessageAction {
    * @param id
    * @param content
    */
-  internalUpdateMessageContent: (id: string, content: string) => Promise<void>;
-  internalCreateMessage: (params: CreateMessageParams) => Promise<string>;
-  internalResendMessage: (id: string, traceId?: string) => Promise<void>;
-  internalTraceMessage: (id: string, payload: TraceEventPayloads) => Promise<void>;
+  internal_updateMessageContent: (id: string, content: string) => Promise<void>;
+  internal_createMessage: (params: CreateMessageParams) => Promise<string>;
+  internal_resendMessage: (id: string, traceId?: string) => Promise<void>;
+  internal_traceMessage: (id: string, payload: TraceEventPayloads) => Promise<void>;
 }
 
 const getAgentConfig = () => agentSelectors.currentAgentConfig(useAgentStore.getState());
@@ -145,24 +144,24 @@ export const chatMessage: StateCreator<
   ChatMessageAction
 > = (set, get) => ({
   deleteMessage: async (id) => {
-    get().dispatchMessage({ type: 'deleteMessage', id });
+    get().internal_dispatchMessage({ type: 'deleteMessage', id });
     await messageService.removeMessage(id);
     await get().refreshMessages();
   },
   delAndRegenerateMessage: async (id) => {
     const traceId = chatSelectors.getTraceIdByMessageId(id)(get());
-    get().internalResendMessage(id, traceId);
+    get().internal_resendMessage(id, traceId);
     get().deleteMessage(id);
 
     // trace the delete and regenerate message
-    get().internalTraceMessage(id, { eventType: TraceEventType.DeleteAndRegenerateMessage });
+    get().internal_traceMessage(id, { eventType: TraceEventType.DeleteAndRegenerateMessage });
   },
   regenerateMessage: async (id: string) => {
     const traceId = chatSelectors.getTraceIdByMessageId(id)(get());
-    await get().internalResendMessage(id, traceId);
+    await get().internal_resendMessage(id, traceId);
 
     // trace the delete and regenerate message
-    get().internalTraceMessage(id, { eventType: TraceEventType.RegenerateMessage });
+    get().internal_traceMessage(id, { eventType: TraceEventType.RegenerateMessage });
   },
   clearMessage: async () => {
     const { activeId, activeTopicId, refreshMessages, refreshTopic, switchTopic } = get();
@@ -184,7 +183,7 @@ export const chatMessage: StateCreator<
     await refreshMessages();
   },
   sendMessage: async ({ message, files, onlyAddUserMessage, isWelcomeQuestion }) => {
-    const { coreProcessMessage, activeTopicId, activeId } = get();
+    const { internal_coreProcessMessage, activeTopicId, activeId } = get();
     if (!activeId) return;
 
     const fileIdList = files?.map((f) => f.id);
@@ -202,7 +201,7 @@ export const chatMessage: StateCreator<
       topicId: activeTopicId,
     };
 
-    const id = await get().internalCreateMessage(newMessage);
+    const id = await get().internal_createMessage(newMessage);
 
     // if only add user message, then stop
     if (onlyAddUserMessage) return;
@@ -210,7 +209,7 @@ export const chatMessage: StateCreator<
     // Get the current messages to generate AI response
     const messages = chatSelectors.currentChats(get());
 
-    await coreProcessMessage(messages, id, { isWelcomeQuestion });
+    await internal_coreProcessMessage(messages, id, { isWelcomeQuestion });
 
     // check activeTopic and then auto create topic
     const chats = chatSelectors.currentChats(get());
@@ -226,11 +225,11 @@ export const chatMessage: StateCreator<
     }
   },
   addAIMessage: async () => {
-    const { internalCreateMessage, updateInputMessage, activeTopicId, activeId, inputMessage } =
+    const { internal_createMessage, updateInputMessage, activeTopicId, activeId, inputMessage } =
       get();
     if (!activeId) return;
 
-    await internalCreateMessage({
+    await internal_createMessage({
       content: inputMessage,
       role: 'assistant',
       sessionId: activeId,
@@ -243,16 +242,16 @@ export const chatMessage: StateCreator<
   copyMessage: async (id, content) => {
     await copyToClipboard(content);
 
-    get().internalTraceMessage(id, { eventType: TraceEventType.CopyMessage });
+    get().internal_traceMessage(id, { eventType: TraceEventType.CopyMessage });
   },
 
   stopGenerateMessage: () => {
-    const { abortController, toggleChatLoading } = get();
+    const { abortController, internal_toggleChatLoading } = get();
     if (!abortController) return;
 
     abortController.abort();
 
-    toggleChatLoading(false, undefined, n('stopGenerateMessage') as string);
+    internal_toggleChatLoading(false, undefined, n('stopGenerateMessage') as string);
   },
   updateInputMessage: (message) => {
     set({ inputMessage: message }, false, n('updateInputMessage', message));
@@ -260,12 +259,12 @@ export const chatMessage: StateCreator<
   modifyMessageContent: async (id, content) => {
     // tracing the diff of update
     // due to message content will change, so we need send trace before update,or will get wrong data
-    get().internalTraceMessage(id, {
+    get().internal_traceMessage(id, {
       eventType: TraceEventType.ModifyMessage,
       nextContent: content,
     });
 
-    await get().internalUpdateMessageContent(id, content);
+    await get().internal_updateMessageContent(id, content);
   },
   useFetchMessages: (sessionId, activeTopicId) =>
     useClientDataSWR<ChatMessage[]>(
@@ -292,8 +291,9 @@ export const chatMessage: StateCreator<
   },
 
   // the internal process method of the AI message
-  coreProcessMessage: async (messages, userMessageId, params) => {
-    const { fetchAIChatMessage, triggerFunctionCall, refreshMessages, activeTopicId } = get();
+  internal_coreProcessMessage: async (messages, userMessageId, params) => {
+    const { internal_fetchAIChatMessage, triggerFunctionCall, refreshMessages, activeTopicId } =
+      get();
 
     const { model, provider } = getAgentConfig();
 
@@ -309,11 +309,11 @@ export const chatMessage: StateCreator<
       topicId: activeTopicId, // if there is activeTopicId，then add it to topicId
     };
 
-    const mid = await get().internalCreateMessage(assistantMessage);
+    const mid = await get().internal_createMessage(assistantMessage);
 
     // 2. fetch the AI response
     const { isFunctionCall, content, functionCallAtEnd, functionCallContent, traceId } =
-      await fetchAIChatMessage(messages, mid, params);
+      await internal_fetchAIChatMessage(messages, mid, params);
 
     // 3. if it's the function call message, trigger the function method
     if (isFunctionCall) {
@@ -323,7 +323,7 @@ export const chatMessage: StateCreator<
       if (functionCallAtEnd) {
         // create a new separate message and remove the function call from the prev message
 
-        await get().internalUpdateMessageContent(mid, content.replace(functionCallContent, ''));
+        await get().internal_updateMessageContent(mid, content.replace(functionCallContent, ''));
 
         const functionMessage: CreateMessageParams = {
           role: 'function',
@@ -337,14 +337,14 @@ export const chatMessage: StateCreator<
           traceId,
         };
 
-        functionId = await get().internalCreateMessage(functionMessage);
+        functionId = await get().internal_createMessage(functionMessage);
       }
 
       await refreshMessages();
       await triggerFunctionCall(functionId);
     }
   },
-  dispatchMessage: (payload) => {
+  internal_dispatchMessage: (payload) => {
     const { activeId } = get();
 
     if (!activeId) return;
@@ -353,16 +353,16 @@ export const chatMessage: StateCreator<
 
     set({ messages }, false, n(`dispatchMessage/${payload.type}`, payload));
   },
-  fetchAIChatMessage: async (messages, assistantId, params) => {
+  internal_fetchAIChatMessage: async (messages, assistantId, params) => {
     const {
-      toggleChatLoading,
+      internal_toggleChatLoading,
       refreshMessages,
-      internalUpdateMessageContent,
-      dispatchMessage,
-      createSmoothMessage,
+      internal_updateMessageContent,
+      internal_dispatchMessage,
+      internal_createSmoothMessage,
     } = get();
 
-    const abortController = toggleChatLoading(
+    const abortController = internal_toggleChatLoading(
       true,
       assistantId,
       n('generateMessage(start)', { assistantId, messages }) as string,
@@ -421,7 +421,7 @@ export const chatMessage: StateCreator<
     let msgTraceId: string | undefined;
 
     const { startAnimation, stopAnimation, outputQueue, isAnimationActive } =
-      createSmoothMessage(assistantId);
+      internal_createSmoothMessage(assistantId);
 
     await chatService.createAssistantMessageStream({
       abortController,
@@ -465,7 +465,7 @@ export const chatMessage: StateCreator<
         }
 
         // update the content after fetch result
-        await internalUpdateMessageContent(assistantId, content);
+        await internal_updateMessageContent(assistantId, content);
       },
       onMessageHandle: async (text) => {
         output += text;
@@ -474,7 +474,7 @@ export const chatMessage: StateCreator<
         // is this message is just a function call
         if (isFunctionMessageAtStart(output)) {
           stopAnimation();
-          dispatchMessage({
+          internal_dispatchMessage({
             id: assistantId,
             key: 'content',
             type: 'updateMessage',
@@ -490,7 +490,7 @@ export const chatMessage: StateCreator<
       },
     });
 
-    toggleChatLoading(false, undefined, n('generateMessage(end)') as string);
+    internal_toggleChatLoading(false, undefined, n('generateMessage(end)') as string);
 
     // also exist message like this:
     // 请稍等，我帮您查询一下。{"tool_calls":[{"id":"call_sbca","type":"function","function":{"name":"pluginName____apiName","arguments":{"key":"value"}}}]}
@@ -513,7 +513,7 @@ export const chatMessage: StateCreator<
       traceId: msgTraceId,
     };
   },
-  toggleChatLoading: (loading, id, action) => {
+  internal_toggleChatLoading: (loading, id, action) => {
     if (loading) {
       window.addEventListener('beforeunload', preventLeavingFn);
 
@@ -527,7 +527,7 @@ export const chatMessage: StateCreator<
       window.removeEventListener('beforeunload', preventLeavingFn);
     }
   },
-  toggleMessageLoading: (loading, id) => {
+  internal_toggleMessageLoading: (loading, id) => {
     set(
       {
         messageLoadingIds: produce(get().messageLoadingIds, (draft) => {
@@ -541,11 +541,11 @@ export const chatMessage: StateCreator<
         }),
       },
       false,
-      'toggleMessageLoading',
+      'internal_toggleMessageLoading',
     );
   },
 
-  internalResendMessage: async (messageId, traceId) => {
+  internal_resendMessage: async (messageId, traceId) => {
     // 1. 构造所有相关的历史记录
     const chats = chatSelectors.currentChats(get());
 
@@ -574,45 +574,45 @@ export const chatMessage: StateCreator<
 
     if (contextMessages.length <= 0) return;
 
-    const { coreProcessMessage } = get();
+    const { internal_coreProcessMessage } = get();
 
     const latestMsg = contextMessages.filter((s) => s.role === 'user').at(-1);
 
     if (!latestMsg) return;
 
-    await coreProcessMessage(contextMessages, latestMsg.id, { traceId });
+    await internal_coreProcessMessage(contextMessages, latestMsg.id, { traceId });
   },
 
-  internalUpdateMessageContent: async (id, content) => {
-    const { dispatchMessage, refreshMessages } = get();
+  internal_updateMessageContent: async (id, content) => {
+    const { internal_dispatchMessage, refreshMessages } = get();
 
     // Due to the async update method and refresh need about 100ms
     // we need to update the message content at the frontend to avoid the update flick
     // refs: https://medium.com/@kyledeguzmanx/what-are-optimistic-updates-483662c3e171
-    dispatchMessage({ id, key: 'content', type: 'updateMessage', value: content });
+    internal_dispatchMessage({ id, key: 'content', type: 'updateMessage', value: content });
 
     await messageService.updateMessage(id, { content });
     await refreshMessages();
   },
 
-  internalCreateMessage: async (message) => {
-    const { dispatchMessage, refreshMessages, toggleMessageLoading } = get();
+  internal_createMessage: async (message) => {
+    const { internal_dispatchMessage, refreshMessages, internal_toggleMessageLoading } = get();
 
     // use optimistic update to avoid the slow waiting
     const tempId = 'tmp_' + nanoid();
-    dispatchMessage({ type: 'createMessage', id: tempId, value: message });
+    internal_dispatchMessage({ type: 'createMessage', id: tempId, value: message });
 
-    toggleMessageLoading(true, tempId);
+    internal_toggleMessageLoading(true, tempId);
     const id = await messageService.createMessage(message);
 
     await refreshMessages();
-    toggleMessageLoading(false, tempId);
+    internal_toggleMessageLoading(false, tempId);
 
     return id;
   },
 
-  createSmoothMessage: (id) => {
-    const { dispatchMessage } = get();
+  internal_createSmoothMessage: (id) => {
+    const { internal_dispatchMessage } = get();
 
     let buffer = '';
     // why use queue: https://shareg.pt/GLBrjpK
@@ -658,7 +658,7 @@ export const chatMessage: StateCreator<
             buffer += charsToAdd;
 
             // 更新消息内容，这里可能需要结合实际情况调整
-            dispatchMessage({ id, key: 'content', type: 'updateMessage', value: buffer });
+            internal_dispatchMessage({ id, key: 'content', type: 'updateMessage', value: buffer });
 
             // 设置下一个字符的延迟
             animationTimeoutId = setTimeout(updateText, 16); // 16 毫秒的延迟模拟打字机效果
@@ -676,7 +676,7 @@ export const chatMessage: StateCreator<
     return { startAnimation, stopAnimation, outputQueue, isAnimationActive };
   },
 
-  internalTraceMessage: async (id, payload) => {
+  internal_traceMessage: async (id, payload) => {
     // tracing the diff of update
     const message = chatSelectors.getMessageById(id)(get());
     if (!message) return;

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

@@ -37,7 +37,7 @@ describe('ChatPluginAction', () => {
       // 设置初始状态
       const initialState = {
         messages: [],
-        coreProcessMessage: vi.fn(),
+        internal_coreProcessMessage: vi.fn(),
         refreshMessages: vi.fn(),
       };
       useChatStore.setState(initialState);
@@ -51,14 +51,14 @@ describe('ChatPluginAction', () => {
         await result.current.fillPluginMessageContent(messageId, newContent, true);
       });
 
-      // 验证 messageService.internalUpdateMessageContent 是否被正确调用
+      // 验证 messageService.internal_updateMessageContent 是否被正确调用
       expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { content: newContent });
 
       // 验证 refreshMessages 是否被调用
       expect(result.current.refreshMessages).toHaveBeenCalled();
 
       // 验证 coreProcessMessage 是否被正确调用
-      expect(result.current.coreProcessMessage).toHaveBeenCalledWith(
+      expect(result.current.internal_coreProcessMessage).toHaveBeenCalledWith(
         mockCurrentChats,
         messageId,
         {},
@@ -86,14 +86,14 @@ describe('ChatPluginAction', () => {
         await result.current.fillPluginMessageContent(messageId, newContent);
       });
 
-      // 验证 messageService.internalUpdateMessageContent 是否被正确调用
+      // 验证 messageService.internal_updateMessageContent 是否被正确调用
       expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { content: newContent });
 
       // 验证 refreshMessages 是否被调用
       expect(result.current.refreshMessages).toHaveBeenCalled();
 
       // 验证 coreProcessMessage 没有被正确调用
-      expect(result.current.coreProcessMessage).not.toHaveBeenCalled();
+      expect(result.current.internal_coreProcessMessage).not.toHaveBeenCalled();
     });
   });
 
@@ -107,7 +107,7 @@ describe('ChatPluginAction', () => {
 
       vi.spyOn(storeState, 'refreshMessages');
       vi.spyOn(storeState, 'triggerAIMessage').mockResolvedValue(undefined);
-      vi.spyOn(storeState, 'toggleChatLoading').mockReturnValue(undefined);
+      vi.spyOn(storeState, 'internal_toggleChatLoading').mockReturnValue(undefined);
 
       const runSpy = vi.spyOn(chatService, 'runPluginApi').mockResolvedValue({
         text: pluginApiResponse,
@@ -120,7 +120,7 @@ describe('ChatPluginAction', () => {
         await result.current.invokeDefaultTypePlugin(messageId, pluginPayload);
       });
 
-      expect(storeState.toggleChatLoading).toHaveBeenCalledWith(
+      expect(storeState.internal_toggleChatLoading).toHaveBeenCalledWith(
         true,
         messageId,
         expect.any(String),
@@ -131,7 +131,7 @@ describe('ChatPluginAction', () => {
       });
       expect(storeState.refreshMessages).toHaveBeenCalled();
       expect(storeState.triggerAIMessage).toHaveBeenCalled();
-      expect(storeState.toggleChatLoading).toHaveBeenCalledWith(false);
+      expect(storeState.internal_toggleChatLoading).toHaveBeenCalledWith(false);
     });
 
     it('should handle errors when the plugin API call fails', async () => {
@@ -142,7 +142,7 @@ describe('ChatPluginAction', () => {
       const storeState = useChatStore.getState();
       vi.spyOn(storeState, 'refreshMessages');
       vi.spyOn(storeState, 'triggerAIMessage').mockResolvedValue(undefined);
-      vi.spyOn(storeState, 'toggleChatLoading').mockReturnValue(undefined);
+      vi.spyOn(storeState, 'internal_toggleChatLoading').mockReturnValue(undefined);
 
       vi.spyOn(chatService, 'runPluginApi').mockRejectedValue(error);
 
@@ -151,7 +151,7 @@ describe('ChatPluginAction', () => {
         await result.current.invokeDefaultTypePlugin(messageId, pluginPayload);
       });
 
-      expect(storeState.toggleChatLoading).toHaveBeenCalledWith(
+      expect(storeState.internal_toggleChatLoading).toHaveBeenCalledWith(
         true,
         messageId,
         expect.any(String),
@@ -159,7 +159,7 @@ describe('ChatPluginAction', () => {
       expect(chatService.runPluginApi).toHaveBeenCalledWith(pluginPayload, { trace: {} });
       expect(messageService.updateMessageError).toHaveBeenCalledWith(messageId, error);
       expect(storeState.refreshMessages).toHaveBeenCalled();
-      expect(storeState.toggleChatLoading).toHaveBeenCalledWith(false);
+      expect(storeState.internal_toggleChatLoading).toHaveBeenCalledWith(false);
       expect(storeState.triggerAIMessage).not.toHaveBeenCalled(); // 确保在错误情况下不调用此方法
     });
   });
@@ -512,8 +512,8 @@ describe('ChatPluginAction', () => {
       });
 
       useChatStore.setState({
-        toggleChatLoading: vi.fn(),
-        internalUpdateMessageContent: vi.fn(),
+        internal_toggleChatLoading: vi.fn(),
+        internal_updateMessageContent: vi.fn(),
         text2image: vi.fn(),
       });
 
@@ -530,18 +530,18 @@ describe('ChatPluginAction', () => {
       );
 
       // Verify that the message content was updated with the tool response
-      expect(result.current.internalUpdateMessageContent).toHaveBeenCalledWith(
+      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
         messageId,
         toolResponse,
       );
 
       // Verify that loading was toggled correctly
-      expect(result.current.toggleChatLoading).toHaveBeenCalledWith(
+      expect(result.current.internal_toggleChatLoading).toHaveBeenCalledWith(
         true,
         messageId,
         expect.any(String),
       );
-      expect(result.current.toggleChatLoading).toHaveBeenCalledWith(false);
+      expect(result.current.internal_toggleChatLoading).toHaveBeenCalledWith(false);
       expect(useChatStore.getState().text2image).toHaveBeenCalled();
     });
 
@@ -561,9 +561,9 @@ describe('ChatPluginAction', () => {
         });
 
         useChatStore.setState({
-          toggleChatLoading: vi.fn(),
+          internal_toggleChatLoading: vi.fn(),
           text2image: vi.fn(),
-          internalUpdateMessageContent: vi.fn(),
+          internal_updateMessageContent: vi.fn(),
         });
       });
       const { result } = renderHook(() => useChatStore());
@@ -579,18 +579,18 @@ describe('ChatPluginAction', () => {
       );
 
       // Verify that the message content was updated with the tool response
-      expect(result.current.internalUpdateMessageContent).toHaveBeenCalledWith(
+      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
         messageId,
         toolResponse,
       );
 
       // Verify that loading was toggled correctly
-      expect(result.current.toggleChatLoading).toHaveBeenCalledWith(
+      expect(result.current.internal_toggleChatLoading).toHaveBeenCalledWith(
         true,
         messageId,
         expect.any(String),
       );
-      expect(result.current.toggleChatLoading).toHaveBeenCalledWith(false);
+      expect(result.current.internal_toggleChatLoading).toHaveBeenCalledWith(false);
       expect(useChatStore.getState().text2image).not.toHaveBeenCalled();
     });
 
@@ -608,8 +608,8 @@ describe('ChatPluginAction', () => {
       });
 
       useChatStore.setState({
-        toggleChatLoading: vi.fn(),
-        internalUpdateMessageContent: vi.fn(),
+        internal_toggleChatLoading: vi.fn(),
+        internal_updateMessageContent: vi.fn(),
         text2image: vi.fn(),
         refreshMessages: vi.fn(),
       });
@@ -621,15 +621,15 @@ describe('ChatPluginAction', () => {
       });
 
       // Verify that loading was toggled correctly
-      expect(result.current.toggleChatLoading).toHaveBeenCalledWith(
+      expect(result.current.internal_toggleChatLoading).toHaveBeenCalledWith(
         true,
         messageId,
         expect.any(String),
       );
-      expect(result.current.toggleChatLoading).toHaveBeenCalledWith(false);
+      expect(result.current.internal_toggleChatLoading).toHaveBeenCalledWith(false);
 
       // Verify that the message content was not updated
-      expect(result.current.internalUpdateMessageContent).not.toHaveBeenCalled();
+      expect(result.current.internal_updateMessageContent).not.toHaveBeenCalled();
 
       // Verify that messages were not refreshed
       expect(result.current.refreshMessages).not.toHaveBeenCalled();

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

@@ -54,28 +54,28 @@ export const chatPlugin: StateCreator<
   },
 
   fillPluginMessageContent: async (id, content, triggerAiMessage) => {
-    const { triggerAIMessage, internalUpdateMessageContent } = get();
+    const { triggerAIMessage, internal_updateMessageContent } = get();
 
-    await internalUpdateMessageContent(id, content);
+    await internal_updateMessageContent(id, content);
 
     if (triggerAiMessage) await triggerAIMessage(id);
   },
 
   invokeBuiltinTool: async (id, payload) => {
-    const { toggleChatLoading, internalUpdateMessageContent } = get();
+    const { internal_toggleChatLoading, internal_updateMessageContent } = get();
     const params = JSON.parse(payload.arguments);
-    toggleChatLoading(true, id, n('invokeBuiltinTool') as string);
+    internal_toggleChatLoading(true, id, n('invokeBuiltinTool') as string);
     let data;
     try {
       data = await useToolStore.getState().invokeBuiltinTool(payload.apiName, params);
     } catch (error) {
       console.log(error);
     }
-    toggleChatLoading(false);
+    internal_toggleChatLoading(false);
 
     if (!data) return;
 
-    await internalUpdateMessageContent(id, data);
+    await internal_updateMessageContent(id, data);
 
     // postToolCalling
     // @ts-ignore
@@ -131,11 +131,11 @@ export const chatPlugin: StateCreator<
   },
 
   runPluginApi: async (id, payload) => {
-    const { internalUpdateMessageContent, refreshMessages, toggleChatLoading } = get();
+    const { internal_updateMessageContent, refreshMessages, internal_toggleChatLoading } = get();
     let data: string;
 
     try {
-      const abortController = toggleChatLoading(true, id, n('fetchPlugin') as string);
+      const abortController = internal_toggleChatLoading(true, id, n('fetchPlugin') as string);
 
       const message = chatSelectors.getMessageById(id)(get());
 
@@ -162,19 +162,19 @@ export const chatPlugin: StateCreator<
       data = '';
     }
 
-    toggleChatLoading(false);
+    internal_toggleChatLoading(false);
     // 如果报错则结束了
     if (!data) return;
 
-    await internalUpdateMessageContent(id, data);
+    await internal_updateMessageContent(id, data);
 
     return data;
   },
 
   triggerAIMessage: async (id, traceId) => {
-    const { coreProcessMessage } = get();
+    const { internal_coreProcessMessage } = get();
     const chats = chatSelectors.currentChats(get());
-    await coreProcessMessage(chats, id, { traceId });
+    await internal_coreProcessMessage(chats, id, { traceId });
   },
 
   triggerFunctionCall: async (id) => {
@@ -187,7 +187,7 @@ export const chatPlugin: StateCreator<
       invokeStandaloneTypePlugin,
       invokeBuiltinTool,
       refreshMessages,
-      internalResendMessage,
+      internal_resendMessage,
       deleteMessage,
     } = get();
 
@@ -213,7 +213,7 @@ export const chatPlugin: StateCreator<
 
       // fix https://github.com/lobehub/lobe-chat/issues/1094, remove and retry after experiencing plugin illusion
       if (!apiName) {
-        internalResendMessage(id);
+        internal_resendMessage(id);
         deleteMessage(id);
         return;
       }

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

@@ -60,7 +60,7 @@ describe('chatToolSlice', () => {
         draft[0].previewUrl = 'new-url';
         draft[0].imageId = 'new-id';
       };
-      vi.spyOn(result.current, 'internalUpdateMessageContent');
+      vi.spyOn(result.current, 'internal_updateMessageContent');
 
       // 模拟 getMessageById 返回消息内容
       vi.spyOn(chatSelectors, 'getMessageById').mockImplementationOnce(
@@ -75,8 +75,8 @@ describe('chatToolSlice', () => {
         await result.current.updateImageItem(messageId, updateFunction);
       });
 
-      // 验证 internalUpdateMessageContent 是否被正确调用以更新内容
-      expect(result.current.internalUpdateMessageContent).toHaveBeenCalledWith(
+      // 验证 internal_updateMessageContent 是否被正确调用以更新内容
+      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
         messageId,
         JSON.stringify([{ prompt: 'test prompt', previewUrl: 'new-url', imageId: 'new-id' }]),
       );

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

@@ -81,6 +81,6 @@ export const chatToolSlice: StateCreator<
     const data: DallEImageItem[] = JSON.parse(message.content);
 
     const nextContent = produce(data, updater);
-    await get().internalUpdateMessageContent(id, JSON.stringify(nextContent));
+    await get().internal_updateMessageContent(id, JSON.stringify(nextContent));
   },
 });