@lobehub/lobehub 2.0.0-next.8 → 2.0.0-next.9

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

@@ -29,7 +29,7 @@ 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');
 
@@ -598,7 +598,6 @@ export const generateAIChat: StateCreator<
         topicId: get().activeTopicId,
         traceName: TraceNameMap.Conversation,
       },
-      isWelcomeQuestion: params?.isWelcomeQuestion,
       onErrorHandle: async (error) => {
         await messageService.updateMessageError(messageId, error);
         await refreshMessages();
@@ -707,7 +706,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,

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);

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

@@ -57,16 +57,131 @@ describe('messagesReducer', () => {
       expect(newState).toEqual(initialState);
     });
 
-    it('should not modify the state if the specified message does not exist', () => {
+    it('should update a block in group message children when id matches a block', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'Original block content',
+              tools: [
+                {
+                  id: 'tool1',
+                  identifier: 'search',
+                  apiName: 'search',
+                  type: 'builtin',
+                  arguments: '{"query": "test"}',
+                },
+              ],
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
       const payload: MessageDispatch = {
         type: 'updateMessage',
-        id: 'nonexistentMessage',
-        value: { content: 'Updated Message' },
+        id: 'block1',
+        value: { content: 'Updated block content' },
       };
 
-      const newState = messagesReducer(initialState, payload);
+      const newState = messagesReducer(stateWithGroup, payload);
+      const groupMessage = newState.find((m) => m.id === 'group1');
+      const block = groupMessage?.children?.find((b) => b.id === 'block1');
 
-      expect(newState).toEqual(initialState);
+      expect(block?.content).toBe('Updated block content');
+      expect(groupMessage?.updatedAt).toBeGreaterThan(1629264000000);
+    });
+
+    it('should update block tools in group message children', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'Block content',
+              tools: [
+                {
+                  id: 'tool1',
+                  identifier: 'search',
+                  apiName: 'search',
+                  type: 'builtin',
+                  arguments: '{"query": "test"}',
+                },
+              ],
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const newTools = [
+        {
+          id: 'tool1',
+          identifier: 'search',
+          apiName: 'search',
+          type: 'builtin',
+          arguments: '{"query": "updated"}',
+          result: {
+            id: 'result1',
+            content: 'Search result',
+          },
+        },
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'updateMessage',
+        id: 'block1',
+        value: { tools: newTools as any },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      const groupMessage = newState.find((m) => m.id === 'group1');
+      const block = groupMessage?.children?.find((b) => b.id === 'block1');
+
+      expect(block?.tools).toEqual(newTools);
+      expect(groupMessage?.updatedAt).toBeGreaterThan(1629264000000);
+    });
+
+    it('should not modify state when updating non-existent block in group message', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'Block content',
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'updateMessage',
+        id: 'nonexistentBlock',
+        value: { content: 'Updated content' },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      expect(newState).toEqual(stateWithGroup);
     });
   });
 
@@ -502,4 +617,247 @@ describe('messagesReducer', () => {
       expect(newState).toEqual(initialState);
     });
   });
+
+  describe('updateGroupBlockToolResult', () => {
+    it('should update a tool result in a group message block', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'Assistant response',
+              tools: [
+                {
+                  id: 'tool1',
+                  identifier: 'search',
+                  apiName: 'search',
+                  type: 'builtin',
+                  arguments: '{"query": "test"}',
+                  result: {
+                    id: 'result1',
+                    content: 'Initial result',
+                  },
+                },
+              ],
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'updateGroupBlockToolResult',
+        groupMessageId: 'group1',
+        blockId: 'block1',
+        toolId: 'tool1',
+        toolResult: {
+          id: 'result1',
+          content: 'Updated result content',
+          state: { foo: 'bar' },
+        },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      const groupMessage = newState.find((m) => m.id === 'group1');
+      const block = groupMessage?.children?.find((b) => b.id === 'block1');
+      const tool = block?.tools?.find((t) => t.id === 'tool1');
+
+      expect(tool?.result).toEqual({
+        id: 'result1',
+        content: 'Updated result content',
+        state: { foo: 'bar' },
+      });
+      expect(groupMessage?.updatedAt).toBeGreaterThan(1629264000000);
+    });
+
+    it('should not modify state if group message is not found', () => {
+      const payload: MessageDispatch = {
+        type: 'updateGroupBlockToolResult',
+        groupMessageId: 'nonexistent',
+        blockId: 'block1',
+        toolId: 'tool1',
+        toolResult: {
+          id: 'result1',
+          content: 'Updated result',
+        },
+      };
+
+      const newState = messagesReducer(initialState, payload);
+      expect(newState).toEqual(initialState);
+    });
+
+    it('should not modify state if block is not found', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'Assistant response',
+              tools: [],
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'updateGroupBlockToolResult',
+        groupMessageId: 'group1',
+        blockId: 'nonexistentBlock',
+        toolId: 'tool1',
+        toolResult: {
+          id: 'result1',
+          content: 'Updated result',
+        },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      expect(newState).toEqual(stateWithGroup);
+    });
+
+    it('should not modify state if tool is not found', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'Assistant response',
+              tools: [
+                {
+                  id: 'tool1',
+                  identifier: 'search',
+                  apiName: 'search',
+                  type: 'builtin',
+                  arguments: '{"query": "test"}',
+                },
+              ],
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'updateGroupBlockToolResult',
+        groupMessageId: 'group1',
+        blockId: 'block1',
+        toolId: 'nonexistentTool',
+        toolResult: {
+          id: 'result1',
+          content: 'Updated result',
+        },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      expect(newState).toEqual(stateWithGroup);
+    });
+  });
+
+  describe('addGroupBlock', () => {
+    it('should add a new block to group message children', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'First block',
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'addGroupBlock',
+        groupMessageId: 'group1',
+        blockId: 'block2',
+        value: {
+          id: 'block2',
+          content: 'Second block',
+        },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      const groupMessage = newState.find((m) => m.id === 'group1');
+
+      expect(groupMessage?.children).toHaveLength(2);
+      expect(groupMessage?.children?.[1]).toEqual({
+        id: 'block2',
+        content: 'Second block',
+      });
+      expect(groupMessage?.updatedAt).toBeGreaterThan(1629264000000);
+    });
+
+    it('should not modify state if group message is not found', () => {
+      const stateWithGroup: UIChatMessage[] = [
+        ...initialState,
+        {
+          id: 'group1',
+          role: 'group',
+          content: '',
+          createdAt: 1629264000000,
+          updatedAt: 1629264000000,
+          meta: {},
+          children: [
+            {
+              id: 'block1',
+              content: 'First block',
+            },
+          ],
+        } as UIChatMessage,
+      ];
+
+      const payload: MessageDispatch = {
+        type: 'addGroupBlock',
+        groupMessageId: 'nonexistentGroup',
+        blockId: 'block2',
+        value: {
+          id: 'block2',
+          content: 'Second block',
+        },
+      };
+
+      const newState = messagesReducer(stateWithGroup, payload);
+      expect(newState).toEqual(stateWithGroup);
+    });
+
+    it('should not modify state if message is not a group message', () => {
+      const payload: MessageDispatch = {
+        type: 'addGroupBlock',
+        groupMessageId: 'message1',
+        blockId: 'block2',
+        value: {
+          id: 'block2',
+          content: 'Second block',
+        },
+      };
+
+      const newState = messagesReducer(initialState, payload);
+      expect(newState).toEqual(initialState);
+    });
+  });
 });