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

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

package/src/store/chat/slices/message/{selectors.test.ts → selectors/chat.test.ts}

@@ -12,7 +12,7 @@ import { messageMapKey } from '@/store/chat/utils/messageMapKey';
 import { createServerConfigStore } from '@/store/serverConfig/store';
 import { merge } from '@/utils/merge';
 
-import { chatSelectors } from './selectors';
+import { chatSelectors } from './chat';
 
 vi.mock('i18next', () => ({
   t: vi.fn((key) => key), // Simplified mock return value
@@ -416,35 +416,6 @@ describe('chatSelectors', () => {
     });
   });
 
-  describe('isToolCallStreaming', () => {
-    it('should return true when tool call is streaming for given message and index', () => {
-      const state: Partial<ChatStore> = {
-        toolCallingStreamIds: {
-          'msg-1': [true, false, true],
-        },
-      };
-      expect(chatSelectors.isToolCallStreaming('msg-1', 0)(state as ChatStore)).toBe(true);
-      expect(chatSelectors.isToolCallStreaming('msg-1', 2)(state as ChatStore)).toBe(true);
-    });
-
-    it('should return false when tool call is not streaming for given message and index', () => {
-      const state: Partial<ChatStore> = {
-        toolCallingStreamIds: {
-          'msg-1': [true, false, true],
-        },
-      };
-      expect(chatSelectors.isToolCallStreaming('msg-1', 1)(state as ChatStore)).toBe(false);
-      expect(chatSelectors.isToolCallStreaming('msg-2', 0)(state as ChatStore)).toBe(false);
-    });
-
-    it('should return false when no streaming data exists for the message', () => {
-      const state: Partial<ChatStore> = {
-        toolCallingStreamIds: {},
-      };
-      expect(chatSelectors.isToolCallStreaming('msg-1', 0)(state as ChatStore)).toBe(false);
-    });
-  });
-
   describe('activeBaseChats with group chat messages', () => {
     it('should retrieve agent meta for group chat messages with groupId and agentId', () => {
       const groupChatMessages = [
@@ -470,4 +441,269 @@ describe('chatSelectors', () => {
       expect(chats[0].meta).toBeDefined();
     });
   });
+
+  describe('getGroupLatestMessageWithoutTools', () => {
+    it('should return the last child without tools', () => {
+      const groupMessage = {
+        id: 'group-1',
+        role: 'group',
+        content: '',
+        children: [
+          {
+            id: 'child-1',
+            content: 'First response',
+            tools: [
+              {
+                id: 'tool-1',
+                identifier: 'test',
+                apiName: 'test',
+                arguments: '{}',
+                type: 'default',
+              },
+            ],
+          },
+          {
+            id: 'child-2',
+            content: 'Second response',
+            tools: [],
+          },
+          {
+            id: 'child-3',
+            content: 'Final response',
+          },
+        ],
+      } as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-1')(state as ChatStore);
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('child-3');
+      expect(result?.content).toBe('Final response');
+    });
+
+    it('should return null if the last child has tools', () => {
+      const groupMessage = {
+        id: 'group-2',
+        role: 'group',
+        content: '',
+        children: [
+          {
+            id: 'child-1',
+            content: 'First response',
+          },
+          {
+            id: 'child-2',
+            content: 'Second response with tools',
+            tools: [
+              {
+                id: 'tool-1',
+                identifier: 'test',
+                apiName: 'test',
+                arguments: '{}',
+                type: 'default',
+              },
+            ],
+          },
+        ],
+      } as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-2')(state as ChatStore);
+      expect(result).toBeUndefined();
+    });
+
+    it('should return the last child when it has empty tools array', () => {
+      const groupMessage = {
+        id: 'group-3',
+        role: 'group',
+        content: '',
+        children: [
+          {
+            id: 'child-1',
+            content: 'First response with tools',
+            tools: [
+              {
+                id: 'tool-1',
+                identifier: 'test',
+                apiName: 'test',
+                arguments: '{}',
+                type: 'default',
+              },
+            ],
+          },
+          {
+            id: 'child-2',
+            content: 'Final response',
+            tools: [],
+          },
+        ],
+      } as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-3')(state as ChatStore);
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('child-2');
+      expect(result?.content).toBe('Final response');
+    });
+
+    it('should return null for non-group messages', () => {
+      const assistantMessage = {
+        id: 'msg-1',
+        role: 'assistant',
+        content: 'Regular message',
+      } as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [assistantMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('msg-1')(state as ChatStore);
+      expect(result).toBeUndefined();
+    });
+
+    it('should return null for group messages without children', () => {
+      const groupMessage = {
+        id: 'group-4',
+        role: 'group',
+        content: '',
+        children: undefined,
+      } as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-4')(state as ChatStore);
+      expect(result).toBeUndefined();
+    });
+
+    it('should return null for group messages with empty children array', () => {
+      const groupMessage = {
+        id: 'group-5',
+        role: 'group',
+        content: '',
+        children: [],
+      } as unknown as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-5')(state as ChatStore);
+      expect(result).toBeUndefined();
+    });
+
+    it('should return null if all children have tools', () => {
+      const groupMessage = {
+        id: 'group-6',
+        role: 'group',
+        content: '',
+        children: [
+          {
+            id: 'child-1',
+            content: 'First response',
+            tools: [
+              {
+                id: 'tool-1',
+                identifier: 'test',
+                apiName: 'test',
+                arguments: '{}',
+                type: 'default',
+              },
+            ],
+          },
+          {
+            id: 'child-2',
+            content: 'Second response',
+            tools: [
+              {
+                id: 'tool-2',
+                identifier: 'test2',
+                apiName: 'test2',
+                arguments: '{}',
+                type: 'default',
+              },
+            ],
+          },
+        ],
+      } as unknown as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-6')(state as ChatStore);
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle empty tools array as no tools', () => {
+      const groupMessage = {
+        id: 'group-7',
+        role: 'group',
+        content: '',
+        children: [
+          {
+            id: 'child-1',
+            content: 'Response with empty tools',
+            tools: [],
+          },
+        ],
+      } as unknown as UIChatMessage;
+
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [groupMessage],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('group-7')(state as ChatStore);
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('child-1');
+    });
+
+    it('should return null when message is not found', () => {
+      const state: Partial<ChatStore> = {
+        activeId: 'test-id',
+        messagesMap: {
+          [messageMapKey('test-id')]: [],
+        },
+      };
+
+      const result = chatSelectors.getGroupLatestMessageWithoutTools('non-existent')(
+        state as ChatStore,
+      );
+      expect(result).toBeUndefined();
+    });
+  });
 });

package/src/store/chat/slices/message/{selectors.ts → selectors/chat.ts}

@@ -10,8 +10,8 @@ import { sessionMetaSelectors } from '@/store/session/selectors';
 import { useUserStore } from '@/store/user';
 import { userProfileSelectors } from '@/store/user/selectors';
 
-import { chatHelpers } from '../../helpers';
-import type { ChatStoreState } from '../../initialState';
+import { chatHelpers } from '../../../helpers';
+import type { ChatStoreState } from '../../../initialState';
 
 const getMeta = (message: UIChatMessage) => {
   switch (message.role) {
@@ -47,7 +47,7 @@ const getBaseChatsByKey =
     return messages.map((i) => ({ ...i, meta: getMeta(i) }));
   };
 
-const currentChatKey = (s: ChatStoreState) => messageMapKey(s.activeId, s.activeTopicId);
+export const currentChatKey = (s: ChatStoreState) => messageMapKey(s.activeId, s.activeTopicId);
 
 /**
  * Current active raw message list, include thread messages
@@ -89,7 +89,7 @@ const mainDisplayChats = (s: ChatStoreState): UIChatMessage[] => {
   return getChatsWithThread(s, displayChats);
 };
 
-const mainDisplayChatIDs = (s: ChatStoreState) => mainDisplayChats(s).map((s) => s.id);
+export const mainDisplayChatIDs = (s: ChatStoreState) => mainDisplayChats(s).map((s) => s.id);
 
 const mainAIChats = (s: ChatStoreState): UIChatMessage[] => {
   const messages = activeBaseChats(s);
@@ -154,7 +154,7 @@ const countMessagesByThreadId = (id: string) => (s: ChatStoreState) => {
   return messages.length;
 };
 
-const getMessageByToolCallId = (id: string) => (s: ChatStoreState) => {
+export const getMessageByToolCallId = (id: string) => (s: ChatStoreState) => {
   const messages = activeBaseChats(s);
   return messages.find((m) => m.tool_call_id === id);
 };
@@ -166,67 +166,6 @@ const currentChatLoadingState = (s: ChatStoreState) => !s.messagesInit;
 
 const isCurrentChatLoaded = (s: ChatStoreState) => !!s.messagesMap[currentChatKey(s)];
 
-const isMessageEditing = (id: string) => (s: ChatStoreState) => s.messageEditingIds.includes(id);
-const isMessageLoading = (id: string) => (s: ChatStoreState) => s.messageLoadingIds.includes(id);
-
-const isMessageGenerating = (id: string) => (s: ChatStoreState) => s.chatLoadingIds.includes(id);
-const isMessageInRAGFlow = (id: string) => (s: ChatStoreState) =>
-  s.messageRAGLoadingIds.includes(id);
-const isMessageInChatReasoning = (id: string) => (s: ChatStoreState) =>
-  s.reasoningLoadingIds.includes(id);
-
-const isPluginApiInvoking = (id: string) => (s: ChatStoreState) =>
-  s.pluginApiLoadingIds.includes(id);
-
-const isToolCallStreaming = (id: string, index: number) => (s: ChatStoreState) => {
-  const isLoading = s.toolCallingStreamIds[id];
-
-  if (!isLoading) return false;
-
-  return isLoading[index];
-};
-
-const isInToolsCalling = (id: string, index: number) => (s: ChatStoreState) => {
-  const isStreamingToolsCalling = isToolCallStreaming(id, index)(s);
-
-  const isInvokingPluginApi = s.messageInToolsCallingIds.includes(id);
-
-  return isStreamingToolsCalling || isInvokingPluginApi;
-};
-
-const isToolApiNameShining =
-  (messageId: string, index: number, toolCallId: string) => (s: ChatStoreState) => {
-    const toolMessageId = getMessageByToolCallId(toolCallId)(s)?.id;
-    const isStreaming = isToolCallStreaming(messageId, index)(s);
-    const isPluginInvoking = !toolMessageId ? true : isPluginApiInvoking(toolMessageId)(s);
-
-    return isStreaming || isPluginInvoking;
-  };
-
-const isAIGenerating = (s: ChatStoreState) =>
-  s.chatLoadingIds.some((id) => mainDisplayChatIDs(s).includes(id));
-
-const isInRAGFlow = (s: ChatStoreState) =>
-  s.messageRAGLoadingIds.some((id) => mainDisplayChatIDs(s).includes(id));
-
-const isCreatingMessage = (s: ChatStoreState) => s.isCreatingMessage;
-
-const isHasMessageLoading = (s: ChatStoreState) =>
-  s.messageLoadingIds.some((id) => mainDisplayChatIDs(s).includes(id));
-
-/**
- * this function is used to determine whether the send button should be disabled
- */
-const isSendButtonDisabledByMessage = (s: ChatStoreState) =>
-  // 1. when there is message loading
-  isHasMessageLoading(s) ||
-  // 2. when is creating the topic
-  s.creatingTopic ||
-  // 3. when is creating the message
-  isCreatingMessage(s) ||
-  // 4. when the message is in RAG flow
-  isInRAGFlow(s);
-
 const inboxActiveTopicMessages = (state: ChatStoreState) => {
   const activeTopicId = state.activeTopicId;
   return state.messagesMap[messageMapKey(INBOX_SESSION_ID, activeTopicId)] || [];
@@ -280,6 +219,29 @@ const getSupervisorTodos = (groupId?: string, topicId?: string | null) => (s: Ch
   return s.supervisorTodos[messageMapKey(groupId, topicId)] || [];
 };
 
+/**
+ * Gets the latest message block from a group message that doesn't contain tools
+ * Returns null if the last block contains tools or if message is not a group message
+ */
+const getGroupLatestMessageWithoutTools = (id: string) => (s: ChatStoreState) => {
+  const message = getMessageById(id)(s);
+
+  if (!message || message.role !== 'group' || !message.children || message.children.length === 0)
+    return;
+
+  // Get the last child
+  const lastChild = message.children.at(-1);
+
+  if (!lastChild) return;
+
+  // Return the last child only if it doesn't have tools
+  if (!lastChild.tools || lastChild.tools.length === 0) {
+    return lastChild;
+  }
+
+  return;
+};
+
 export const chatSelectors = {
   activeBaseChats,
   activeBaseChatsWithoutTool,
@@ -289,6 +251,7 @@ export const chatSelectors = {
   currentToolMessages,
   currentUserFiles,
   getBaseChatsByKey,
+  getGroupLatestMessageWithoutTools,
   getMessageById,
   getMessageByToolCallId,
   getSupervisorTodos,
@@ -296,21 +259,8 @@ export const chatSelectors = {
   getThreadMessages,
   getTraceIdByMessageId,
   inboxActiveTopicMessages,
-  isAIGenerating,
-  isCreatingMessage,
   isCurrentChatLoaded,
-  isHasMessageLoading,
-  isInToolsCalling,
-  isMessageEditing,
-  isMessageGenerating,
-  isMessageInChatReasoning,
-  isMessageInRAGFlow,
-  isMessageLoading,
-  isPluginApiInvoking,
-  isSendButtonDisabledByMessage,
   isSupervisorLoading,
-  isToolApiNameShining,
-  isToolCallStreaming,
   latestMessage,
   mainAIChats,
   mainAIChatsMessageString,

package/src/store/chat/slices/message/selectors/index.ts

@@ -0,0 +1,2 @@
+export * from './chat';
+export * from './messageState';

package/src/store/chat/slices/message/selectors/messageState.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+
+import { ChatStore } from '@/store/chat';
+
+import { messageStateSelectors } from './messageState';
+
+describe('messageStateSelectors', () => {
+  describe('isToolCallStreaming', () => {
+    it('should return true when tool call is streaming for given message and index', () => {
+      const state: Partial<ChatStore> = {
+        toolCallingStreamIds: {
+          'msg-1': [true, false, true],
+        },
+      };
+      expect(messageStateSelectors.isToolCallStreaming('msg-1', 0)(state as ChatStore)).toBe(true);
+      expect(messageStateSelectors.isToolCallStreaming('msg-1', 2)(state as ChatStore)).toBe(true);
+    });
+
+    it('should return false when tool call is not streaming for given message and index', () => {
+      const state: Partial<ChatStore> = {
+        toolCallingStreamIds: {
+          'msg-1': [true, false, true],
+        },
+      };
+      expect(messageStateSelectors.isToolCallStreaming('msg-1', 1)(state as ChatStore)).toBe(false);
+      expect(messageStateSelectors.isToolCallStreaming('msg-2', 0)(state as ChatStore)).toBe(false);
+    });
+
+    it('should return false when no streaming data exists for the message', () => {
+      const state: Partial<ChatStore> = {
+        toolCallingStreamIds: {},
+      };
+      expect(messageStateSelectors.isToolCallStreaming('msg-1', 0)(state as ChatStore)).toBe(false);
+    });
+  });
+});