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

package/src/store/chat/slices/aiChat/actions/generateAIChat.ts

@@ -11,25 +11,24 @@ import {
   TraceNameMap,
   UIChatMessage,
 } from '@lobechat/types';
+import isEqual from 'fast-deep-equal';
 import { t } from 'i18next';
 import { produce } from 'immer';
+import { throttle } from 'lodash-es';
 import { StateCreator } from 'zustand/vanilla';
 
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
-import { useAgentStore } from '@/store/agent';
 import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
 import { getAgentStoreState } from '@/store/agent/store';
 import { aiModelSelectors, aiProviderSelectors } from '@/store/aiInfra';
 import { getAiInfraStoreState } from '@/store/aiInfra/store';
 import { ChatStore } from '@/store/chat/store';
-import { messageMapKey } from '@/store/chat/utils/messageMapKey';
 import { getFileStoreState } from '@/store/file/store';
-import { useSessionStore } from '@/store/session';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
 import { Action, setNamespace } from '@/utils/storeDebug';
 
-import { chatSelectors, topicSelectors } from '../../../selectors';
+import { chatSelectors, messageStateSelectors, topicSelectors } from '../../../selectors';
 
 const n = setNamespace('ai');
 
@@ -158,13 +157,7 @@ export const generateAIChat: StateCreator<
   },
 
   sendMessage: async ({ message, files, onlyAddUserMessage, isWelcomeQuestion }) => {
-    const {
-      internal_coreProcessMessage,
-      activeTopicId,
-      activeId,
-      activeThreadId,
-      sendMessageInServer,
-    } = get();
+    const { activeId, sendMessageInServer } = get();
     if (!activeId) return;
 
     const fileIdList = files?.map((f) => f.id);
@@ -177,134 +170,6 @@ export const generateAIChat: StateCreator<
     // router to server mode send message
     if (isServerMode)
       return sendMessageInServer({ message, files, onlyAddUserMessage, isWelcomeQuestion });
-
-    set({ isCreatingMessage: true }, false, n('creatingMessage/start'));
-
-    const newMessage: CreateMessageParams = {
-      content: message,
-      // if message has attached with files, then add files to message and the agent
-      files: fileIdList,
-      role: 'user',
-      sessionId: activeId,
-      // if there is activeTopicId，then add topicId to message
-      topicId: activeTopicId,
-      threadId: activeThreadId,
-    };
-
-    const agentConfig = agentChatConfigSelectors.currentChatConfig(getAgentStoreState());
-
-    let tempMessageId: string | undefined = undefined;
-    let newTopicId: string | undefined = undefined;
-
-    // it should be the default topic, then
-    // if autoCreateTopic is enabled, check to whether we need to create a topic
-    if (!onlyAddUserMessage && !activeTopicId && agentConfig.enableAutoCreateTopic) {
-      // check activeTopic and then auto create topic
-      const chats = chatSelectors.activeBaseChats(get());
-
-      // we will add two messages (user and assistant), so the finial length should +2
-      const featureLength = chats.length + 2;
-
-      // if there is no activeTopicId and the feature length is greater than the threshold
-      // then create a new topic and active it
-      if (!activeTopicId && featureLength >= agentConfig.autoCreateTopicThreshold) {
-        // we need to create a temp message for optimistic update
-        tempMessageId = get().internal_createTmpMessage(newMessage);
-        get().internal_toggleMessageLoading(true, tempMessageId);
-
-        const topicId = await get().createTopic();
-
-        if (topicId) {
-          newTopicId = topicId;
-          newMessage.topicId = topicId;
-
-          // we need to copy the messages to the new topic or the message will disappear
-          const mapKey = chatSelectors.currentChatKey(get());
-          const newMaps = {
-            ...get().messagesMap,
-            [messageMapKey(activeId, topicId)]: get().messagesMap[mapKey],
-          };
-          set({ messagesMap: newMaps }, false, n('moveMessagesToNewTopic'));
-
-          // make the topic loading
-          get().internal_updateTopicLoading(topicId, true);
-        }
-      }
-    }
-    //  update assistant update to make it rerank
-    useSessionStore.getState().triggerSessionUpdate(get().activeId);
-
-    const id = await get().internal_createMessage(newMessage, {
-      tempMessageId,
-      skipRefresh: !onlyAddUserMessage && newMessage.fileList?.length === 0,
-    });
-
-    if (!id) {
-      set({ isCreatingMessage: false }, false, n('creatingMessage/start'));
-      if (!!newTopicId) get().internal_updateTopicLoading(newTopicId, false);
-      return;
-    }
-
-    if (tempMessageId) get().internal_toggleMessageLoading(false, tempMessageId);
-
-    // switch to the new topic if create the new topic
-    if (!!newTopicId) {
-      await get().switchTopic(newTopicId, true);
-      await get().internal_fetchMessages();
-
-      // delete previous messages
-      // remove the temp message map
-      const newMaps = { ...get().messagesMap, [messageMapKey(activeId, null)]: [] };
-      set({ messagesMap: newMaps }, false, 'internal_copyMessages');
-    }
-
-    // if only add user message, then stop
-    if (onlyAddUserMessage) {
-      set({ isCreatingMessage: false }, false, 'creatingMessage/start');
-      return;
-    }
-
-    // Get the current messages to generate AI response
-    const messages = chatSelectors.activeBaseChats(get());
-    const userFiles = chatSelectors.currentUserFiles(get()).map((f) => f.id);
-
-    await internal_coreProcessMessage(messages, id, {
-      isWelcomeQuestion,
-      ragQuery: get().internal_shouldUseRAG() ? message : undefined,
-      threadId: activeThreadId,
-    });
-
-    set({ isCreatingMessage: false }, false, n('creatingMessage/stop'));
-
-    const summaryTitle = async () => {
-      // if autoCreateTopic is false, then stop
-      if (!agentConfig.enableAutoCreateTopic) return;
-
-      // check activeTopic and then auto update topic title
-      if (newTopicId) {
-        const chats = chatSelectors.getBaseChatsByKey(messageMapKey(activeId, newTopicId))(get());
-        await get().summaryTopicTitle(newTopicId, chats);
-        return;
-      }
-
-      if (!activeTopicId) return;
-      const topic = topicSelectors.getTopicById(activeTopicId)(get());
-
-      if (topic && !topic.title) {
-        const chats = chatSelectors.getBaseChatsByKey(messageMapKey(activeId, topic.id))(get());
-        await get().summaryTopicTitle(topic.id, chats);
-      }
-    };
-
-    // if there is relative files, then add files to agent
-    // only available in server mode
-    const addFilesToAgent = async () => {
-      if (userFiles.length === 0 || !isServerMode) return;
-
-      await useAgentStore.getState().addFilesToAgent(userFiles, false);
-    };
-
-    await Promise.all([summaryTitle(), addFilesToAgent()]);
   },
   stopGenerateMessage: () => {
     const { chatLoadingIdsAbortController, internal_toggleChatLoading } = get();
@@ -579,6 +444,19 @@ export const generateAIChat: StateCreator<
     // to upload image
     const uploadTasks: Map<string, Promise<{ id?: string; url?: string }>> = new Map();
 
+    // Throttle tool_calls updates to prevent excessive re-renders (max once per 300ms)
+    const throttledUpdateToolCalls = throttle(
+      (toolCalls: any[]) => {
+        internal_dispatchMessage({
+          id: messageId,
+          type: 'updateMessage',
+          value: { tools: get().internal_transformToolCalls(toolCalls) },
+        });
+      },
+      300,
+      { leading: true, trailing: true },
+    );
+
     const historySummary = chatConfig.enableCompressHistory
       ? topicSelectors.currentActiveTopicSummary(get())
       : undefined;
@@ -598,7 +476,6 @@ export const generateAIChat: StateCreator<
         topicId: get().activeTopicId,
         traceName: TraceNameMap.Conversation,
       },
-      isWelcomeQuestion: params?.isWelcomeQuestion,
       onErrorHandle: async (error) => {
         await messageService.updateMessageError(messageId, error);
         await refreshMessages();
@@ -633,6 +510,8 @@ export const generateAIChat: StateCreator<
 
         let parsedToolCalls = toolCalls;
         if (parsedToolCalls && parsedToolCalls.length > 0) {
+          // Flush any pending throttled updates before finalizing
+          throttledUpdateToolCalls.flush();
           internal_toggleToolCallingStreaming(messageId, undefined);
           parsedToolCalls = parsedToolCalls.map((item) => ({
             ...item,
@@ -644,6 +523,8 @@ export const generateAIChat: StateCreator<
           isFunctionCall = true;
         }
 
+        internal_toggleChatReasoning(false, messageId, n('toggleChatReasoning/false') as string);
+
         // update the content after fetch result
         await internal_updateMessageContent(messageId, content, {
           toolCalls: parsedToolCalls,
@@ -707,7 +588,8 @@ export const generateAIChat: StateCreator<
             if (!duration) {
               duration = Date.now() - thinkingStartAt;
 
-              const isInChatReasoning = chatSelectors.isMessageInChatReasoning(messageId)(get());
+              const isInChatReasoning =
+                messageStateSelectors.isMessageInChatReasoning(messageId)(get());
               if (isInChatReasoning) {
                 internal_toggleChatReasoning(
                   false,
@@ -752,12 +634,17 @@ export const generateAIChat: StateCreator<
           // is this message is just a tool call
           case 'tool_calls': {
             internal_toggleToolCallingStreaming(messageId, chunk.isAnimationActives);
-            internal_dispatchMessage({
-              id: messageId,
-              type: 'updateMessage',
-              value: { tools: get().internal_transformToolCalls(chunk.tool_calls) },
-            });
+            throttledUpdateToolCalls(chunk.tool_calls);
             isFunctionCall = true;
+            const isInChatReasoning =
+              messageStateSelectors.isMessageInChatReasoning(messageId)(get());
+            if (isInChatReasoning) {
+              internal_toggleChatReasoning(
+                false,
+                messageId,
+                n('toggleChatReasoning/false') as string,
+              );
+            }
           }
         }
       },
@@ -827,16 +714,19 @@ export const generateAIChat: StateCreator<
     return get().internal_toggleLoadingArrays('reasoningLoadingIds', loading, id, action);
   },
   internal_toggleToolCallingStreaming: (id, streaming) => {
+    const previous = get().toolCallingStreamIds;
+    const next = produce(previous, (draft) => {
+      if (!!streaming) {
+        draft[id] = streaming;
+      } else {
+        delete draft[id];
+      }
+    });
+
+    if (isEqual(previous, next)) return;
+
     set(
-      {
-        toolCallingStreamIds: produce(get().toolCallingStreamIds, (draft) => {
-          if (!!streaming) {
-            draft[id] = streaming;
-          } else {
-            delete draft[id];
-          }
-        }),
-      },
+      { toolCallingStreamIds: next },
 
       false,
       `toggleToolCallingStreaming/${!!streaming ? 'start' : 'end'}`,

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

@@ -2,14 +2,12 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { ChatStore } from '@/store/chat/store';
 
-import { ChatDallEAction, dalleSlice } from './dalle';
 import { ChatCodeInterpreterAction, codeInterpreterSlice } from './interpreter';
 import { LocalFileAction, localSystemSlice } from './localSystem';
 import { SearchAction, searchSlice } from './search';
 
 export interface ChatBuiltinToolAction
-  extends ChatDallEAction,
-    SearchAction,
+  extends SearchAction,
     LocalFileAction,
     ChatCodeInterpreterAction {}
 
@@ -19,7 +17,6 @@ export const chatToolSlice: StateCreator<
   [],
   ChatBuiltinToolAction
 > = (...params) => ({
-  ...dalleSlice(...params),
   ...searchSlice(...params),
   ...localSystemSlice(...params),
   ...codeInterpreterSlice(...params),

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

@@ -471,7 +471,11 @@ describe('chatMessage actions', () => {
         await result.current.internal_updateMessageContent(messageId, newContent);
       });
 
-      expect(spy).toHaveBeenCalledWith(messageId, { content: newContent });
+      expect(spy).toHaveBeenCalledWith(
+        messageId,
+        { content: newContent },
+        { sessionId: 'session-id', topicId: 'topic-id' },
+      );
     });
 
     it('should dispatch message update action', async () => {

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

@@ -6,6 +6,7 @@ import {
   ChatMessageError,
   ChatMessagePluginError,
   CreateMessageParams,
+  CreateNewMessageParams,
   GroundingSearch,
   MessageMetadata,
   MessageToolCall,
@@ -117,6 +118,14 @@ export interface ChatMessageAction {
    * otherwise the message will be too slow to show
    */
   internal_createTmpMessage: (params: CreateMessageParams) => string;
+  /**
+   * create a new message using createNewMessage API and return full message list
+   * used for group message scenarios to reduce network requests
+   */
+  internal_createNewMessage: (
+    params: CreateNewMessageParams,
+    context?: { tempMessageId?: string; groupMessageId?: string },
+  ) => Promise<{ id: string; messages: UIChatMessage[] } | undefined>;
   /**
    * delete the message content with optimistic update
    */
@@ -374,8 +383,16 @@ export const chatMessage: StateCreator<
 
   internal_updateMessageError: async (id, error) => {
     get().internal_dispatchMessage({ id, type: 'updateMessage', value: { error } });
-    await messageService.updateMessage(id, { error });
-    await get().refreshMessages();
+    const result = await messageService.updateMessage(
+      id,
+      { error },
+      { topicId: get().activeTopicId, sessionId: get().activeId },
+    );
+    if (result?.success && result.messages) {
+      get().replaceMessages(result.messages);
+    } else {
+      await get().refreshMessages();
+    }
   },
 
   internal_updateMessagePluginError: async (id, error) => {
@@ -384,7 +401,12 @@ export const chatMessage: StateCreator<
   },
 
   internal_updateMessageContent: async (id, content, extra) => {
-    const { internal_dispatchMessage, refreshMessages, internal_transformToolCalls } = get();
+    const {
+      internal_dispatchMessage,
+      refreshMessages,
+      internal_transformToolCalls,
+      replaceMessages,
+    } = 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
@@ -403,17 +425,26 @@ export const chatMessage: StateCreator<
       });
     }
 
-    await messageService.updateMessage(id, {
-      content,
-      tools: extra?.toolCalls ? internal_transformToolCalls(extra?.toolCalls) : undefined,
-      reasoning: extra?.reasoning,
-      search: extra?.search,
-      metadata: extra?.metadata,
-      model: extra?.model,
-      provider: extra?.provider,
-      imageList: extra?.imageList,
-    });
-    await refreshMessages();
+    const result = await messageService.updateMessage(
+      id,
+      {
+        content,
+        tools: extra?.toolCalls ? internal_transformToolCalls(extra?.toolCalls) : undefined,
+        reasoning: extra?.reasoning,
+        search: extra?.search,
+        metadata: extra?.metadata,
+        model: extra?.model,
+        provider: extra?.provider,
+        imageList: extra?.imageList,
+      },
+      { topicId: get().activeTopicId, sessionId: get().activeId },
+    );
+
+    if (result && result.success && result.messages) {
+      replaceMessages(result.messages);
+    } else {
+      await refreshMessages();
+    }
   },
 
   internal_createMessage: async (message, context) => {
@@ -473,6 +504,63 @@ export const chatMessage: StateCreator<
 
     return tempId;
   },
+
+  internal_createNewMessage: async (message, context) => {
+    const {
+      internal_createTmpMessage,
+      internal_toggleMessageLoading,
+      internal_dispatchMessage,
+      replaceMessages,
+    } = get();
+
+    let tempId = context?.tempMessageId;
+    if (!tempId) {
+      tempId = 'tmp_' + nanoid();
+
+      // Check if should add as group block (explicitly controlled by caller)
+      if (context?.groupMessageId) {
+        internal_dispatchMessage({
+          type: 'addGroupBlock',
+          groupMessageId: context.groupMessageId,
+          blockId: tempId,
+          value: {
+            id: tempId,
+            content: message.content,
+          },
+        });
+        internal_toggleMessageLoading(true, tempId);
+      } else {
+        // Regular message creation at top level
+        tempId = internal_createTmpMessage(message as any);
+        internal_toggleMessageLoading(true, tempId);
+      }
+    }
+
+    try {
+      // 使用 createNewMessage API
+      const result = await messageService.createNewMessage(message);
+
+      // 直接用返回的 messages 更新 store（已包含 group 结构）
+      replaceMessages(result.messages);
+
+      internal_toggleMessageLoading(false, tempId);
+      return result;
+    } catch (e) {
+      internal_toggleMessageLoading(false, tempId);
+      internal_dispatchMessage({
+        id: tempId,
+        type: 'updateMessage',
+        value: {
+          error: {
+            type: ChatErrorType.CreateMessageError,
+            message: (e as Error).message,
+            body: e,
+          },
+        },
+      });
+    }
+  },
+
   internal_deleteMessage: async (id: string) => {
     get().internal_dispatchMessage({ type: 'deleteMessage', id });
     await messageService.removeMessage(id);