@lobehub/lobehub 2.0.0-next.71 → 2.0.0-next.73

package/src/store/chat/slices/message/actions/query.ts

@@ -23,7 +23,7 @@ export interface MessageQueryAction {
   /**
    * Manually refresh messages from server
    */
-  refreshMessages: () => Promise<void>;
+  refreshMessages: (sessionId?: string, topicId?: string | null) => Promise<void>;
 
   /**
    * Replace current messages with new data
@@ -33,7 +33,7 @@ export interface MessageQueryAction {
     params?: {
       action?: any;
       sessionId?: string;
-      topicId?: string;
+      topicId?: string | null;
     },
   ) => void;
 
@@ -58,9 +58,11 @@ export const messageQuery: StateCreator<
 > = (set, get) => ({
   // TODO: The mutate should only be called once, but since we haven't merge session and group,
   // we need to call it twice
-  refreshMessages: async () => {
-    await mutate([SWR_USE_FETCH_MESSAGES, get().activeId, get().activeTopicId, 'session']);
-    await mutate([SWR_USE_FETCH_MESSAGES, get().activeId, get().activeTopicId, 'group']);
+  refreshMessages: async (sessionId?: string, topicId?: string | null) => {
+    const sid = sessionId ?? get().activeId;
+    const tid = topicId !== undefined ? topicId : get().activeTopicId;
+    await mutate([SWR_USE_FETCH_MESSAGES, sid, tid, 'session']);
+    await mutate([SWR_USE_FETCH_MESSAGES, sid, tid, 'group']);
   },
 
   replaceMessages: (messages, params) => {

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

@@ -43,11 +43,18 @@ const activeDbMessages = (s: ChatStoreState): UIChatMessage[] => {
 // ============= DB Message Queries ========== //
 
 /**
- * Get raw message by ID from database
- * This searches in dbMessagesMap, which contains flat message structure
+ * Get raw message by ID from database (searches globally across all sessions/topics)
+ * This is essential for parallel topic agent runtime where background updates
+ * may occur after the user has switched to another chat.
  */
-const getDbMessageById = (id: string) => (s: ChatStoreState) =>
-  chatHelpers.getMessageById(activeDbMessages(s), id);
+const getDbMessageById = (id: string) => (s: ChatStoreState) => {
+  // Search across all messages in dbMessagesMap
+  for (const messages of Object.values(s.dbMessagesMap)) {
+    const message = chatHelpers.getMessageById(messages, id);
+    if (message) return message;
+  }
+  return undefined;
+};
 
 /**
  * Get raw message by tool_call_id from database

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

@@ -257,6 +257,11 @@ describe('ChatPluginAction', () => {
       expect(storeState.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         pluginApiResponse,
+        undefined,
+        {
+          sessionId: undefined,
+          topicId: undefined,
+        },
       );
       expect(storeState.internal_togglePluginApiCalling).toHaveBeenCalledWith(
         false,
@@ -295,8 +300,14 @@ describe('ChatPluginAction', () => {
         expect.any(String),
       );
       expect(chatService.runPluginApi).toHaveBeenCalledWith(pluginPayload, { trace: {} });
-      expect(messageService.updateMessageError).toHaveBeenCalledWith(messageId, error);
-      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+      expect(messageService.updateMessageError).toHaveBeenCalledWith(messageId, error, {
+        sessionId: undefined,
+        topicId: undefined,
+      });
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages, {
+        sessionId: undefined,
+        topicId: undefined,
+      });
       expect(storeState.internal_togglePluginApiCalling).toHaveBeenCalledWith(
         false,
         'message-id',
@@ -379,50 +390,78 @@ describe('ChatPluginAction', () => {
 
       // Verify that tool messages were created for each tool call
       expect(optimisticCreateMessageMock).toHaveBeenCalledTimes(4);
-      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(1, {
-        content: '',
-        parentId: assistantId,
-        plugin: message.tools![0],
-        role: 'tool',
-        sessionId: 'session-id',
-        tool_call_id: 'tool1',
-        topicId: 'topic-id',
-        threadId: undefined,
-        groupId: undefined,
-      });
-      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(2, {
-        content: '',
-        parentId: assistantId,
-        plugin: message.tools![1],
-        role: 'tool',
-        sessionId: 'session-id',
-        tool_call_id: 'tool2',
-        topicId: 'topic-id',
-        threadId: undefined,
-        groupId: undefined,
-      });
-      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(3, {
-        content: '',
-        parentId: assistantId,
-        plugin: message.tools![2],
-        role: 'tool',
-        sessionId: 'session-id',
-        tool_call_id: 'tool3',
-        topicId: 'topic-id',
-        threadId: undefined,
-        groupId: undefined,
-      });
-      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(4, {
-        content: '',
-        parentId: assistantId,
-        plugin: message.tools![3],
-        role: 'tool',
-        sessionId: 'session-id',
-        tool_call_id: 'tool4',
-        topicId: 'topic-id',
-        threadId: undefined,
-        groupId: undefined,
-      });
+      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(
+        1,
+        {
+          content: '',
+          parentId: assistantId,
+          plugin: message.tools![0],
+          role: 'tool',
+          sessionId: 'session-id',
+          tool_call_id: 'tool1',
+          topicId: 'topic-id',
+          threadId: undefined,
+          groupId: undefined,
+        },
+        {
+          sessionId: 'session-id',
+          topicId: 'topic-id',
+        },
+      );
+      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(
+        2,
+        {
+          content: '',
+          parentId: assistantId,
+          plugin: message.tools![1],
+          role: 'tool',
+          sessionId: 'session-id',
+          tool_call_id: 'tool2',
+          topicId: 'topic-id',
+          threadId: undefined,
+          groupId: undefined,
+        },
+        {
+          sessionId: 'session-id',
+          topicId: 'topic-id',
+        },
+      );
+      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(
+        3,
+        {
+          content: '',
+          parentId: assistantId,
+          plugin: message.tools![2],
+          role: 'tool',
+          sessionId: 'session-id',
+          tool_call_id: 'tool3',
+          topicId: 'topic-id',
+          threadId: undefined,
+          groupId: undefined,
+        },
+        {
+          sessionId: 'session-id',
+          topicId: 'topic-id',
+        },
+      );
+      expect(optimisticCreateMessageMock).toHaveBeenNthCalledWith(
+        4,
+        {
+          content: '',
+          parentId: assistantId,
+          plugin: message.tools![3],
+          role: 'tool',
+          sessionId: 'session-id',
+          tool_call_id: 'tool4',
+          topicId: 'topic-id',
+          threadId: undefined,
+          groupId: undefined,
+        },
+        {
+          sessionId: 'session-id',
+          topicId: 'topic-id',
+        },
+      );
 
       // Verify that the appropriate plugin types were invoked
       expect(invokeStandaloneTypePluginMock).toHaveBeenCalledWith(
@@ -556,7 +595,10 @@ describe('ChatPluginAction', () => {
         },
       );
 
-      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages, {
+        sessionId: 'inbox',
+        topicId: null,
+      });
     });
   });
 
@@ -596,7 +638,10 @@ describe('ChatPluginAction', () => {
       });
 
       // 验证 replaceMessages 是否被调用
-      expect(result.current.replaceMessages).toHaveBeenCalledWith(mockMessages);
+      expect(result.current.replaceMessages).toHaveBeenCalledWith(mockMessages, {
+        sessionId: 'session-id',
+        topicId: 'topic-id',
+      });
     });
 
     it('should handle errors when message creation fails', async () => {
@@ -773,7 +818,10 @@ describe('ChatPluginAction', () => {
         type: 'PluginSettingsInvalid',
       });
 
-      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages, {
+        sessionId: undefined,
+        topicId: undefined,
+      });
     });
   });
 
@@ -848,7 +896,10 @@ describe('ChatPluginAction', () => {
         await result.current.reInvokeToolMessage(messageId);
       });
 
-      expect(internal_updateMessageErrorMock).toHaveBeenCalledWith(messageId, null);
+      expect(internal_updateMessageErrorMock).toHaveBeenCalledWith(messageId, null, {
+        sessionId: undefined,
+        topicId: undefined,
+      });
     });
   });
 
@@ -938,6 +989,11 @@ describe('ChatPluginAction', () => {
       expect(result.current.optimisticUpdateMessageContent).toHaveBeenCalledWith(
         messageId,
         apiResponse,
+        undefined,
+        {
+          sessionId: undefined,
+          topicId: undefined,
+        },
       );
       expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { traceId: 'trace-id' });
     });
@@ -977,8 +1033,14 @@ describe('ChatPluginAction', () => {
         await result.current.internal_callPluginApi(messageId, payload);
       });
 
-      expect(messageService.updateMessageError).toHaveBeenCalledWith(messageId, error);
-      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+      expect(messageService.updateMessageError).toHaveBeenCalledWith(messageId, error, {
+        sessionId: undefined,
+        topicId: undefined,
+      });
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages, {
+        sessionId: undefined,
+        topicId: undefined,
+      });
     });
   });
 
@@ -1111,7 +1173,10 @@ describe('ChatPluginAction', () => {
         { error },
         { sessionId: 'inbox', topicId: null },
       );
-      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages, {
+        sessionId: 'inbox',
+        topicId: null,
+      });
     });
   });
 
@@ -1153,7 +1218,145 @@ describe('ChatPluginAction', () => {
         });
       });
 
-      expect(refreshToUpdateMessageToolsSpy).toHaveBeenCalledWith(messageId);
+      expect(refreshToUpdateMessageToolsSpy).toHaveBeenCalledWith(messageId, undefined);
+    });
+  });
+
+  describe('Plugin OptimisticUpdateContext isolation', () => {
+    describe('optimisticUpdatePluginState', () => {
+      it('should use context sessionId/topicId when provided', async () => {
+        const { result } = renderHook(() => useChatStore());
+        const messageId = 'message-id';
+        const pluginState = { key: 'value' };
+        const contextSessionId = 'context-session';
+        const contextTopicId = 'context-topic';
+
+        (messageService.updateMessagePluginState as Mock).mockResolvedValue({
+          success: true,
+          messages: [],
+        });
+
+        const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
+
+        await act(async () => {
+          await result.current.optimisticUpdatePluginState(messageId, pluginState, {
+            sessionId: contextSessionId,
+            topicId: contextTopicId,
+          });
+        });
+
+        expect(messageService.updateMessagePluginState).toHaveBeenCalledWith(
+          messageId,
+          pluginState,
+          { sessionId: contextSessionId, topicId: contextTopicId },
+        );
+        expect(replaceMessagesSpy).toHaveBeenCalledWith([], {
+          sessionId: contextSessionId,
+          topicId: contextTopicId,
+        });
+      });
+
+      it('should fallback to activeId/activeTopicId when context not provided', async () => {
+        const { result } = renderHook(() => useChatStore());
+        const messageId = 'message-id';
+        const pluginState = { key: 'value' };
+
+        act(() => {
+          useChatStore.setState({
+            activeId: 'active-session',
+            activeTopicId: 'active-topic',
+          });
+        });
+
+        (messageService.updateMessagePluginState as Mock).mockResolvedValue({
+          success: true,
+          messages: [],
+        });
+
+        await act(async () => {
+          await result.current.optimisticUpdatePluginState(messageId, pluginState);
+        });
+
+        expect(messageService.updateMessagePluginState).toHaveBeenCalledWith(
+          messageId,
+          pluginState,
+          { sessionId: 'active-session', topicId: 'active-topic' },
+        );
+      });
+    });
+
+    describe('optimisticUpdatePluginError', () => {
+      it('should use context sessionId/topicId when provided', async () => {
+        const { result } = renderHook(() => useChatStore());
+        const messageId = 'message-id';
+        const error = { message: 'Plugin error', type: 'error' as any };
+        const contextSessionId = 'context-session';
+        const contextTopicId = 'context-topic';
+
+        (messageService.updateMessage as Mock).mockResolvedValue({
+          success: true,
+          messages: [],
+        });
+
+        await act(async () => {
+          await result.current.optimisticUpdatePluginError(messageId, error, {
+            sessionId: contextSessionId,
+            topicId: contextTopicId,
+          });
+        });
+
+        expect(messageService.updateMessage).toHaveBeenCalledWith(
+          messageId,
+          { error },
+          { sessionId: contextSessionId, topicId: contextTopicId },
+        );
+      });
+    });
+
+    describe('internal_refreshToUpdateMessageTools', () => {
+      it('should use context sessionId/topicId when provided', async () => {
+        const { result } = renderHook(() => useChatStore());
+        const messageId = 'message-id';
+        const contextSessionId = 'context-session';
+        const contextTopicId = 'context-topic';
+
+        const message = {
+          id: messageId,
+          role: 'assistant',
+          content: 'test',
+          tools: [{ id: 'tool-1', identifier: 'test', apiName: 'test', arguments: '{}' }],
+          sessionId: contextSessionId,
+          topicId: contextTopicId,
+        } as any;
+
+        // Set up both dbMessagesMap and messagesMap
+        const key = messageMapKey(contextSessionId, contextTopicId);
+        act(() => {
+          useChatStore.setState({
+            dbMessagesMap: {
+              [key]: [message],
+            },
+            messagesMap: {
+              [key]: [message],
+            },
+            activeId: contextSessionId,
+            activeTopicId: contextTopicId,
+          });
+        });
+
+        await act(async () => {
+          await result.current.internal_refreshToUpdateMessageTools(messageId, {
+            sessionId: contextSessionId,
+            topicId: contextTopicId,
+          });
+        });
+
+        expect(messageService.updateMessage).toHaveBeenCalledWith(
+          messageId,
+          { tools: message.tools },
+          { sessionId: contextSessionId, topicId: contextTopicId },
+        );
+      });
     });
   });
 });

package/src/store/chat/slices/plugin/actions/optimisticUpdate.ts

@@ -4,6 +4,7 @@ import isEqual from 'fast-deep-equal';
 import { StateCreator } from 'zustand/vanilla';
 
 import { messageService } from '@/services/message';
+import { OptimisticUpdateContext } from '@/store/chat/slices/message/actions/optimisticUpdate';
 import { ChatStore } from '@/store/chat/store';
 import { merge } from '@/utils/merge';
 import { safeParseJSON } from '@/utils/safeParseJSON';
@@ -18,7 +19,11 @@ export interface PluginOptimisticUpdateAction {
   /**
    * Update plugin state with optimistic update
    */
-  optimisticUpdatePluginState: (id: string, value: any) => Promise<void>;
+  optimisticUpdatePluginState: (
+    id: string,
+    value: any,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
 
   /**
    * Update plugin arguments with optimistic update
@@ -32,27 +37,46 @@ export interface PluginOptimisticUpdateAction {
   /**
    * Update plugin with optimistic update (generic method for any plugin field)
    */
-  optimisticUpdatePlugin: (id: string, value: Partial<MessagePluginItem>) => Promise<void>;
+  optimisticUpdatePlugin: (
+    id: string,
+    value: Partial<MessagePluginItem>,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
 
   /**
    * Add tool to assistant message with optimistic update
    */
-  optimisticAddToolToAssistantMessage: (id: string, tool: ChatToolPayload) => Promise<void>;
+  optimisticAddToolToAssistantMessage: (
+    id: string,
+    tool: ChatToolPayload,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
 
   /**
    * Remove tool from assistant message with optimistic update
    */
-  optimisticRemoveToolFromAssistantMessage: (id: string, tool_call_id?: string) => Promise<void>;
+  optimisticRemoveToolFromAssistantMessage: (
+    id: string,
+    tool_call_id?: string,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
 
   /**
    * Update plugin error with optimistic update
    */
-  optimisticUpdatePluginError: (id: string, error: ChatMessageError) => Promise<void>;
+  optimisticUpdatePluginError: (
+    id: string,
+    error: ChatMessageError,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
 
   /**
    * Use the optimistic update value to update the message tools to database
    */
-  internal_refreshToUpdateMessageTools: (id: string) => Promise<void>;
+  internal_refreshToUpdateMessageTools: (
+    id: string,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
 }
 
 export const pluginOptimisticUpdate: StateCreator<
@@ -61,19 +85,22 @@ export const pluginOptimisticUpdate: StateCreator<
   [],
   PluginOptimisticUpdateAction
 > = (set, get) => ({
-  optimisticUpdatePluginState: async (id, value) => {
+  optimisticUpdatePluginState: async (id, value, context) => {
     const { replaceMessages } = get();
 
     // optimistic update
     get().internal_dispatchMessage({ id, type: 'updateMessage', value: { pluginState: value } });
 
+    const sessionId = context?.sessionId ?? get().activeId;
+    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+
     const result = await messageService.updateMessagePluginState(id, value, {
-      sessionId: get().activeId,
-      topicId: get().activeTopicId,
+      sessionId,
+      topicId,
     });
 
     if (result?.success && result.messages) {
-      replaceMessages(result.messages);
+      replaceMessages(result.messages, { sessionId, topicId });
     }
   },
 
@@ -124,7 +151,7 @@ export const pluginOptimisticUpdate: StateCreator<
     await refreshMessages();
   },
 
-  optimisticUpdatePlugin: async (id, value) => {
+  optimisticUpdatePlugin: async (id, value, context) => {
     const { replaceMessages } = get();
 
     // optimistic update
@@ -134,17 +161,20 @@ export const pluginOptimisticUpdate: StateCreator<
       value,
     });
 
+    const sessionId = context?.sessionId ?? get().activeId;
+    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+
     const result = await messageService.updateMessagePlugin(id, value, {
-      sessionId: get().activeId,
-      topicId: get().activeTopicId,
+      sessionId,
+      topicId,
     });
 
     if (result?.success && result.messages) {
-      replaceMessages(result.messages);
+      replaceMessages(result.messages, { sessionId, topicId });
     }
   },
 
-  optimisticAddToolToAssistantMessage: async (id, tool) => {
+  optimisticAddToolToAssistantMessage: async (id, tool, context) => {
     const assistantMessage = displayMessageSelectors.getDisplayMessageById(id)(get());
     if (!assistantMessage) return;
 
@@ -155,10 +185,10 @@ export const pluginOptimisticUpdate: StateCreator<
       id: assistantMessage.id,
     });
 
-    await internal_refreshToUpdateMessageTools(id);
+    await internal_refreshToUpdateMessageTools(id, context);
   },
 
-  optimisticRemoveToolFromAssistantMessage: async (id, tool_call_id) => {
+  optimisticRemoveToolFromAssistantMessage: async (id, tool_call_id, context) => {
     const message = displayMessageSelectors.getDisplayMessageById(id)(get());
     if (!message || !tool_call_id) return;
 
@@ -168,46 +198,53 @@ export const pluginOptimisticUpdate: StateCreator<
     internal_dispatchMessage({ type: 'deleteMessageTool', tool_call_id, id: message.id });
 
     // update the message tools
-    await internal_refreshToUpdateMessageTools(id);
+    await internal_refreshToUpdateMessageTools(id, context);
   },
 
-  optimisticUpdatePluginError: async (id, error) => {
+  optimisticUpdatePluginError: async (id, error, context) => {
     const { replaceMessages } = get();
 
     get().internal_dispatchMessage({ id, type: 'updateMessage', value: { error } });
+
+    const sessionId = context?.sessionId ?? get().activeId;
+    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+
     const result = await messageService.updateMessage(
       id,
       { error },
       {
-        sessionId: get().activeId,
-        topicId: get().activeTopicId,
+        sessionId,
+        topicId,
       },
     );
     if (result?.success && result.messages) {
-      replaceMessages(result.messages);
+      replaceMessages(result.messages, { sessionId, topicId });
     }
   },
 
-  internal_refreshToUpdateMessageTools: async (id) => {
+  internal_refreshToUpdateMessageTools: async (id, context) => {
     const { dbMessageSelectors } = await import('../../message/selectors');
     const message = dbMessageSelectors.getDbMessageById(id)(get());
     if (!message || !message.tools) return;
 
     const { internal_toggleMessageLoading, replaceMessages } = get();
 
+    const sessionId = context?.sessionId ?? get().activeId;
+    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+
     internal_toggleMessageLoading(true, id);
     const result = await messageService.updateMessage(
       id,
       { tools: message.tools },
       {
-        sessionId: get().activeId,
-        topicId: get().activeTopicId,
+        sessionId,
+        topicId,
       },
     );
     internal_toggleMessageLoading(false, id);
 
     if (result?.success && result.messages) {
-      replaceMessages(result.messages);
+      replaceMessages(result.messages, { sessionId, topicId });
     }
   },
 });