@lobehub/chat 0.120.0 → 0.120.2

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

@@ -12,6 +12,8 @@ import { pluginSelectors } from '@/store/tool/selectors';
 import { ChatPluginPayload } from '@/types/message';
 import { LobeTool } from '@/types/tool';
 
+const invokeStandaloneTypePlugin = useChatStore.getState().invokeStandaloneTypePlugin;
+
 // Mock messageService 和 chatSelectors
 vi.mock('@/services/message', () => ({
   messageService: {
@@ -41,7 +43,7 @@ beforeEach(() => {
 
 describe('ChatPluginAction', () => {
   describe('fillPluginMessageContent', () => {
-    it('should update message content and process the message', async () => {
+    it('should update message content and trigger the ai message', async () => {
       // 设置模拟函数的返回值
       const mockCurrentChats: any[] = [];
       (chatSelectors.currentChats as Mock).mockReturnValue(mockCurrentChats);
@@ -60,7 +62,7 @@ describe('ChatPluginAction', () => {
       const newContent = 'Updated content';
 
       await act(async () => {
-        await result.current.fillPluginMessageContent(messageId, newContent);
+        await result.current.fillPluginMessageContent(messageId, newContent, true);
       });
 
       // 验证 messageService.updateMessageContent 是否被正确调用
@@ -72,6 +74,37 @@ describe('ChatPluginAction', () => {
       // 验证 coreProcessMessage 是否被正确调用
       expect(result.current.coreProcessMessage).toHaveBeenCalledWith(mockCurrentChats, messageId);
     });
+    it('should update message content and not trigger ai message', async () => {
+      // 设置模拟函数的返回值
+      const mockCurrentChats: any[] = [];
+      (chatSelectors.currentChats as Mock).mockReturnValue(mockCurrentChats);
+
+      // 设置初始状态
+      const initialState = {
+        messages: [],
+        coreProcessMessage: vi.fn(),
+        refreshMessages: vi.fn(),
+      };
+      useChatStore.setState(initialState);
+
+      const { result } = renderHook(() => useChatStore());
+
+      const messageId = 'message-id';
+      const newContent = 'Updated content';
+
+      await act(async () => {
+        await result.current.fillPluginMessageContent(messageId, newContent);
+      });
+
+      // 验证 messageService.updateMessageContent 是否被正确调用
+      expect(messageService.updateMessage).toHaveBeenCalledWith(messageId, { content: newContent });
+
+      // 验证 refreshMessages 是否被调用
+      expect(result.current.refreshMessages).toHaveBeenCalled();
+
+      // 验证 coreProcessMessage 没有被正确调用
+      expect(result.current.coreProcessMessage).not.toHaveBeenCalled();
+    });
   });
 
   describe('runPluginDefaultType', () => {
@@ -259,9 +292,92 @@ describe('ChatPluginAction', () => {
         ],
       });
 
+      const invokeStandaloneTypePlugin = useChatStore.getState().invokeStandaloneTypePlugin;
+
+      act(() => {
+        useChatStore.setState({
+          refreshMessages: vi.fn(),
+          invokeStandaloneTypePlugin: vi.fn(),
+        });
+      });
+
+      (chatSelectors.getMessageById as Mock).mockImplementation(() => () => ({
+        id: messageId,
+        content: messageContent,
+      }));
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.triggerFunctionCall(messageId);
+      });
+
+      // 验证 refreshMessages 是否被调用
+      expect(result.current.refreshMessages).toHaveBeenCalled();
+
+      // 验证 invokeDefaultTypePlugin 是否没有被调用，因为类型是 standalone
+      expect(result.current.invokeDefaultTypePlugin).not.toHaveBeenCalled();
+      expect(result.current.invokeStandaloneTypePlugin).toHaveBeenCalled();
+
+      useChatStore.setState({ invokeStandaloneTypePlugin });
+    });
+
+    it('should handle builtin plugin type', async () => {
+      const messageId = 'message-id';
+      const messageContent = JSON.stringify({
+        tool_calls: [
+          {
+            id: 'call_scv',
+            function: {
+              name: `pluginName${PLUGIN_SCHEMA_SEPARATOR}apiName${PLUGIN_SCHEMA_SEPARATOR}builtin`,
+              arguments: {},
+            },
+          },
+        ],
+      });
+
+      const invokeBuiltinTool = useChatStore.getState().invokeBuiltinTool;
+      useChatStore.setState({ refreshMessages: vi.fn(), invokeBuiltinTool: vi.fn() });
+
+      (chatSelectors.getMessageById as Mock).mockImplementation(() => () => ({
+        id: messageId,
+        content: messageContent,
+      }));
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.triggerFunctionCall(messageId);
+      });
+
+      // 验证 refreshMessages 是否被调用
+      expect(result.current.refreshMessages).toHaveBeenCalled();
+
+      // 验证 invokeDefaultTypePlugin 是否没有被调用，因为类型是 standalone
+      expect(result.current.invokeDefaultTypePlugin).not.toHaveBeenCalled();
+      expect(result.current.invokeBuiltinTool).toHaveBeenCalled();
+
+      useChatStore.setState({ invokeBuiltinTool });
+    });
+
+    it('should handle markdown plugin type', async () => {
+      const messageId = 'message-id';
+      const messageContent = JSON.stringify({
+        tool_calls: [
+          {
+            id: 'call_scv',
+            function: {
+              name: `pluginName${PLUGIN_SCHEMA_SEPARATOR}apiName${PLUGIN_SCHEMA_SEPARATOR}markdown`,
+              arguments: {},
+            },
+          },
+        ],
+      });
+
+      const invokeMarkdownTypePlugin = useChatStore.getState().invokeMarkdownTypePlugin;
       useChatStore.setState({
         refreshMessages: vi.fn(),
-        invokeDefaultTypePlugin: vi.fn(),
+        invokeMarkdownTypePlugin: vi.fn(),
       });
 
       (chatSelectors.getMessageById as Mock).mockImplementation(() => () => ({
@@ -278,8 +394,10 @@ describe('ChatPluginAction', () => {
       // 验证 refreshMessages 是否被调用
       expect(result.current.refreshMessages).toHaveBeenCalled();
 
-      // 验证 invokeDefaultTypePlugin 是否没有被调用，因为类型是 standalone
       expect(result.current.invokeDefaultTypePlugin).not.toHaveBeenCalled();
+      expect(result.current.invokeMarkdownTypePlugin).toHaveBeenCalled();
+
+      useChatStore.setState({ invokeMarkdownTypePlugin });
     });
   });
 
@@ -472,6 +590,7 @@ describe('ChatPluginAction', () => {
       expect(result.current.toggleChatLoading).toHaveBeenCalledWith(false);
       expect(useChatStore.getState().text2image).not.toHaveBeenCalled();
     });
+
     it('should handle errors when invoking a builtin tool fails', async () => {
       const payload = {
         apiName: 'builtinApi',
@@ -525,8 +644,10 @@ describe('ChatPluginAction', () => {
       } as ChatPluginPayload;
       const messageId = 'message-id';
 
-      useChatStore.setState({
-        runPluginApi: vi.fn().mockResolvedValue('Markdown response'),
+      const runPluginApiMock = vi.fn();
+
+      act(() => {
+        useChatStore.setState({ runPluginApi: runPluginApiMock });
       });
 
       const { result } = renderHook(() => useChatStore());
@@ -536,7 +657,46 @@ describe('ChatPluginAction', () => {
       });
 
       // Verify that the markdown type plugin was invoked
-      expect(result.current.runPluginApi).toHaveBeenCalledWith(messageId, payload);
+      expect(runPluginApiMock).toHaveBeenCalledWith(messageId, payload);
+    });
+  });
+
+  describe('invokeStandaloneTypePlugin', () => {
+    it('should update message with error and refresh messages if plugin settings are invalid', async () => {
+      const messageId = 'message-id';
+
+      const payload = {
+        identifier: 'pluginName',
+      } as ChatPluginPayload;
+
+      act(() => {
+        useToolStore.setState({
+          validatePluginSettings: vi
+            .fn()
+            .mockResolvedValue({ valid: false, errors: ['Invalid setting'] }),
+        });
+
+        useChatStore.setState({ refreshMessages: vi.fn(), invokeStandaloneTypePlugin });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.invokeStandaloneTypePlugin(messageId, payload);
+      });
+
+      const call = vi.mocked(messageService.updateMessageError).mock.calls[0];
+
+      expect(call[1]).toEqual({
+        body: {
+          error: ['Invalid setting'],
+          message: '[plugin] your settings is invalid with plugin manifest setting schema',
+        },
+        message: undefined,
+        type: 'PluginSettingsInvalid',
+      });
+
+      expect(result.current.refreshMessages).toHaveBeenCalled();
     });
   });
 });

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

@@ -1,3 +1,5 @@
+import { PluginErrorType } from '@lobehub/chat-plugin-sdk';
+import { t } from 'i18next';
 import { Md5 } from 'ts-md5';
 import { StateCreator } from 'zustand/vanilla';
 
@@ -18,10 +20,15 @@ const n = setNamespace('plugin');
 
 export interface ChatPluginAction {
   createAssistantMessageByPlugin: (content: string, parentId: string) => Promise<void>;
-  fillPluginMessageContent: (id: string, content: string) => Promise<void>;
+  fillPluginMessageContent: (
+    id: string,
+    content: string,
+    triggerAiMessage?: boolean,
+  ) => Promise<void>;
   invokeBuiltinTool: (id: string, payload: ChatPluginPayload) => Promise<void>;
   invokeDefaultTypePlugin: (id: string, payload: any) => Promise<void>;
   invokeMarkdownTypePlugin: (id: string, payload: ChatPluginPayload) => Promise<void>;
+  invokeStandaloneTypePlugin: (id: string, payload: ChatPluginPayload) => Promise<void>;
   runPluginApi: (id: string, payload: ChatPluginPayload) => Promise<string | undefined>;
   triggerAIMessage: (id: string) => Promise<void>;
   triggerFunctionCall: (id: string) => Promise<void>;
@@ -47,12 +54,12 @@ export const chatPlugin: StateCreator<
     await get().refreshMessages();
   },
 
-  fillPluginMessageContent: async (id, content) => {
+  fillPluginMessageContent: async (id, content, triggerAiMessage) => {
     const { triggerAIMessage, updateMessageContent } = get();
 
     await updateMessageContent(id, content);
 
-    await triggerAIMessage(id);
+    if (triggerAiMessage) await triggerAIMessage(id);
   },
 
   invokeBuiltinTool: async (id, payload) => {
@@ -103,6 +110,29 @@ export const chatPlugin: StateCreator<
     await runPluginApi(id, payload);
   },
 
+  invokeStandaloneTypePlugin: async (id, payload) => {
+    const result = await useToolStore.getState().validatePluginSettings(payload.identifier);
+    console.log('------------------');
+    console.log(result);
+    console.log('------------------');
+    if (!result) return;
+
+    // if the plugin settings is not valid, then set the message with error type
+    if (!result.valid) {
+      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,
+      });
+
+      await get().refreshMessages();
+      return;
+    }
+  },
+
   runPluginApi: async (id, payload) => {
     const { updateMessageContent, refreshMessages, toggleChatLoading } = get();
     let data: string;
@@ -144,6 +174,7 @@ export const chatPlugin: StateCreator<
     const {
       invokeDefaultTypePlugin,
       invokeMarkdownTypePlugin,
+      invokeStandaloneTypePlugin,
       invokeBuiltinTool,
       refreshMessages,
     } = get();
@@ -192,9 +223,10 @@ export const chatPlugin: StateCreator<
 
     switch (payload.type) {
       case 'standalone': {
-        // TODO: need to auth user's settings
+        await invokeStandaloneTypePlugin(id, payload);
         break;
       }
+
       case 'markdown': {
         await invokeMarkdownTypePlugin(id, payload);
         break;

package/src/store/tool/slices/plugin/__snapshots__/action.test.ts.snap

@@ -0,0 +1,15 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`useToolStore:plugin > validatePluginSettings > should return invalid result if settings do not match the schema 1`] = `
+{
+  "errors": [
+    {
+      "error": "Instance does not have required property "abc".",
+      "instanceLocation": "#",
+      "keyword": "required",
+      "keywordLocation": "#/required",
+    },
+  ],
+  "valid": false,
+}
+`;

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

@@ -1,7 +1,9 @@
+import { LobeChatPluginMeta } from '@lobehub/chat-plugin-sdk';
 import { act, renderHook } from '@testing-library/react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { pluginService } from '@/services/plugin';
+import { LobeTool } from '@/types/tool';
 
 import { useToolStore } from '../../store';
 
@@ -18,6 +20,64 @@ beforeEach(() => {
 });
 
 describe('useToolStore:plugin', () => {
+  describe('checkPluginsIsInstalled', () => {
+    it('should not perform any operations if the plugin list is empty', async () => {
+      const installPluginsMock = vi.fn();
+      useToolStore.setState({
+        loadPluginStore: vi.fn(),
+        installPlugins: installPluginsMock,
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      await act(async () => {
+        await result.current.checkPluginsIsInstalled([]);
+      });
+
+      expect(installPluginsMock).not.toHaveBeenCalled();
+    });
+
+    it('should load the plugin store and install plugins if necessary', async () => {
+      const plugins = ['plugin1', 'plugin2'];
+      const loadPluginStoreMock = vi.fn();
+      const installPluginsMock = vi.fn();
+      useToolStore.setState({
+        loadPluginStore: loadPluginStoreMock,
+        installPlugins: installPluginsMock,
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      await act(async () => {
+        await result.current.checkPluginsIsInstalled(plugins);
+      });
+
+      expect(loadPluginStoreMock).toHaveBeenCalled();
+      expect(installPluginsMock).toHaveBeenCalledWith(plugins);
+    });
+
+    it('should not load the plugin store and install plugins', async () => {
+      const plugins = ['plugin1', 'plugin2'];
+      const loadPluginStoreMock = vi.fn();
+      const installPluginsMock = vi.fn();
+      useToolStore.setState({
+        loadPluginStore: loadPluginStoreMock,
+        installPlugins: installPluginsMock,
+        installedPlugins: [{ identifier: 'abc' }] as LobeTool[],
+        pluginStoreList: [{ identifier: 'abc' }] as LobeChatPluginMeta[],
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      await act(async () => {
+        await result.current.checkPluginsIsInstalled(plugins);
+      });
+
+      expect(loadPluginStoreMock).not.toHaveBeenCalled();
+      expect(installPluginsMock).toHaveBeenCalledWith(plugins);
+    });
+  });
+
   describe('updatePluginSettings', () => {
     it('should update settings for a given plugin', async () => {
       const pluginId = 'test-plugin';
@@ -44,4 +104,66 @@ describe('useToolStore:plugin', () => {
       expect(pluginService.removeAllPlugins).toBeCalled();
     });
   });
+
+  describe('validatePluginSettings', () => {
+    // 模拟插件数据
+    const testPluginId = 'test-plugin';
+    // 定义测试用的 schema 和模拟的验证结果
+    const testSchema = {
+      properties: { abc: { type: 'string' } },
+      required: ['abc'],
+      type: 'object',
+    };
+
+    const testPluginSettings = { abc: 'valid-string' };
+
+    const testPlugin = {
+      type: 'plugin',
+      identifier: testPluginId,
+      manifest: {
+        identifier: testPluginId,
+        settings: testSchema,
+      },
+      settings: testPluginSettings,
+    } as unknown as LobeTool;
+
+    it('should validate settings against the schema and return valid result', async () => {
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        useToolStore.setState({
+          installedPlugins: [testPlugin],
+        });
+      });
+
+      const validationResult = await result.current.validatePluginSettings(testPluginId);
+
+      expect(validationResult).toEqual({ valid: true, errors: [] });
+    });
+
+    it('should return invalid result if settings do not match the schema', async () => {
+      const { result } = renderHook(() => useToolStore());
+      act(() => {
+        useToolStore.setState({
+          installedPlugins: [{ ...testPlugin, settings: {} }] as any,
+        });
+      });
+
+      const validationResult = await result.current.validatePluginSettings(testPluginId);
+
+      expect(validationResult).toMatchSnapshot();
+    });
+
+    it('should return undefined if manifest or settings are not found', async () => {
+      useToolStore.setState({
+        installedPlugins: [],
+      });
+
+      const { result } = renderHook(() => useToolStore());
+
+      const validationResult = await result.current.validatePluginSettings(testPluginId);
+
+      expect(validationResult).toBeUndefined();
+    });
+  });
 });

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

@@ -1,10 +1,12 @@
+import { Schema, ValidationResult } from '@cfworker/json-schema';
 import useSWR, { SWRResponse } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
 import { pluginService } from '@/services/plugin';
-import { pluginStoreSelectors } from '@/store/tool/selectors';
 
 import { ToolStore } from '../../store';
+import { pluginStoreSelectors } from '../store/selectors';
+import { pluginSelectors } from './selectors';
 
 /**
  * 插件接口
@@ -14,6 +16,7 @@ export interface PluginAction {
   removeAllPlugins: () => Promise<void>;
   updatePluginSettings: <T>(id: string, settings: Partial<T>) => Promise<void>;
   useCheckPluginsIsInstalled: (plugins: string[]) => SWRResponse;
+  validatePluginSettings: (identifier: string) => Promise<ValidationResult | undefined>;
 }
 
 export const createPluginSlice: StateCreator<
@@ -45,4 +48,18 @@ export const createPluginSlice: StateCreator<
     await get().refreshPlugins();
   },
   useCheckPluginsIsInstalled: (plugins) => useSWR(plugins, get().checkPluginsIsInstalled),
+  validatePluginSettings: async (identifier) => {
+    const manifest = pluginSelectors.getPluginManifestById(identifier)(get());
+    if (!manifest || !manifest.settings) return;
+    const settings = pluginSelectors.getPluginSettingsById(identifier)(get());
+
+    // validate the settings
+    const { Validator } = await import('@cfworker/json-schema');
+    const validator = new Validator(manifest.settings as Schema);
+    const result = validator.validate(settings);
+
+    if (!result.valid) return { errors: result.errors, valid: false };
+
+    return { errors: [], valid: true };
+  },
 });

package/docs/Development/Data-Store-Selectors.zh-CN.md

@@ -1,68 +0,0 @@
-# 数据存储取数模块
-
-selectors 是 LobeChat 数据流研发框架下的取数模块，它的作用是从 store 中以特定特务逻辑取出数据，供组件消费使用。
-
-以 `src/store/plugin/selectors.ts` 为例：
-
-这个 TypeScript 代码段定义了一个名为 `pluginSelectors` 的对象，该对象包含一系列用于从插件存储状态中检索数据的选择器函数。选择器是一种从 Redux store（或类似的状态管理库）中提取和派生数据的函数。这个特定的例子是为了管理与前端应用程序的插件系统相关的状态。
-
-下面是一些关键点的说明：
-
-- `enabledSchema`: 一个函数，返回一个基于启用插件列表 `enabledPlugins` 过滤后的 `ChatCompletionFunctions` 数组。它将插件标识符作为前缀添加到 API 名称，以确保唯一性，并使用 `uniqBy` 函数从 Lodash 库中删除重复项。
-- `onlinePluginStore`: 返回当前在线插件列表。
-- `pluginList`: 返回插件列表，包括自定义插件和标准插件。
-- `getPluginMetaById`: 根据插件 ID 返回插件元数据。
-- `getDevPluginById`: 返回开发中的自定义插件信息。
-- `getPluginManifestById`: 根据插件 ID 返回插件清单。
-- `getPluginSettingsById`: 根据插件 ID 返回插件设置。
-- `getPluginManifestLoadingStatus`: 根据插件 ID 返回插件清单的加载状态（加载中、成功或错误）。
-- `isCustomPlugin`: 检查给定 ID 的插件是否为自定义插件。
-- `displayPluginList`: 返回一个处理过的插件列表，包括作者、头像、创建时间、描述、首页 URL、标识符和标题。
-- `hasPluginUI`: 根据插件 ID 确定插件是否有 UI 组件。
-
-selectors 是高度模块化和可维护的，它通过将复杂的状态选择逻辑封装在单独的函数中，使得在应用程序的其他部分调用状态数据时，代码更加简洁和直观。此外，由于使用了 TypeScript，每个函数都可以具有明确的输入和输出类型，这有助于提高代码的可靠性和开发效率。
-
-以 `displayPluginList` 方法为例。其代码如下：
-
-```ts
-const pluginList = (s: PluginStoreState) => [...s.pluginList, ...s.customPluginList];
-
-const displayPluginList = (s: PluginStoreState) =>
-  pluginList(s).map((p) => ({
-    author: p.author,
-    avatar: p.meta?.avatar,
-    createAt: p.createAt,
-    desc: pluginHelpers.getPluginDesc(p.meta),
-    homepage: p.homepage,
-    identifier: p.identifier,
-    title: pluginHelpers.getPluginTitle(p.meta),
-  }));
-```
-
-- `pluginList` 方法：用于从插件状态存储 PluginStoreState 中获取所有插件的列表。 它通过结合两个数组：pluginList 和 customPluginList 来创建一个新的插件列表；
-- `displayPluginList` 方法：调用 pluginList 方法来获取合并后的插件列表，转换其中的 title 和 desc 变成显示在 UI 上的文本。
-
-在组件中，只需引入便可直接获取最终消费的数据：
-
-```tsx | pure
-import { usePluginStore } from '@/store/plugin';
-import { pluginSelectors } from '@/store/plugin/selectors';
-
-const Render = ({ plugins }) => {
-  const list = usePluginStore(pluginSelectors.displayPluginList);
-
-  return <> ... </>;
-};
-```
-
-这样实现的好处在于：
-
-1. **解耦和重用**：通过将选择器独立于组件，我们可以在多个组件之间复用这些选择器而不需要重写取数逻辑。这减少了重复代码，提高了开发效率，并且使得代码库更加干净和易于维护。
-2. **性能优化**：选择器可以用来计算派生数据，这样可以避免在每个组件中重复计算相同的数据。当状态发生变化时，只有依赖于这部分状态的选择器才会重新计算，从而减少不必要的渲染和计算。
-3. **易于测试**：选择器是纯函数，它们仅依赖于传入的参数。这意味着它们可以在隔离的环境中进行测试，无需模拟整个 store 或组件树。
-4. **类型安全**：由于 LobeChat 使用 TypeScript，每个选择器都有明确的输入和输出类型定义。这为开发者提供了自动完成和编译时检查的优势，减少了运行时错误。
-5. **可维护性**：选择器集中了状态的读取逻辑，使得跟踪状态的变化和管理更加直观。如果状态结构发生变化，我们只需要更新相应的选择器，而不是搜索和替换整个代码库中的多个位置。
-6. **可组合性**：选择器可以组合其他选择器，以创建更复杂的选择逻辑。这种模式允许开发者构建一个选择器层次结构，使得状态选择更加灵活和强大。
-7. **简化组件逻辑**：组件不需要知道状态的结构或如何获取和计算需要的数据。组件只需调用选择器即可获取渲染所需的数据，这使得组件逻辑变得更简单和清晰。
-
-通过这样的设计，LobeChat 的开发者可以更专注于构建用户界面和业务逻辑，而不必担心数据的获取和处理细节。这种模式也为未来可能的状态结构变更提供了更好的适应性和扩展性。