@lobehub/lobehub 2.0.0-next.85 → 2.0.0-next.86

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

@@ -6,6 +6,7 @@ import {
   CreateMessageParams,
   GroundingSearch,
   MessageMetadata,
+  MessagePluginItem,
   MessageToolCall,
   ModelReasoning,
   UIChatMessage,
@@ -21,8 +22,7 @@ import { ChatStore } from '@/store/chat/store';
  * Context for optimistic updates to specify session/topic isolation
  */
 export interface OptimisticUpdateContext {
-  sessionId?: string;
-  topicId?: string | null;
+  operationId?: string;
 }
 
 /**
@@ -38,10 +38,8 @@ export interface MessageOptimisticUpdateAction {
     params: CreateMessageParams,
     context?: {
       groupMessageId?: string;
-      sessionId?: string;
-      skipRefresh?: boolean;
+      operationId?: string;
       tempMessageId?: string;
-      topicId?: string | null;
     },
   ) => Promise<{ id: string; messages: UIChatMessage[] } | undefined>;
 
@@ -94,6 +92,16 @@ export interface MessageOptimisticUpdateAction {
     context?: OptimisticUpdateContext,
   ) => Promise<void>;
 
+  /**
+   * Optimistic update for message pluginIntervention field (frontend only, no database persistence)
+   * Use this when you need to update plugin intervention status
+   */
+  optimisticUpdateMessagePlugin: (
+    id: string,
+    value: Partial<MessagePluginItem>,
+    context?: OptimisticUpdateContext,
+  ) => Promise<void>;
+
   /**
    * update the message plugin error with optimistic update
    */
@@ -136,28 +144,28 @@ export const messageOptimisticUpdate: StateCreator<
     try {
       const result = await messageService.createMessage(message);
 
-      if (!context?.skipRefresh) {
-        // Use the messages returned from createMessage (already grouped)
-        const sessionId = context?.sessionId ?? get().activeId;
-        const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
-        replaceMessages(result.messages, { sessionId, topicId });
-      }
+      // Use the messages returned from createMessage (already grouped)
+      const { sessionId, topicId } = get().internal_getSessionContext(context);
+      replaceMessages(result.messages, { sessionId, topicId });
 
       internal_toggleMessageLoading(false, tempId);
       return result;
     } catch (e) {
       internal_toggleMessageLoading(false, tempId);
-      internal_dispatchMessage({
-        id: tempId,
-        type: 'updateMessage',
-        value: {
-          error: {
-            body: e,
-            message: (e as Error).message,
-            type: ChatErrorType.CreateMessageError,
+      internal_dispatchMessage(
+        {
+          id: tempId,
+          type: 'updateMessage',
+          value: {
+            error: {
+              body: e,
+              message: (e as Error).message,
+              type: ChatErrorType.CreateMessageError,
+            },
           },
         },
-      });
+        context,
+      );
     }
   },
 
@@ -172,9 +180,8 @@ export const messageOptimisticUpdate: StateCreator<
   },
 
   optimisticDeleteMessage: async (id: string, context) => {
-    get().internal_dispatchMessage({ id, type: 'deleteMessage' });
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    get().internal_dispatchMessage({ id, type: 'deleteMessage' }, context);
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
     const result = await messageService.removeMessage(id, {
       sessionId,
       topicId,
@@ -185,9 +192,8 @@ export const messageOptimisticUpdate: StateCreator<
   },
 
   optimisticDeleteMessages: async (ids, context) => {
-    get().internal_dispatchMessage({ ids, type: 'deleteMessages' });
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    get().internal_dispatchMessage({ ids, type: 'deleteMessages' }, context);
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
     const result = await messageService.removeMessages(ids, {
       sessionId,
       topicId,
@@ -209,21 +215,26 @@ export const messageOptimisticUpdate: StateCreator<
     // we need to update the message content at the frontend to avoid the update flick
     // refs: https://medium.com/@kyledeguzmanx/what-are-optimistic-updates-483662c3e171
     if (extra?.toolCalls) {
-      internal_dispatchMessage({
-        id,
-        type: 'updateMessage',
-        value: { tools: internal_transformToolCalls(extra?.toolCalls) },
-      });
+      internal_dispatchMessage(
+        {
+          id,
+          type: 'updateMessage',
+          value: { tools: internal_transformToolCalls(extra?.toolCalls) },
+        },
+        context,
+      );
     } else {
-      internal_dispatchMessage({
-        id,
-        type: 'updateMessage',
-        value: { content },
-      });
+      internal_dispatchMessage(
+        {
+          id,
+          type: 'updateMessage',
+          value: { content },
+        },
+        context,
+      );
     }
 
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
 
     const result = await messageService.updateMessage(
       id,
@@ -252,9 +263,8 @@ export const messageOptimisticUpdate: StateCreator<
   },
 
   optimisticUpdateMessageError: async (id, error, context) => {
-    get().internal_dispatchMessage({ id, type: 'updateMessage', value: { error } });
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    get().internal_dispatchMessage({ id, type: 'updateMessage', value: { error } }, context);
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
     const result = await messageService.updateMessage(id, { error }, { sessionId, topicId });
     if (result?.success && result.messages) {
       get().replaceMessages(result.messages, { sessionId, topicId });
@@ -267,14 +277,16 @@ export const messageOptimisticUpdate: StateCreator<
     const { internal_dispatchMessage, refreshMessages, replaceMessages } = get();
 
     // Optimistic update: update the frontend immediately
-    internal_dispatchMessage({
-      id,
-      type: 'updateMessageMetadata',
-      value: metadata,
-    });
+    internal_dispatchMessage(
+      {
+        id,
+        type: 'updateMessageMetadata',
+        value: metadata,
+      },
+      context,
+    );
 
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
 
     // Persist to database
     const result = await messageService.updateMessageMetadata(id, metadata, {
@@ -289,9 +301,31 @@ export const messageOptimisticUpdate: StateCreator<
     }
   },
 
+  optimisticUpdateMessagePlugin: async (id, value, context) => {
+    const { internal_dispatchMessage, replaceMessages } = get();
+
+    // Optimistic update: update the frontend immediately
+    internal_dispatchMessage(
+      {
+        id,
+        type: 'updateMessagePlugin',
+        value,
+      },
+      context,
+    );
+
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
+
+    // Persist to database
+    const result = await messageService.updateMessagePlugin(id, value, { sessionId, topicId });
+
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages, { sessionId, topicId });
+    }
+  },
+
   optimisticUpdateMessagePluginError: async (id, error, context) => {
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
     const result = await messageService.updateMessagePluginError(id, error, {
       sessionId,
       topicId,
@@ -302,8 +336,7 @@ export const messageOptimisticUpdate: StateCreator<
   },
 
   optimisticUpdateMessageRAG: async (id, data, context) => {
-    const sessionId = context?.sessionId ?? get().activeId;
-    const topicId = context?.topicId !== undefined ? context.topicId : get().activeTopicId;
+    const { sessionId, topicId } = get().internal_getSessionContext(context);
     const result = await messageService.updateMessageRAG(id, data, {
       sessionId,
       topicId,

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

@@ -15,10 +15,6 @@ export interface ChatMessageState {
    * Derived from session.type, used for caching to avoid repeated lookups
    */
   activeSessionType?: 'agent' | 'group';
-  /**
-   * is the message is continuing generation (used for disable continue button)
-   */
-  continuingIds: string[];
   /**
    * Raw messages from database (flat structure)
    */
@@ -52,10 +48,6 @@ export interface ChatMessageState {
    * Parsed messages for display (includes assistantGroup from conversation-flow)
    */
   messagesMap: Record<string, UIChatMessage[]>;
-  /**
-   * is the message is regenerating (used for disable regenerate button)
-   */
-  regeneratingIds: string[];
   /**
    * Supervisor decision debounce timers by group ID
    */
@@ -77,7 +69,6 @@ export interface ChatMessageState {
 export const initialMessageState: ChatMessageState = {
   activeId: 'inbox',
   activeSessionType: undefined,
-  continuingIds: [],
   dbMessagesMap: {},
   groupAgentMaps: {},
   groupMaps: {},
@@ -87,7 +78,6 @@ export const initialMessageState: ChatMessageState = {
   messageLoadingIds: [],
   messagesInit: false,
   messagesMap: {},
-  regeneratingIds: [],
   supervisorDebounceTimers: {},
   supervisorDecisionAbortControllers: {},
   supervisorDecisionLoading: [],

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

@@ -1,26 +1,50 @@
 import type { ChatStoreState } from '../../../initialState';
+import { operationSelectors } from '../../operation/selectors';
 import { mainDisplayChatIDs } from './chat';
 import { getDbMessageByToolCallId } from './dbMessage';
 import { getDisplayMessageById } from './displayMessage';
 
 const isMessageEditing = (id: string) => (s: ChatStoreState) => s.messageEditingIds.includes(id);
-const isMessageLoading = (id: string) => (s: ChatStoreState) => s.messageLoadingIds.includes(id);
-const isMessageRegenerating = (id: string) => (s: ChatStoreState) => s.regeneratingIds.includes(id);
-const isMessageContinuing = (id: string) => (s: ChatStoreState) => s.continuingIds.includes(id);
 
-const isMessageGenerating = (id: string) => (s: ChatStoreState) => s.chatLoadingIds.includes(id);
+/**
+ * Check if a message is in loading state
+ * Priority: operation system (for AI flows) > legacy messageLoadingIds (for CRUD operations)
+ */
+const isMessageLoading = (id: string) => (s: ChatStoreState) => {
+  // First check operation system (sendMessage, etc.)
+  const hasOperation = operationSelectors.isMessageProcessing(id)(s);
+  if (hasOperation) return true;
+
+  // Fallback to legacy loading state (for non-operation CRUD)
+  return s.messageLoadingIds.includes(id);
+};
+
+// Use operation system for AI-related loading states
+const isMessageRegenerating = (id: string) => (s: ChatStoreState) =>
+  operationSelectors.isMessageRegenerating(id)(s);
+const isMessageContinuing = (id: string) => (s: ChatStoreState) =>
+  operationSelectors.isMessageContinuing(id)(s);
+const isMessageGenerating = (id: string) => (s: ChatStoreState) =>
+  operationSelectors.isMessageGenerating(id)(s); // Only check generateAI operations
+const isMessageInChatReasoning = (id: string) => (s: ChatStoreState) =>
+  operationSelectors.isMessageInReasoning(id)(s);
+
+// Use operation system for message CRUD operations
+const isMessageCreating = (id: string) => (s: ChatStoreState) =>
+  operationSelectors.isMessageCreating(id)(s); // Only check sendMessage operations
+
+// RAG flow still uses dedicated state
 const isMessageInRAGFlow = (id: string) => (s: ChatStoreState) =>
   s.messageRAGLoadingIds.includes(id);
-const isMessageInChatReasoning = (id: string) => (s: ChatStoreState) =>
-  s.reasoningLoadingIds.includes(id);
 
 const isMessageCollapsed = (id: string) => (s: ChatStoreState) => {
   const message = getDisplayMessageById(id)(s);
   return message?.metadata?.collapsed ?? false;
 };
 
+// Use operation system for plugin API invocation
 const isPluginApiInvoking = (id: string) => (s: ChatStoreState) =>
-  s.pluginApiLoadingIds.includes(id);
+  operationSelectors.isMessageInToolCalling(id)(s);
 
 const isToolCallStreaming = (id: string, index: number) => (s: ChatStoreState) => {
   const isLoading = s.toolCallingStreamIds[id];
@@ -33,7 +57,8 @@ const isToolCallStreaming = (id: string, index: number) => (s: ChatStoreState) =
 const isInToolsCalling = (id: string, index: number) => (s: ChatStoreState) => {
   const isStreamingToolsCalling = isToolCallStreaming(id, index)(s);
 
-  const isInvokingPluginApi = s.messageInToolsCallingIds.includes(id);
+  // Check if assistant message has any tool calling operations
+  const isInvokingPluginApi = operationSelectors.isMessageInToolCalling(id)(s);
 
   return isStreamingToolsCalling || isInvokingPluginApi;
 };
@@ -47,9 +72,6 @@ const isToolApiNameShining =
     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));
 
@@ -72,13 +94,13 @@ const isSendButtonDisabledByMessage = (s: ChatStoreState) =>
   isInRAGFlow(s);
 
 export const messageStateSelectors = {
-  isAIGenerating,
   isCreatingMessage,
   isHasMessageLoading,
   isInRAGFlow,
   isInToolsCalling,
   isMessageCollapsed,
   isMessageContinuing,
+  isMessageCreating,
   isMessageEditing,
   isMessageGenerating,
   isMessageInChatReasoning,