@lobehub/lobehub 2.0.0-next.4 → 2.0.0-next.40

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;
+  },
+});

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

@@ -0,0 +1,115 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+import { ChatToolPayload, UIChatMessage } from '@lobechat/types';
+import { StateCreator } from 'zustand/vanilla';
+
+import { ChatStore } from '@/store/chat/store';
+
+import { displayMessageSelectors } from '../../message/selectors';
+
+/**
+ * Public API for plugin operations
+ * These methods are called by UI components or other business scenarios
+ */
+export interface PluginPublicApiAction {
+  /**
+   * Fill plugin message content and optionally trigger AI message
+   */
+  fillPluginMessageContent: (
+    id: string,
+    content: string,
+    triggerAiMessage?: boolean,
+  ) => Promise<void>;
+
+  /**
+   * Re-invoke a tool message (retry failed plugin call)
+   */
+  reInvokeToolMessage: (id: string) => Promise<void>;
+
+  /**
+   * Summary plugin content using AI
+   */
+  summaryPluginContent: (id: string) => Promise<void>;
+
+  /**
+   * Invoke different type of plugin based on payload type
+   * This is the unified entry point for plugin invocation
+   */
+  internal_invokeDifferentTypePlugin: (id: string, payload: ChatToolPayload) => Promise<any>;
+}
+
+export const pluginPublicApi: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  PluginPublicApiAction
+> = (set, get) => ({
+  fillPluginMessageContent: async (id, content, triggerAiMessage) => {
+    const { triggerAIMessage, optimisticUpdateMessageContent } = get();
+
+    await optimisticUpdateMessageContent(id, content);
+
+    if (triggerAiMessage) await triggerAIMessage({ parentId: id });
+  },
+
+  reInvokeToolMessage: async (id) => {
+    const message = displayMessageSelectors.getDisplayMessageById(id)(get());
+    if (!message || message.role !== 'tool' || !message.plugin) return;
+
+    // if there is error content, then clear the error
+    if (!!message.pluginError) {
+      get().optimisticUpdateMessagePluginError(id, null);
+    }
+
+    const payload: ChatToolPayload = { ...message.plugin, id: message.tool_call_id! };
+
+    await get().internal_invokeDifferentTypePlugin(id, payload);
+  },
+
+  summaryPluginContent: async (id) => {
+    const message = displayMessageSelectors.getDisplayMessageById(id)(get());
+    if (!message || message.role !== 'tool') return;
+
+    await get().internal_execAgentRuntime({
+      messages: [
+        {
+          role: 'assistant',
+          content: '作为一名总结专家，请结合以上系统提示词，将以下内容进行总结：',
+        },
+        {
+          ...message,
+          content: message.content,
+          role: 'assistant',
+          name: undefined,
+          tool_call_id: undefined,
+        },
+      ] as UIChatMessage[],
+      parentMessageId: message.id,
+      parentMessageType: 'assistant',
+    });
+  },
+
+  internal_invokeDifferentTypePlugin: async (id, payload) => {
+    switch (payload.type) {
+      case 'standalone': {
+        return await get().invokeStandaloneTypePlugin(id, payload);
+      }
+
+      case 'markdown': {
+        return await get().invokeMarkdownTypePlugin(id, payload);
+      }
+
+      case 'builtin': {
+        return await get().invokeBuiltinTool(id, payload);
+      }
+
+      // @ts-ignore
+      case 'mcp': {
+        return await get().invokeMCPTypePlugin(id, payload);
+      }
+
+      default: {
+        return await get().invokeDefaultTypePlugin(id, payload);
+      }
+    }
+  },
+});