@lobehub/chat 1.33.4 → 1.34.0

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

@@ -32,6 +32,8 @@ interface ProcessMessageParams {
    * the RAG query content, should be embedding and used in the semantic search
    */
   ragQuery?: string;
+  threadId?: string;
+  inPortalThread?: boolean;
 }
 
 export interface AIGenerateAction {
@@ -79,7 +81,15 @@ export interface AIGenerateAction {
   /**
    * Resends a specific message, optionally using a trace ID for tracking
    */
-  internal_resendMessage: (id: string, traceId?: string) => Promise<void>;
+  internal_resendMessage: (
+    id: string,
+    params?: {
+      traceId?: string;
+      messages?: ChatMessage[];
+      threadId?: string;
+      inPortalThread?: boolean;
+    },
+  ) => Promise<void>;
   /**
    * Toggles the loading state for AI message generation, managing the UI feedback
    */
@@ -102,7 +112,7 @@ export const generateAIChat: StateCreator<
 > = (set, get) => ({
   delAndRegenerateMessage: async (id) => {
     const traceId = chatSelectors.getTraceIdByMessageId(id)(get());
-    get().internal_resendMessage(id, traceId);
+    get().internal_resendMessage(id, { traceId });
     get().deleteMessage(id);
 
     // trace the delete and regenerate message
@@ -110,14 +120,14 @@ export const generateAIChat: StateCreator<
   },
   regenerateMessage: async (id) => {
     const traceId = chatSelectors.getTraceIdByMessageId(id)(get());
-    await get().internal_resendMessage(id, traceId);
+    await get().internal_resendMessage(id, { traceId });
 
     // trace the delete and regenerate message
     get().internal_traceMessage(id, { eventType: TraceEventType.RegenerateMessage });
   },
 
   sendMessage: async ({ message, files, onlyAddUserMessage, isWelcomeQuestion }) => {
-    const { internal_coreProcessMessage, activeTopicId, activeId } = get();
+    const { internal_coreProcessMessage, activeTopicId, activeId, activeThreadId } = get();
     if (!activeId) return;
 
     const fileIdList = files?.map((f) => f.id);
@@ -137,6 +147,7 @@ export const generateAIChat: StateCreator<
       sessionId: activeId,
       // if there is activeTopicId，then add topicId to message
       topicId: activeTopicId,
+      threadId: activeThreadId,
     };
 
     const agentConfig = getAgentChatConfig();
@@ -213,6 +224,7 @@ export const generateAIChat: StateCreator<
     await internal_coreProcessMessage(messages, id, {
       isWelcomeQuestion,
       ragQuery: get().internal_shouldUseRAG() ? message : undefined,
+      threadId: activeThreadId,
     });
 
     set({ isCreatingMessage: false }, false, n('creatingMessage/stop'));
@@ -308,6 +320,7 @@ export const generateAIChat: StateCreator<
       parentId: userMessageId,
       sessionId: get().activeId,
       topicId: activeTopicId, // if there is activeTopicId，then add it to topicId
+      threadId: params?.threadId,
       fileChunks,
       ragQueryId,
     };
@@ -320,7 +333,10 @@ export const generateAIChat: StateCreator<
     // 4. if it's the function call message, trigger the function method
     if (isFunctionCall) {
       await refreshMessages();
-      await triggerToolCalls(assistantId);
+      await triggerToolCalls(assistantId, {
+        threadId: params?.threadId,
+        inPortalThread: params?.inPortalThread,
+      });
     }
 
     // 5. summary history if context messages is larger than historyCount
@@ -482,9 +498,12 @@ export const generateAIChat: StateCreator<
     };
   },
 
-  internal_resendMessage: async (messageId, traceId) => {
+  internal_resendMessage: async (
+    messageId,
+    { traceId, messages: outChats, threadId: outThreadId, inPortalThread } = {},
+  ) => {
     // 1. 构造所有相关的历史记录
-    const chats = chatSelectors.activeBaseChats(get());
+    const chats = outChats ?? chatSelectors.mainAIChats(get());
 
     const currentIndex = chats.findIndex((c) => c.id === messageId);
     if (currentIndex < 0) return;
@@ -511,15 +530,19 @@ export const generateAIChat: StateCreator<
 
     if (contextMessages.length <= 0) return;
 
-    const { internal_coreProcessMessage } = get();
+    const { internal_coreProcessMessage, activeThreadId } = get();
 
     const latestMsg = contextMessages.findLast((s) => s.role === 'user');
 
     if (!latestMsg) return;
 
+    const threadId = outThreadId ?? activeThreadId;
+
     await internal_coreProcessMessage(contextMessages, latestMsg.id, {
       traceId,
       ragQuery: get().internal_shouldUseRAG() ? latestMsg.content : undefined,
+      threadId,
+      inPortalThread,
     });
   },
 

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

@@ -146,7 +146,7 @@ export const chatRag: StateCreator<ChatStore, [['zustand/devtools', never]], [],
     // delete the current ragQuery
     await get().deleteUserMessageRagQuery(id);
 
-    const chats = chatSelectors.currentChatsWithHistoryConfig(get());
+    const chats = chatSelectors.mainAIChatsWithHistoryConfig(get());
 
     await get().internal_rewriteQuery(
       id,

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

@@ -170,7 +170,7 @@ describe('chatSelectors', () => {
         activeId: 'abc',
       });
 
-      const chats = chatSelectors.currentChatsWithHistoryConfig(state);
+      const chats = chatSelectors.mainAIChatsWithHistoryConfig(state);
       expect(chats).toHaveLength(3);
       expect(chats).toEqual(mockedChats);
     });
@@ -196,7 +196,7 @@ describe('chatSelectors', () => {
         });
       });
 
-      const chats = chatSelectors.currentChatsWithHistoryConfig(state);
+      const chats = chatSelectors.mainAIChatsWithHistoryConfig(state);
 
       expect(chats).toHaveLength(2);
       expect(chats).toEqual([
@@ -262,7 +262,7 @@ describe('chatSelectors', () => {
         .join('');
 
       // Call the selector and verify the result
-      const concatenatedString = chatSelectors.chatsMessageString(state);
+      const concatenatedString = chatSelectors.mainAIChatsMessageString(state);
       expect(concatenatedString).toBe(expectedString);
 
       // Restore the mocks after the test

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

@@ -52,35 +52,48 @@ const activeBaseChatsWithoutTool = (s: ChatStoreState) => {
   return messages.filter((m) => m.role !== 'tool');
 };
 
-/**
- * Main display chats
- * 根据当前不同的状态，返回不同的消息列表
- */
-const mainDisplayChats = (s: ChatStoreState): ChatMessage[] => {
-  return activeBaseChatsWithoutTool(s);
+const getChatsWithThread = (s: ChatStoreState, messages: ChatMessage[]) => {
   // 如果没有 activeThreadId，则返回所有的主消息
-  // const mains = activeBaseChats(s).filter((m) => !m.threadId);
-  // if (!s.activeThreadId) return mains;
-  //
-  // const thread = s.threadMaps[s.activeTopicId!]?.find((t) => t.id === s.activeThreadId);
-  //
-  // if (!thread) return mains;
-  //
-  // const sourceIndex = mains.findIndex((m) => m.id === thread.sourceMessageId);
-  // const sliced = mains.slice(0, sourceIndex + 1);
-  //
-  // return [...sliced, ...activeBaseChats(s).filter((m) => m.threadId === s.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): ChatMessage[] => {
+  const displayChats = activeBaseChatsWithoutTool(s);
+
+  return getChatsWithThread(s, displayChats);
 };
 
 const mainDisplayChatIDs = (s: ChatStoreState) => mainDisplayChats(s).map((s) => s.id);
 
-const currentChatsWithHistoryConfig = (s: ChatStoreState): ChatMessage[] => {
-  const chats = activeBaseChats(s);
+const mainAIChats = (s: ChatStoreState): ChatMessage[] => {
+  const messages = activeBaseChats(s);
+
+  return getChatsWithThread(s, messages);
+};
+
+const mainAIChatsWithHistoryConfig = (s: ChatStoreState): ChatMessage[] => {
+  const chats = mainAIChats(s);
   const config = agentSelectors.currentAgentChatConfig(useAgentStore.getState());
 
   return chatHelpers.getSlicedMessagesWithConfig(chats, config);
 };
 
+const mainAIChatsMessageString = (s: ChatStoreState): string => {
+  const chats = mainAIChatsWithHistoryConfig(s);
+  return chats.map((m) => m.content).join('');
+};
+
 const currentToolMessages = (s: ChatStoreState) => {
   const messages = activeBaseChats(s);
 
@@ -110,14 +123,15 @@ const showInboxWelcome = (s: ChatStoreState): boolean => {
   return data.length === 0;
 };
 
-const chatsMessageString = (s: ChatStoreState): string => {
-  const chats = currentChatsWithHistoryConfig(s);
-  return chats.map((m) => m.content).join('');
-};
-
 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;
+};
+
 const getMessageByToolCallId = (id: string) => (s: ChatStoreState) => {
   const messages = activeBaseChats(s);
   return messages.find((m) => m.tool_call_id === id);
@@ -147,10 +161,15 @@ const isToolCallStreaming = (id: string, index: number) => (s: ChatStoreState) =
   return isLoading[index];
 };
 
-const isAIGenerating = (s: ChatStoreState) => s.chatLoadingIds.length > 0;
-const isInRAGFlow = (s: ChatStoreState) => s.messageRAGLoadingIds.length > 0;
+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.length > 0;
+
+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
@@ -168,10 +187,9 @@ const isSendButtonDisabledByMessage = (s: ChatStoreState) =>
 export const chatSelectors = {
   activeBaseChats,
   activeBaseChatsWithoutTool,
-  chatsMessageString,
+  countMessagesByThreadId,
   currentChatKey,
   currentChatLoadingState,
-  currentChatsWithHistoryConfig,
   currentToolMessages,
   currentUserFiles,
   getMessageById,
@@ -189,6 +207,9 @@ export const chatSelectors = {
   isSendButtonDisabledByMessage,
   isToolCallStreaming,
   latestMessage,
+  mainAIChats,
+  mainAIChatsMessageString,
+  mainAIChatsWithHistoryConfig,
   mainDisplayChatIDs,
   mainDisplayChats,
   showInboxWelcome,

package/src/store/chat/slices/plugin/action.ts

@@ -25,7 +25,8 @@ import { merge } from '@/utils/merge';
 import { safeParseJSON } from '@/utils/safeParseJSON';
 import { setNamespace } from '@/utils/storeDebug';
 
-import { chatSelectors } from '../../slices/message/selectors';
+import { chatSelectors } from '../message/selectors';
+import { threadSelectors } from '../thread/selectors';
 
 const n = setNamespace('plugin');
 
@@ -44,10 +45,18 @@ export interface ChatPluginAction {
   invokeStandaloneTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
 
   reInvokeToolMessage: (id: string) => Promise<void>;
-  triggerAIMessage: (params: { parentId?: string; traceId?: string }) => Promise<void>;
+  triggerAIMessage: (params: {
+    parentId?: string;
+    traceId?: string;
+    threadId?: string;
+    inPortalThread?: boolean;
+  }) => Promise<void>;
   summaryPluginContent: (id: string) => Promise<void>;
 
-  triggerToolCalls: (id: string) => Promise<void>;
+  triggerToolCalls: (
+    id: string,
+    params?: { threadId?: string; inPortalThread?: boolean },
+  ) => Promise<void>;
   updatePluginState: (id: string, value: any) => Promise<void>;
   updatePluginArguments: <T = any>(id: string, value: T) => Promise<void>;
 
@@ -200,10 +209,18 @@ export const chatPlugin: StateCreator<
     await get().internal_invokeDifferentTypePlugin(id, payload);
   },
 
-  triggerAIMessage: async ({ parentId, traceId }) => {
+  triggerAIMessage: async ({ parentId, traceId, threadId, inPortalThread }) => {
     const { internal_coreProcessMessage } = get();
-    const chats = chatSelectors.activeBaseChats(get());
-    await internal_coreProcessMessage(chats, parentId ?? chats.at(-1)!.id, { traceId });
+
+    const chats = inPortalThread
+      ? threadSelectors.portalAIChatsWithHistoryConfig(get())
+      : chatSelectors.mainAIChatsWithHistoryConfig(get());
+
+    await internal_coreProcessMessage(chats, parentId ?? chats.at(-1)!.id, {
+      traceId,
+      threadId,
+      inPortalThread,
+    });
   },
 
   summaryPluginContent: async (id) => {
@@ -228,7 +245,7 @@ export const chatPlugin: StateCreator<
     );
   },
 
-  triggerToolCalls: async (assistantId) => {
+  triggerToolCalls: async (assistantId, { threadId, inPortalThread } = {}) => {
     const message = chatSelectors.getMessageById(assistantId)(get());
     if (!message || !message.tools) return;
 
@@ -242,6 +259,7 @@ export const chatPlugin: StateCreator<
         role: 'tool',
         sessionId: get().activeId,
         tool_call_id: payload.id,
+        threadId,
         topicId: get().activeTopicId, // if there is activeTopicId，then add it to topicId
       };
 
@@ -263,7 +281,7 @@ export const chatPlugin: StateCreator<
 
     const traceId = chatSelectors.getTraceIdByMessageId(latestToolId)(get());
 
-    await get().triggerAIMessage({ traceId });
+    await get().triggerAIMessage({ traceId, threadId, inPortalThread });
   },
   updatePluginState: async (id, value) => {
     const { refreshMessages } = get();

package/src/store/chat/slices/portal/action.ts

@@ -51,6 +51,7 @@ export const chatPortalSlice: StateCreator<
 
     set({ portalMessageDetail: messageId }, false, 'openMessageDetail');
   },
+
   openToolUI: (id, identifier) => {
     get().togglePortal(true);
 

package/src/store/chat/slices/portal/initialState.ts

@@ -11,6 +11,7 @@ export interface ChatPortalState {
   portalArtifactDisplayMode?: 'code' | 'preview';
   portalFile?: PortalFile;
   portalMessageDetail?: string;
+  portalThreadId?: string;
   portalToolMessage?: { id: string; identifier: string };
   showPortal: boolean;
 }

package/src/store/chat/slices/portal/selectors/thread.ts

@@ -0,0 +1,17 @@
+import type { ChatStoreState } from '@/store/chat';
+
+const showThread = (s: ChatStoreState) => !!s.threadStartMessageId || !!s.portalThreadId;
+
+const newThreadMode = (s: ChatStoreState) => s.newThreadMode;
+
+const portalCurrentThread = (s: ChatStoreState) => {
+  if (!s.portalThreadId || !s.activeTopicId) return;
+
+  return (s.threadMaps[s.activeTopicId] || []).find((t) => t.id === s.portalThreadId);
+};
+
+export const portalThreadSelectors = {
+  newThreadMode,
+  portalCurrentThread,
+  showThread,
+};

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

@@ -71,3 +71,5 @@ export const chatPortalSelectors = {
   artifactCodeLanguage,
   isArtifactTagClosed,
 };
+
+export * from './selectors/thread';