@lobehub/lobehub 2.0.0-next.35 → 2.0.0-next.36

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

@@ -154,36 +154,6 @@ describe('chatSelectors', () => {
     });
   });
 
-  describe('getMessageByToolCallId', () => {
-    it('should return undefined if the message with the given id does not exist', () => {
-      const message = chatSelectors.getMessageByToolCallId('non-existent-id')(initialStore);
-      expect(message).toBeUndefined();
-    });
-
-    it('should return the message object with the matching tool_call_id', () => {
-      const toolMessage = {
-        id: 'msg3',
-        content: 'Function Message',
-        role: 'tool',
-        tool_call_id: 'ttt',
-        plugin: {
-          arguments: 'arg1',
-          identifier: 'func1',
-          apiName: 'ttt',
-          type: 'default',
-        },
-      } as UIChatMessage;
-      const state = merge(initialStore, {
-        messagesMap: {
-          [messageMapKey('abc')]: [...mockMessages, toolMessage],
-        },
-        activeId: 'abc',
-      });
-      const message = chatSelectors.getMessageByToolCallId('ttt')(state);
-      expect(message).toMatchObject(toolMessage);
-    });
-  });
-
   describe('currentChatsWithHistoryConfig', () => {
     it('should slice the messages according to the current agent config', () => {
       const state = merge(initialStore, {
@@ -255,19 +225,6 @@ describe('chatSelectors', () => {
     });
   });
 
-  describe('mainDisplayChats', () => {
-    it('should return existing messages except tool message', () => {
-      const state = merge(initialStore, {
-        messagesMap: {
-          [messageMapKey('someActiveId')]: mockMessages,
-        },
-        activeId: 'someActiveId',
-      });
-      const chats = chatSelectors.mainDisplayChats(state);
-      expect(chats).toEqual(mockedChats.slice(0, 2));
-    });
-  });
-
   describe('chatsMessageString', () => {
     it('should concatenate the contents of all messages returned by currentChatsWithHistoryConfig', () => {
       // Prepare a state with a few messages
@@ -353,6 +310,9 @@ describe('chatSelectors', () => {
       ] as UIChatMessage[];
       const state: Partial<ChatStore> = {
         activeId: 'test-id',
+        dbMessagesMap: {
+          [messageMapKey('test-id')]: messages,
+        },
         messagesMap: {
           [messageMapKey('test-id')]: messages,
         },
@@ -369,6 +329,9 @@ describe('chatSelectors', () => {
       ] as UIChatMessage[];
       const state: Partial<ChatStore> = {
         activeId: 'test-id',
+        dbMessagesMap: {
+          [messageMapKey('test-id')]: messages,
+        },
         messagesMap: {
           [messageMapKey('test-id')]: messages,
         },
@@ -446,7 +409,7 @@ describe('chatSelectors', () => {
     it('should return the last child without tools', () => {
       const groupMessage = {
         id: 'group-1',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: [
           {
@@ -490,7 +453,7 @@ describe('chatSelectors', () => {
     it('should return null if the last child has tools', () => {
       const groupMessage = {
         id: 'group-2',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: [
           {
@@ -527,7 +490,7 @@ describe('chatSelectors', () => {
     it('should return the last child when it has empty tools array', () => {
       const groupMessage = {
         id: 'group-3',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: [
           {
@@ -585,7 +548,7 @@ describe('chatSelectors', () => {
     it('should return null for group messages without children', () => {
       const groupMessage = {
         id: 'group-4',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: undefined,
       } as UIChatMessage;
@@ -604,7 +567,7 @@ describe('chatSelectors', () => {
     it('should return null for group messages with empty children array', () => {
       const groupMessage = {
         id: 'group-5',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: [],
       } as unknown as UIChatMessage;
@@ -623,7 +586,7 @@ describe('chatSelectors', () => {
     it('should return null if all children have tools', () => {
       const groupMessage = {
         id: 'group-6',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: [
           {
@@ -669,7 +632,7 @@ describe('chatSelectors', () => {
     it('should handle empty tools array as no tools', () => {
       const groupMessage = {
         id: 'group-7',
-        role: 'group',
+        role: 'assistantGroup',
         content: '',
         children: [
           {

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

@@ -1,272 +1,108 @@
-import { ChatFileItem, UIChatMessage } from '@lobechat/types';
-
-import { DEFAULT_USER_AVATAR } from '@/const/meta';
-import { INBOX_SESSION_ID } from '@/const/session';
-import { useAgentStore } from '@/store/agent';
-import { agentChatConfigSelectors } from '@/store/agent/selectors';
-import { messageMapKey } from '@/store/chat/utils/messageMapKey';
-import { useSessionStore } from '@/store/session';
-import { sessionMetaSelectors } from '@/store/session/selectors';
-import { useUserStore } from '@/store/user';
-import { userProfileSelectors } from '@/store/user/selectors';
+/**
+ * Chat Selectors - Backward Compatibility Layer
+ *
+ * This file provides backward compatibility by re-exporting selectors from:
+ * - dbMessage.ts: Raw database message selectors (for data operations)
+ * - displayMessage.ts: Display message selectors (for UI rendering)
+ *
+ * MIGRATION GUIDE:
+ * ================
+ *
+ * For Data Operations (create, update, delete):
+ * ----------------------------------------------
+ * Use dbMessageSelectors from './dbMessage'
+ *
+ * Before: chatSelectors.getMessageById(id)(state)
+ * After:  dbMessageSelectors.getDbMessageById(id)(state)
+ *
+ * Before: chatSelectors.latestMessage(state)
+ * After:  dbMessageSelectors.latestDbMessage(state)
+ *
+ * Before: chatSelectors.currentToolMessages(state)
+ * After:  dbMessageSelectors.dbToolMessages(state)
+ *
+ * For UI Rendering:
+ * -----------------
+ * Use displayMessageSelectors from './displayMessage'
+ *
+ * Before: chatSelectors.mainDisplayChats(state)
+ * After:  displayMessageSelectors.mainDisplayChats(state)
+ *
+ * Before: chatSelectors.getMessageById(id)(state)  // For display
+ * After:  displayMessageSelectors.getDisplayMessageById(id)(state)
+ */
+import { ChatFileItem } from '@lobechat/types';
 
-import { chatHelpers } from '../../../helpers';
 import type { ChatStoreState } from '../../../initialState';
+import { dbMessageSelectors } from './dbMessage';
+import { displayMessageSelectors } from './displayMessage';
 
-const getMeta = (message: UIChatMessage) => {
-  switch (message.role) {
-    case 'user': {
-      return {
-        avatar: userProfileSelectors.userAvatar(useUserStore.getState()) || DEFAULT_USER_AVATAR,
-      };
-    }
-
-    case 'system': {
-      return message.meta;
-    }
-
-    default: {
-      // For group chat, get meta from agent session
-      if (message.groupId && message.agentId) {
-        return sessionMetaSelectors.getAgentMetaByAgentId(message.agentId)(
-          useSessionStore.getState(),
-        );
-      }
-
-      // Otherwise, use the current session's agent meta for single agent chat
-      return sessionMetaSelectors.currentAgentMeta(useSessionStore.getState());
-    }
-  }
-};
-
-const getBaseChatsByKey =
-  (key: string) =>
-  (s: ChatStoreState): UIChatMessage[] => {
-    const messages = s.messagesMap[key] || [];
+// Re-export new selector groups
+export { dbMessageSelectors } from './dbMessage';
+export { displayMessageSelectors } from './displayMessage';
 
-    return messages.map((i) => ({ ...i, meta: getMeta(i) }));
-  };
-
-export const currentChatKey = (s: ChatStoreState) => messageMapKey(s.activeId, s.activeTopicId);
+// ============= Backward Compatibility Exports ========== //
+// These maintain the old API for gradual migration
+// Prefer using dbMessageSelectors or displayMessageSelectors directly
 
 /**
- * Current active raw message list, include thread messages
+ * @deprecated Use displayMessageSelectors.currentDisplayChatKey instead
  */
-const activeBaseChats = (s: ChatStoreState): UIChatMessage[] => {
-  if (!s.activeId) return [];
-
-  return getBaseChatsByKey(currentChatKey(s))(s);
-};
+export const currentChatKey = displayMessageSelectors.currentDisplayChatKey;
 
 /**
- * 排除掉所有 tool 消息，在展示时需要使用
+ * @deprecated Use displayMessageSelectors.mainDisplayChatIDs instead
  */
-const activeBaseChatsWithoutTool = (s: ChatStoreState) => {
-  const messages = activeBaseChats(s);
-
-  return messages.filter((m) => m.role !== 'tool');
-};
-
-const getChatsWithThread = (s: ChatStoreState, messages: UIChatMessage[]) => {
-  // 如果没有 activeThreadId，则返回所有的主消息
-  if (!s.activeThreadId) return messages.filter((m) => !m.threadId);
-
-  const thread = s.threadMaps[s.activeTopicId!]?.find((t) => t.id === s.activeThreadId);
-
-  if (!thread) return messages.filter((m) => !m.threadId);
-
-  const sourceIndex = messages.findIndex((m) => m.id === thread.sourceMessageId);
-  const sliced = messages.slice(0, sourceIndex + 1);
-
-  return [...sliced, ...messages.filter((m) => m.threadId === s.activeThreadId)];
-};
-
-// ============= Main Display Chats ========== //
-// =========================================== //
-const mainDisplayChats = (s: ChatStoreState): UIChatMessage[] => {
-  const displayChats = activeBaseChatsWithoutTool(s);
-
-  return getChatsWithThread(s, displayChats);
-};
-
-export const mainDisplayChatIDs = (s: ChatStoreState) => mainDisplayChats(s).map((s) => s.id);
-
-const mainAIChats = (s: ChatStoreState): UIChatMessage[] => {
-  const messages = activeBaseChats(s);
-
-  return getChatsWithThread(s, messages);
-};
-
-const mainAIChatsWithHistoryConfig = (s: ChatStoreState): UIChatMessage[] => {
-  const chats = mainAIChats(s);
-  const enableHistoryCount = agentChatConfigSelectors.enableHistoryCount(useAgentStore.getState());
-  const historyCount = agentChatConfigSelectors.historyCount(useAgentStore.getState());
-
-  return chatHelpers.getSlicedMessages(chats, {
-    enableHistoryCount,
-    historyCount,
-  });
-};
-
-const mainAIChatsMessageString = (s: ChatStoreState): string => {
-  const chats = mainAIChatsWithHistoryConfig(s);
-  return chats.map((m) => m.content).join('');
-};
-
-const mainAILatestMessageReasoningContent = (s: ChatStoreState) =>
-  mainAIChats(s).at(-1)?.reasoning?.content;
+export const mainDisplayChatIDs = displayMessageSelectors.mainDisplayChatIDs;
 
-const currentToolMessages = (s: ChatStoreState) => {
-  const messages = activeBaseChats(s);
-
-  return messages.filter((m) => m.role === 'tool');
-};
-
-const currentUserMessages = (s: ChatStoreState) => {
-  const messages = activeBaseChats(s);
-
-  return messages.filter((m) => m.role === 'user');
-};
-
-const currentUserFiles = (s: ChatStoreState) => {
-  const userMessages = currentUserMessages(s);
-
-  return userMessages
-    .filter((m) => m.fileList && m.fileList?.length > 0)
-    .flatMap((m) => m.fileList)
-    .filter(Boolean) as ChatFileItem[];
-};
-
-const showInboxWelcome = (s: ChatStoreState): boolean => {
-  const isInbox = s.activeId === INBOX_SESSION_ID;
-  if (!isInbox) return false;
-
-  const data = activeBaseChats(s);
-  return data.length === 0;
-};
-
-const getMessageById = (id: string) => (s: ChatStoreState) =>
-  chatHelpers.getMessageById(activeBaseChats(s), id);
-
-const countMessagesByThreadId = (id: string) => (s: ChatStoreState) => {
-  const messages = activeBaseChats(s).filter((m) => m.threadId === id);
-
-  return messages.length;
-};
-
-export const getMessageByToolCallId = (id: string) => (s: ChatStoreState) => {
-  const messages = activeBaseChats(s);
-  return messages.find((m) => m.tool_call_id === id);
-};
-const getTraceIdByMessageId = (id: string) => (s: ChatStoreState) => getMessageById(id)(s)?.traceId;
+/**
+ * Legacy chatSelectors object for backward compatibility
+ * @deprecated Import dbMessageSelectors or displayMessageSelectors directly
+ */
+export const chatSelectors = {
+  // Display message selectors (from messagesMap)
+  activeBaseChats: displayMessageSelectors.activeDisplayMessages,
+  // DB message selectors (from dbMessagesMap)
+  countMessagesByThreadId: dbMessageSelectors.countDbMessagesByThreadId,
 
-const latestMessage = (s: ChatStoreState) => activeBaseChats(s).at(-1);
+  currentChatKey: displayMessageSelectors.currentDisplayChatKey,
 
-const currentChatLoadingState = (s: ChatStoreState) => !s.messagesInit;
+  currentChatLoadingState: displayMessageSelectors.currentChatLoadingState,
 
-const isCurrentChatLoaded = (s: ChatStoreState) => !!s.messagesMap[currentChatKey(s)];
+  currentToolMessages: dbMessageSelectors.dbToolMessages,
 
-const inboxActiveTopicMessages = (state: ChatStoreState) => {
-  const activeTopicId = state.activeTopicId;
-  return state.messagesMap[messageMapKey(INBOX_SESSION_ID, activeTopicId)] || [];
-};
+  currentUserFiles: (s: ChatStoreState) =>
+    dbMessageSelectors.dbUserFiles(s) as unknown as ChatFileItem[],
 
-/**
- * Gets messages between the current user and a specific agent (thread messages)
- * This is like a DM (Direct Message) view between user and agent
- */
-const getThreadMessages =
-  (agentId: string) =>
-  (s: ChatStoreState): UIChatMessage[] => {
-    if (!agentId) return [];
+  getBaseChatsByKey: displayMessageSelectors.getDisplayMessagesByKey,
 
-    const allMessages = activeBaseChats(s);
+  getGroupLatestMessageWithoutTools: displayMessageSelectors.getGroupLatestMessageWithoutTools,
 
-    // Filter messages to only include:
-    // 1. User messages sent TO the specific agent (role: 'user' && targetId matches agentId)
-    // 2. Assistant messages FROM the specific agent sent TO user (role: 'assistant' && agentId matches && targetId is 'user')
-    return allMessages.filter((message) => {
-      if (message.role === 'user' && message.targetId === agentId) {
-        return true; // Include user messages sent to the specific agent
-      }
+  getMessageById: displayMessageSelectors.getDisplayMessageById,
 
-      if (
-        message.role === 'assistant' &&
-        message.agentId === agentId &&
-        message.targetId === 'user'
-      ) {
-        return true; // Include messages from the specific agent sent to user
-      }
+  getSupervisorTodos: displayMessageSelectors.getSupervisorTodos,
 
-      return false; // Exclude all other messages
-    });
-  };
+  getThreadMessageIDs: displayMessageSelectors.getThreadMessageIDs,
 
-/**
- * Gets thread message IDs for a specific agent
- */
-const getThreadMessageIDs =
-  (agentId: string) =>
-  (s: ChatStoreState): string[] => {
-    return getThreadMessages(agentId)(s).map((message) => message.id);
-  };
+  getThreadMessages: displayMessageSelectors.getThreadMessages,
 
-const isSupervisorLoading = (groupId: string) => (s: ChatStoreState) =>
-  s.supervisorDecisionLoading.includes(groupId);
+  getTraceIdByMessageId: dbMessageSelectors.getTraceIdByDbMessageId,
 
-const getSupervisorTodos = (groupId?: string, topicId?: string | null) => (s: ChatStoreState) => {
-  if (!groupId) return [];
-  return s.supervisorTodos[messageMapKey(groupId, topicId)] || [];
-};
+  inboxActiveTopicMessages: displayMessageSelectors.inboxActiveTopicDisplayMessages,
 
-/**
- * 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);
+  isCurrentChatLoaded: displayMessageSelectors.isCurrentDisplayChatLoaded,
 
-  if (!message || message.role !== 'group' || !message.children || message.children.length === 0)
-    return;
+  isSupervisorLoading: displayMessageSelectors.isSupervisorLoading,
 
-  // Get the last child
-  const lastChild = message.children.at(-1);
+  latestMessage: dbMessageSelectors.latestDbMessage,
 
-  if (!lastChild) return;
+  mainAIChats: displayMessageSelectors.mainAIChats,
 
-  // Return the last child only if it doesn't have tools
-  if (!lastChild.tools || lastChild.tools.length === 0) {
-    return lastChild;
-  }
+  mainAIChatsMessageString: displayMessageSelectors.mainAIChatsMessageString,
 
-  return;
-};
-
-export const chatSelectors = {
-  activeBaseChats,
-  activeBaseChatsWithoutTool,
-  countMessagesByThreadId,
-  currentChatKey,
-  currentChatLoadingState,
-  currentToolMessages,
-  currentUserFiles,
-  getBaseChatsByKey,
-  getGroupLatestMessageWithoutTools,
-  getMessageById,
-  getMessageByToolCallId,
-  getSupervisorTodos,
-  getThreadMessageIDs,
-  getThreadMessages,
-  getTraceIdByMessageId,
-  inboxActiveTopicMessages,
-  isCurrentChatLoaded,
-  isSupervisorLoading,
-  latestMessage,
-  mainAIChats,
-  mainAIChatsMessageString,
-  mainAIChatsWithHistoryConfig,
-  mainAILatestMessageReasoningContent,
-  mainDisplayChatIDs,
-  mainDisplayChats,
-  showInboxWelcome,
+  mainAIChatsWithHistoryConfig: displayMessageSelectors.mainAIChatsWithHistoryConfig,
+  mainAILatestMessageReasoningContent: displayMessageSelectors.mainAILatestMessageReasoningContent,
+  mainDisplayChatIDs: displayMessageSelectors.mainDisplayChatIDs,
+  mainDisplayChats: displayMessageSelectors.mainDisplayChats,
+  showInboxWelcome: displayMessageSelectors.showInboxWelcome,
 };

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

@@ -0,0 +1,140 @@
+import { UIChatMessage } from '@lobechat/types';
+
+import { chatHelpers } from '../../../helpers';
+import type { ChatStoreState } from '../../../initialState';
+import { messageMapKey } from '../../../utils/messageMapKey';
+
+/**
+ * DB Message Selectors
+ *
+ * These selectors access raw messages from dbMessagesMap (database source).
+ * Use these selectors when you need to:
+ * - Operate on raw message data (create, update, delete)
+ * - Access original message structure before processing
+ * - Perform data mutations or service calls
+ *
+ * DO NOT use these for UI rendering - use displayMessage.ts selectors instead.
+ */
+
+// ============= Basic DB Message Access ========== //
+
+/**
+ * Get the current chat key for accessing dbMessagesMap
+ */
+export const currentDbChatKey = (s: ChatStoreState) => messageMapKey(s.activeId, s.activeTopicId);
+
+/**
+ * Get raw messages from database by key
+ */
+const getDbMessagesByKey =
+  (key: string) =>
+  (s: ChatStoreState): UIChatMessage[] => {
+    return s.dbMessagesMap[key] || [];
+  };
+
+/**
+ * Get current active session's raw messages from database
+ */
+const activeDbMessages = (s: ChatStoreState): UIChatMessage[] => {
+  if (!s.activeId) return [];
+  return getDbMessagesByKey(currentDbChatKey(s))(s);
+};
+
+// ============= DB Message Queries ========== //
+
+/**
+ * Get raw message by ID from database
+ * This searches in dbMessagesMap, which contains flat message structure
+ */
+const getDbMessageById = (id: string) => (s: ChatStoreState) =>
+  chatHelpers.getMessageById(activeDbMessages(s), id);
+
+/**
+ * Get raw message by tool_call_id from database
+ */
+export const getDbMessageByToolCallId = (id: string) => (s: ChatStoreState) => {
+  const messages = activeDbMessages(s);
+  return messages.find((m) => m.tool_call_id === id);
+};
+
+/**
+ * Get traceId from a message by ID
+ */
+const getTraceIdByDbMessageId = (id: string) => (s: ChatStoreState) =>
+  getDbMessageById(id)(s)?.traceId;
+
+/**
+ * Get latest raw message from database
+ */
+const latestDbMessage = (s: ChatStoreState) => activeDbMessages(s).at(-1);
+
+// ============= DB Message Filtering ========== //
+
+/**
+ * Get all tool messages from database
+ */
+const dbToolMessages = (s: ChatStoreState) => {
+  const messages = activeDbMessages(s);
+  return messages.filter((m) => m.role === 'tool');
+};
+
+/**
+ * Get all user messages from database
+ */
+const dbUserMessages = (s: ChatStoreState) => {
+  const messages = activeDbMessages(s);
+  return messages.filter((m) => m.role === 'user');
+};
+
+/**
+ * Get all file attachments from user messages
+ */
+const dbUserFiles = (s: ChatStoreState) => {
+  const userMessages = dbUserMessages(s);
+  return userMessages
+    .filter((m) => m.fileList && m.fileList.length > 0)
+    .flatMap((m) => m.fileList)
+    .filter(Boolean);
+};
+
+// ============= DB Message Counting ========== //
+
+/**
+ * Count messages in a specific thread
+ */
+const countDbMessagesByThreadId = (id: string) => (s: ChatStoreState) => {
+  const messages = activeDbMessages(s).filter((m) => m.threadId === id);
+  return messages.length;
+};
+
+// ============= DB Message Status ========== //
+
+/**
+ * Check if current chat is loaded in dbMessagesMap
+ */
+const isCurrentDbChatLoaded = (s: ChatStoreState) => !!s.dbMessagesMap[currentDbChatKey(s)];
+
+/**
+ * Get inbox active topic raw messages from database
+ */
+const inboxActiveTopicDbMessages = (state: ChatStoreState) => {
+  const activeTopicId = state.activeTopicId;
+  const key = messageMapKey('inbox', activeTopicId);
+  return state.dbMessagesMap[key] || [];
+};
+
+export const dbMessageSelectors = {
+  activeDbMessages,
+  countDbMessagesByThreadId,
+  currentDbChatKey,
+  dbToolMessages,
+  dbUserFiles,
+  dbUserMessages,
+  getDbMessageById,
+  getDbMessageByToolCallId,
+  getDbMessagesByKey,
+  getTraceIdByDbMessageId,
+  inboxActiveTopicDbMessages,
+  isCurrentDbChatLoaded,
+  latestDbMessage,
+};