@lobehub/lobehub 2.0.0-next.1 → 2.0.0-next.11

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

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

@@ -75,6 +75,29 @@ interface UpdateMessageExtra {
   value: any;
 }
 
+interface UpdateGroupBlockToolResult {
+  blockId: string;
+  groupMessageId: string;
+  toolId: string;
+  toolResult: {
+    content: string;
+    error?: any;
+    id: string;
+    state?: any;
+  };
+  type: 'updateGroupBlockToolResult';
+}
+
+interface AddGroupBlock {
+  blockId: string;
+  groupMessageId: string;
+  type: 'addGroupBlock';
+  value: {
+    content: string;
+    id: string;
+  };
+}
+
 export type MessageDispatch =
   | CreateMessage
   | UpdateMessage
@@ -86,7 +109,9 @@ export type MessageDispatch =
   | UpdateMessageTools
   | AddMessageTool
   | DeleteMessageTool
-  | DeleteMessages;
+  | DeleteMessages
+  | UpdateGroupBlockToolResult
+  | AddGroupBlock;
 
 export const messagesReducer = (
   state: UIChatMessage[],
@@ -96,10 +121,27 @@ export const messagesReducer = (
     case 'updateMessage': {
       return produce(state, (draftState) => {
         const { id, value } = payload;
+
+        // First, try to find in top-level messages
         const index = draftState.findIndex((i) => i.id === id);
-        if (index < 0) return;
+        if (index >= 0) {
+          draftState[index] = merge(draftState[index], { ...value, updatedAt: Date.now() });
+          return;
+        }
 
-        draftState[index] = merge(draftState[index], { ...value, updatedAt: Date.now() });
+        // If not found, search in group message children (blocks)
+        for (const message of draftState) {
+          if (message.role === 'group' && message.children) {
+            const blockIndex = message.children.findIndex((block) => block.id === id);
+            if (blockIndex >= 0) {
+              message.children[blockIndex] = merge(message.children[blockIndex], {
+                ...value,
+              });
+              message.updatedAt = Date.now();
+              return;
+            }
+          }
+        }
       });
     }
 
@@ -226,6 +268,48 @@ export const messagesReducer = (
         });
       });
     }
+
+    case 'updateGroupBlockToolResult': {
+      return produce(state, (draftState) => {
+        const { groupMessageId, blockId, toolId, toolResult } = payload;
+
+        // Find the group message
+        const msg = draftState.find((m) => m.id === groupMessageId);
+        if (!msg || msg.role !== 'group' || !msg.children) return;
+
+        // Find the block within children
+        const block = msg.children.find((b) => b.id === blockId);
+        if (!block || !block.tools) return;
+
+        // Find the tool and update its result
+        const tool = block.tools.find((t) => t.id === toolId);
+        if (!tool) return;
+
+        // Update tool result (optimistic update)
+        tool.result = toolResult;
+
+        msg.updatedAt = Date.now();
+      });
+    }
+
+    case 'addGroupBlock': {
+      return produce(state, (draftState) => {
+        const { groupMessageId, blockId, value } = payload;
+
+        // Find the group message
+        const msg = draftState.find((m) => m.id === groupMessageId);
+        if (!msg || msg.role !== 'group' || !msg.children) return;
+
+        // Add new block to children
+        msg.children.push({
+          content: value.content,
+          id: blockId,
+        });
+
+        msg.updatedAt = Date.now();
+      });
+    }
+
     default: {
       throw new Error('暂未实现的 type，请检查 reducer');
     }