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

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

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

@@ -0,0 +1,80 @@
+import type { ChatStoreState } from '../../../initialState';
+import { getMessageByToolCallId, mainDisplayChatIDs } from './chat';
+
+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);
+
+export const messageStateSelectors = {
+  isAIGenerating,
+  isCreatingMessage,
+  isHasMessageLoading,
+  isInRAGFlow,
+  isInToolsCalling,
+  isMessageEditing,
+  isMessageGenerating,
+  isMessageInChatReasoning,
+  isMessageInRAGFlow,
+  isMessageLoading,
+  isPluginApiInvoking,
+  isSendButtonDisabledByMessage,
+  isToolApiNameShining,
+  isToolCallStreaming,
+};