@lobehub/lobehub 2.0.0-next.38 → 2.0.0-next.39

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

@@ -1,4 +1,4 @@
-import { UIChatMessage } from '@lobechat/types';
+import { AssistantContentBlock, UIChatMessage } from '@lobechat/types';
 
 import { DEFAULT_USER_AVATAR } from '@/const/meta';
 import { INBOX_SESSION_ID } from '@/const/session';
@@ -250,12 +250,62 @@ const getGroupLatestMessageWithoutTools = (id: string) => (s: ChatStoreState) =>
 
   // Return the last child only if it doesn't have tools
   if (!lastChild.tools || lastChild.tools.length === 0) {
+    if (!lastChild.content) return;
+
     return lastChild;
   }
 
   return;
 };
 
+/**
+ * Helper to find last message ID in an AssistantContentBlock
+ */
+const findLastBlockId = (block: AssistantContentBlock | undefined): string | undefined => {
+  if (!block) return undefined;
+
+  // Check tools for result message ID
+  if (block.tools && block.tools.length > 0) {
+    const lastTool = block.tools.at(-1);
+    return lastTool?.result_msg_id;
+  }
+
+  // Return block ID
+  return block.id;
+};
+
+/**
+ * Recursively finds the last message ID in a message tree
+ * Priority: children > tools > self
+ */
+const findLastMessageIdRecursive = (node: UIChatMessage | undefined): string | undefined => {
+  if (!node) return undefined;
+
+  // Priority 1: Dive into children recursively
+  if (node.children && node.children.length > 0) {
+    const lastChild = node.children.at(-1);
+    return findLastBlockId(lastChild);
+  }
+
+  // Priority 2: Check tools for result message ID
+  if (node.tools && node.tools.length > 0) {
+    const lastTool = node.tools.at(-1);
+    return lastTool?.result_msg_id;
+  }
+
+  // Priority 3: Return self ID
+  return node.id;
+};
+
+/**
+ * Finds the last (deepest) message ID from a display message
+ * Recursively traverses children and tools to find the actual last message
+ */
+const findLastMessageId = (id: string) => (s: ChatStoreState) => {
+  const message = getDisplayMessageById(id)(s);
+  return findLastMessageIdRecursive(message);
+};
+
 // ============= Supervisor Selectors ========== //
 
 const isSupervisorLoading = (groupId: string) => (s: ChatStoreState) =>
@@ -281,6 +331,7 @@ export const displayMessageSelectors = {
   activeDisplayMessages,
   currentChatLoadingState,
   currentDisplayChatKey,
+  findLastMessageId,
   getDisplayMessageById,
   getDisplayMessagesByKey,
   getGroupLatestMessageWithoutTools,

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

@@ -5,6 +5,7 @@ import { getDbMessageByToolCallId } from './dbMessage';
 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);
 const isMessageInRAGFlow = (id: string) => (s: ChatStoreState) =>
@@ -70,6 +71,7 @@ export const messageStateSelectors = {
   isHasMessageLoading,
   isInRAGFlow,
   isInToolsCalling,
+  isMessageContinuing,
   isMessageEditing,
   isMessageGenerating,
   isMessageInChatReasoning,

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

@@ -544,7 +544,7 @@ describe('ChatPluginAction', () => {
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
-        await result.current.updatePluginState(messageId, pluginStateValue);
+        await result.current.optimisticUpdatePluginState(messageId, pluginStateValue);
       });
 
       expect(messageService.updateMessagePluginState).toHaveBeenCalledWith(
@@ -887,7 +887,7 @@ describe('ChatPluginAction', () => {
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
-        await result.current.updatePluginArguments(messageId, newArguments);
+        await result.current.optimisticUpdatePluginArguments(messageId, newArguments);
       });
 
       expect(messageService.updateMessagePluginArguments).toHaveBeenCalledWith(
@@ -1103,7 +1103,7 @@ describe('ChatPluginAction', () => {
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
-        await result.current.internal_updatePluginError(messageId, error);
+        await result.current.optimisticUpdatePluginError(messageId, error);
       });
 
       expect(messageService.updateMessage).toHaveBeenCalledWith(
@@ -1144,7 +1144,7 @@ describe('ChatPluginAction', () => {
       });
 
       await act(async () => {
-        await result.current.internal_addToolToAssistantMessage(messageId, {
+        await result.current.optimisticAddToolToAssistantMessage(messageId, {
           identifier,
           arguments: '{"oldKey":"oldValue"}',
           id: 'newId',

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

@@ -0,0 +1,39 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { ChatStore } from '@/store/chat/store';
+
+import { PluginInternalsAction, pluginInternals } from './internals';
+import { PluginOptimisticUpdateAction, pluginOptimisticUpdate } from './optimisticUpdate';
+import { PluginTypesAction, pluginTypes } from './pluginTypes';
+import { PluginPublicApiAction, pluginPublicApi } from './publicApi';
+import { PluginWorkflowAction, pluginWorkflow } from './workflow';
+
+/**
+ * Combined plugin action interface
+ * Aggregates all plugin-related actions
+ */
+export interface ChatPluginAction
+  extends PluginPublicApiAction,
+    PluginOptimisticUpdateAction,
+    PluginTypesAction,
+    PluginWorkflowAction,
+    PluginInternalsAction {
+  /**/
+}
+
+/**
+ * Combined plugin action creator
+ * Merges all plugin action modules
+ */
+export const chatPlugin: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  ChatPluginAction
+> = (...params) => ({
+  ...pluginPublicApi(...params),
+  ...pluginOptimisticUpdate(...params),
+  ...pluginTypes(...params),
+  ...pluginWorkflow(...params),
+  ...pluginInternals(...params),
+});

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

@@ -0,0 +1,83 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+import { ToolNameResolver } from '@lobechat/context-engine';
+import { MessageToolCall, ToolsCallingContext } from '@lobechat/types';
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { StateCreator } from 'zustand/vanilla';
+
+import { ChatStore } from '@/store/chat/store';
+import { useToolStore } from '@/store/tool';
+import { pluginSelectors } from '@/store/tool/selectors';
+import { builtinTools } from '@/tools';
+import { Action } from '@/utils/storeDebug';
+
+import { displayMessageSelectors } from '../../message/selectors';
+
+/**
+ * Internal utility methods and runtime state management
+ * These are building blocks used by other actions
+ */
+export interface PluginInternalsAction {
+  /**
+   * Toggle plugin API calling state
+   */
+  internal_togglePluginApiCalling: (
+    loading: boolean,
+    id?: string,
+    action?: Action,
+  ) => AbortController | undefined;
+
+  /**
+   * Transform tool calls from runtime format to storage format
+   */
+  internal_transformToolCalls: (toolCalls: MessageToolCall[]) => any[];
+
+  /**
+   * Construct tools calling context for plugin invocation
+   */
+  internal_constructToolsCallingContext: (id: string) => ToolsCallingContext | undefined;
+}
+
+export const pluginInternals: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  PluginInternalsAction
+> = (set, get) => ({
+  internal_togglePluginApiCalling: (loading, id, action) => {
+    return get().internal_toggleLoadingArrays('pluginApiLoadingIds', loading, id, action);
+  },
+
+  internal_transformToolCalls: (toolCalls) => {
+    const toolNameResolver = new ToolNameResolver();
+
+    // Build manifests map from tool store
+    const toolStoreState = useToolStore.getState();
+    const manifests: Record<string, LobeChatPluginManifest> = {};
+
+    // Get all installed plugins
+    const installedPlugins = pluginSelectors.installedPlugins(toolStoreState);
+    for (const plugin of installedPlugins) {
+      if (plugin.manifest) {
+        manifests[plugin.identifier] = plugin.manifest as LobeChatPluginManifest;
+      }
+    }
+
+    // Get all builtin tools
+    for (const tool of builtinTools) {
+      if (tool.manifest) {
+        manifests[tool.identifier] = tool.manifest as LobeChatPluginManifest;
+      }
+    }
+
+    return toolNameResolver.resolve(toolCalls, manifests);
+  },
+
+  internal_constructToolsCallingContext: (id: string) => {
+    const message = displayMessageSelectors.getDisplayMessageById(id)(get());
+    if (!message) return;
+
+    return {
+      topicId: message.topicId,
+    };
+  },
+});

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

@@ -0,0 +1,188 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+import { ChatMessageError, ChatToolPayload } from '@lobechat/types';
+import isEqual from 'fast-deep-equal';
+import { StateCreator } from 'zustand/vanilla';
+
+import { messageService } from '@/services/message';
+import { ChatStore } from '@/store/chat/store';
+import { merge } from '@/utils/merge';
+import { safeParseJSON } from '@/utils/safeParseJSON';
+
+import { displayMessageSelectors } from '../../message/selectors';
+
+/**
+ * Optimistic update operations for plugin-related data
+ * All methods follow the pattern: update frontend first, then persist to database
+ */
+export interface PluginOptimisticUpdateAction {
+  /**
+   * Update plugin state with optimistic update
+   */
+  optimisticUpdatePluginState: (id: string, value: any) => Promise<void>;
+
+  /**
+   * Update plugin arguments with optimistic update
+   */
+  optimisticUpdatePluginArguments: <T = any>(
+    id: string,
+    value: T,
+    replace?: boolean,
+  ) => Promise<void>;
+
+  /**
+   * Add tool to assistant message with optimistic update
+   */
+  optimisticAddToolToAssistantMessage: (id: string, tool: ChatToolPayload) => Promise<void>;
+
+  /**
+   * Remove tool from assistant message with optimistic update
+   */
+  optimisticRemoveToolFromAssistantMessage: (id: string, tool_call_id?: string) => Promise<void>;
+
+  /**
+   * Update plugin error with optimistic update
+   */
+  optimisticUpdatePluginError: (id: string, error: ChatMessageError) => Promise<void>;
+
+  /**
+   * Use the optimistic update value to update the message tools to database
+   */
+  internal_refreshToUpdateMessageTools: (id: string) => Promise<void>;
+}
+
+export const pluginOptimisticUpdate: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  PluginOptimisticUpdateAction
+> = (set, get) => ({
+  optimisticUpdatePluginState: async (id, value) => {
+    const { replaceMessages } = get();
+
+    // optimistic update
+    get().internal_dispatchMessage({ id, type: 'updateMessage', value: { pluginState: value } });
+
+    const result = await messageService.updateMessagePluginState(id, value, {
+      sessionId: get().activeId,
+      topicId: get().activeTopicId,
+    });
+
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
+  },
+
+  optimisticUpdatePluginArguments: async (id, value, replace = false) => {
+    const { refreshMessages } = get();
+    const toolMessage = displayMessageSelectors.getDisplayMessageById(id)(get());
+    if (!toolMessage || !toolMessage?.tool_call_id) return;
+
+    let assistantMessage = displayMessageSelectors.getDisplayMessageById(
+      toolMessage?.parentId || '',
+    )(get());
+
+    const prevArguments = toolMessage?.plugin?.arguments;
+    const prevJson = safeParseJSON(prevArguments || '');
+    const nextValue = replace ? (value as any) : merge(prevJson || {}, value);
+    if (isEqual(prevJson, nextValue)) return;
+
+    // optimistic update
+    get().internal_dispatchMessage({
+      id,
+      type: 'updateMessagePlugin',
+      value: { arguments: JSON.stringify(nextValue) },
+    });
+
+    // 同样需要更新 assistantMessage 的 pluginArguments
+    if (assistantMessage) {
+      get().internal_dispatchMessage({
+        id: assistantMessage.id,
+        type: 'updateMessageTools',
+        tool_call_id: toolMessage?.tool_call_id,
+        value: { arguments: JSON.stringify(nextValue) },
+      });
+      assistantMessage = displayMessageSelectors.getDisplayMessageById(assistantMessage?.id)(get());
+    }
+
+    const updateAssistantMessage = async () => {
+      if (!assistantMessage) return;
+      await messageService.updateMessage(assistantMessage!.id, {
+        tools: assistantMessage?.tools,
+      });
+    };
+
+    await Promise.all([
+      messageService.updateMessagePluginArguments(id, nextValue),
+      updateAssistantMessage(),
+    ]);
+
+    await refreshMessages();
+  },
+
+  optimisticAddToolToAssistantMessage: async (id, tool) => {
+    const assistantMessage = displayMessageSelectors.getDisplayMessageById(id)(get());
+    if (!assistantMessage) return;
+
+    const { internal_dispatchMessage, internal_refreshToUpdateMessageTools } = get();
+    internal_dispatchMessage({
+      type: 'addMessageTool',
+      value: tool,
+      id: assistantMessage.id,
+    });
+
+    await internal_refreshToUpdateMessageTools(id);
+  },
+
+  optimisticRemoveToolFromAssistantMessage: async (id, tool_call_id) => {
+    const message = displayMessageSelectors.getDisplayMessageById(id)(get());
+    if (!message || !tool_call_id) return;
+
+    const { internal_dispatchMessage, internal_refreshToUpdateMessageTools } = get();
+
+    // optimistic update
+    internal_dispatchMessage({ type: 'deleteMessageTool', tool_call_id, id: message.id });
+
+    // update the message tools
+    await internal_refreshToUpdateMessageTools(id);
+  },
+
+  optimisticUpdatePluginError: async (id, error) => {
+    const { replaceMessages } = get();
+
+    get().internal_dispatchMessage({ id, type: 'updateMessage', value: { error } });
+    const result = await messageService.updateMessage(
+      id,
+      { error },
+      {
+        sessionId: get().activeId,
+        topicId: get().activeTopicId,
+      },
+    );
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
+  },
+
+  internal_refreshToUpdateMessageTools: async (id) => {
+    const { dbMessageSelectors } = await import('../../message/selectors');
+    const message = dbMessageSelectors.getDbMessageById(id)(get());
+    if (!message || !message.tools) return;
+
+    const { internal_toggleMessageLoading, replaceMessages } = get();
+
+    internal_toggleMessageLoading(true, id);
+    const result = await messageService.updateMessage(
+      id,
+      { tools: message.tools },
+      {
+        sessionId: get().activeId,
+        topicId: get().activeTopicId,
+      },
+    );
+    internal_toggleMessageLoading(false, id);
+
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
+  },
+});

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

@@ -0,0 +1,213 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+import { ChatToolPayload } from '@lobechat/types';
+import { PluginErrorType } from '@lobehub/chat-plugin-sdk';
+import { t } from 'i18next';
+import { StateCreator } from 'zustand/vanilla';
+
+import { MCPToolCallResult } from '@/libs/mcp';
+import { chatService } from '@/services/chat';
+import { mcpService } from '@/services/mcp';
+import { messageService } from '@/services/message';
+import { ChatStore } from '@/store/chat/store';
+import { useToolStore } from '@/store/tool';
+import { safeParseJSON } from '@/utils/safeParseJSON';
+import { setNamespace } from '@/utils/storeDebug';
+
+import { displayMessageSelectors } from '../../message/selectors';
+
+const n = setNamespace('plugin');
+
+/**
+ * Plugin type-specific implementations
+ * Each method handles a specific type of plugin invocation
+ */
+export interface PluginTypesAction {
+  /**
+   * Invoke builtin tool
+   */
+  invokeBuiltinTool: (id: string, payload: ChatToolPayload) => Promise<void>;
+
+  /**
+   * Invoke default type plugin (returns data)
+   */
+  invokeDefaultTypePlugin: (id: string, payload: any) => Promise<string | undefined>;
+
+  /**
+   * Invoke markdown type plugin
+   */
+  invokeMarkdownTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
+
+  /**
+   * Invoke MCP type plugin
+   */
+  invokeMCPTypePlugin: (id: string, payload: ChatToolPayload) => Promise<string | undefined>;
+
+  /**
+   * Invoke standalone type plugin
+   */
+  invokeStandaloneTypePlugin: (id: string, payload: ChatToolPayload) => Promise<void>;
+
+  /**
+   * Internal method to call plugin API
+   */
+  internal_callPluginApi: (id: string, payload: ChatToolPayload) => Promise<string | undefined>;
+}
+
+export const pluginTypes: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  PluginTypesAction
+> = (set, get) => ({
+  invokeBuiltinTool: async (id, payload) => {
+    // run tool api call
+    // @ts-ignore
+    const { [payload.apiName]: action } = get();
+    if (!action) return;
+
+    const content = safeParseJSON(payload.arguments);
+
+    if (!content) return;
+
+    return await action(id, content);
+  },
+
+  invokeDefaultTypePlugin: async (id, payload) => {
+    const { internal_callPluginApi } = get();
+
+    const data = await internal_callPluginApi(id, payload);
+
+    if (!data) return;
+
+    return data;
+  },
+
+  invokeMarkdownTypePlugin: async (id, payload) => {
+    const { internal_callPluginApi } = get();
+
+    await internal_callPluginApi(id, payload);
+  },
+
+  invokeStandaloneTypePlugin: async (id, payload) => {
+    const result = await useToolStore.getState().validatePluginSettings(payload.identifier);
+    if (!result) return;
+
+    // if the plugin settings is not valid, then set the message with error type
+    if (!result.valid) {
+      const updateResult = await messageService.updateMessageError(id, {
+        body: {
+          error: result.errors,
+          message: '[plugin] your settings is invalid with plugin manifest setting schema',
+        },
+        message: t('response.PluginSettingsInvalid', { ns: 'error' }),
+        type: PluginErrorType.PluginSettingsInvalid as any,
+      });
+
+      if (updateResult?.success && updateResult.messages) {
+        get().replaceMessages(updateResult.messages);
+      }
+      return;
+    }
+  },
+
+  invokeMCPTypePlugin: async (id, payload) => {
+    const {
+      optimisticUpdateMessageContent,
+      internal_togglePluginApiCalling,
+      internal_constructToolsCallingContext,
+      optimisticUpdatePluginState,
+      optimisticUpdateMessagePluginError,
+    } = get();
+    let data: MCPToolCallResult | undefined;
+
+    try {
+      const abortController = internal_togglePluginApiCalling(
+        true,
+        id,
+        n('fetchPlugin/start') as string,
+      );
+
+      const context = internal_constructToolsCallingContext(id);
+      const result = await mcpService.invokeMcpToolCall(payload, {
+        signal: abortController?.signal,
+        topicId: context?.topicId,
+      });
+
+      if (!!result) data = result;
+    } catch (error) {
+      console.log(error);
+      const err = error as Error;
+
+      // ignore the aborted request error
+      if (!err.message.includes('The user aborted a request.')) {
+        const result = await messageService.updateMessageError(id, error as any);
+        if (result?.success && result.messages) {
+          get().replaceMessages(result.messages);
+        }
+      }
+    }
+
+    internal_togglePluginApiCalling(false, id, n('fetchPlugin/end') as string);
+
+    // 如果报错则结束了
+
+    if (!data) return;
+
+    await Promise.all([
+      optimisticUpdateMessageContent(id, data.content),
+      (async () => {
+        if (data.success) await optimisticUpdatePluginState(id, data.state);
+        else await optimisticUpdateMessagePluginError(id, data.error);
+      })(),
+    ]);
+
+    return data.content;
+  },
+
+  internal_callPluginApi: async (id, payload) => {
+    const { optimisticUpdateMessageContent, internal_togglePluginApiCalling } = get();
+    let data: string;
+
+    try {
+      const abortController = internal_togglePluginApiCalling(
+        true,
+        id,
+        n('fetchPlugin/start') as string,
+      );
+
+      const message = displayMessageSelectors.getDisplayMessageById(id)(get());
+
+      const res = await chatService.runPluginApi(payload, {
+        signal: abortController?.signal,
+        trace: { observationId: message?.observationId, traceId: message?.traceId },
+      });
+      data = res.text;
+
+      // save traceId
+      if (res.traceId) {
+        await messageService.updateMessage(id, { traceId: res.traceId });
+      }
+    } catch (error) {
+      console.log(error);
+      const err = error as Error;
+
+      // ignore the aborted request error
+      if (!err.message.includes('The user aborted a request.')) {
+        const result = await messageService.updateMessageError(id, error as any);
+        if (result?.success && result.messages) {
+          get().replaceMessages(result.messages);
+        }
+      }
+
+      data = '';
+    }
+
+    internal_togglePluginApiCalling(false, id, n('fetchPlugin/end') as string);
+    // 如果报错则结束了
+    if (!data) return;
+
+    await optimisticUpdateMessageContent(id, data);
+
+    return data;
+  },
+});