@lobehub/chat 1.17.6 → 1.18.0

package/src/services/__tests__/assistant.test.ts

@@ -0,0 +1,82 @@
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { globalHelpers } from '@/store/user/helpers';
+
+import { assistantService } from '../assistant';
+
+// Mocking modules and functions
+
+vi.mock('@/store/user/helpers', () => ({
+  globalHelpers: {
+    getCurrentLanguage: vi.fn(),
+  },
+}));
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe('AssistantService', () => {
+  describe('getAssistantList', () => {
+    it('should fetch and return the assistant list', async () => {
+      // Arrange
+      const fakeResponse = { agents: [{ name: 'TestAssisstant' }] };
+      (globalHelpers.getCurrentLanguage as Mock).mockReturnValue('tt');
+      global.fetch = vi.fn(() =>
+        Promise.resolve({
+          json: () => Promise.resolve(fakeResponse),
+        }),
+      ) as any;
+
+      // Act
+      const assistantList = await assistantService.getAssistantList();
+
+      // Assert
+      expect(globalHelpers.getCurrentLanguage).toHaveBeenCalled();
+      expect(fetch).toHaveBeenCalledWith('/api/assistant/store?locale=tt');
+      expect(assistantList).toEqual(fakeResponse.agents);
+    });
+
+    it('should handle fetch error', async () => {
+      // Arrange
+      const fakeUrl = 'http://fake-url.com/plugins.json';
+      (globalHelpers.getCurrentLanguage as Mock).mockReturnValue('en');
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      // Act & Assert
+      await expect(assistantService.getAssistantList()).rejects.toThrow('Network error');
+    });
+  });
+  describe('getAssistantList', () => {
+    it('should fetch and return the assistant list', async () => {
+      // Arrange
+      const fakeResponse = { identifier: 'test-assisstant' };
+      (globalHelpers.getCurrentLanguage as Mock).mockReturnValue('tt');
+      global.fetch = vi.fn(() =>
+        Promise.resolve({
+          json: () => Promise.resolve(fakeResponse),
+        }),
+      ) as any;
+
+      // Act
+      const assistant = await assistantService.getAssistantById('test-assisstant');
+
+      // Assert
+      expect(globalHelpers.getCurrentLanguage).toHaveBeenCalled();
+      expect(fetch).toHaveBeenCalledWith('/api/assistant/test-assisstant?locale=tt');
+      expect(assistant.identifier).toEqual(fakeResponse.identifier);
+    });
+
+    it('should handle fetch error', async () => {
+      // Arrange
+      const fakeUrl = 'http://fake-url.com/plugins.json';
+      (globalHelpers.getCurrentLanguage as Mock).mockReturnValue('en');
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      // Act & Assert
+      await expect(assistantService.getAssistantById('test-assisstant')).rejects.toThrow(
+        'Network error',
+      );
+    });
+  });
+});

package/src/services/__tests__/tool.test.ts

@@ -19,7 +19,7 @@ beforeEach(() => {
 });
 
 describe('ToolService', () => {
-  describe('getPluginList', () => {
+  describe('getToolList', () => {
     it('should fetch and return the plugin list', async () => {
       // Arrange
       const fakeResponse = { plugins: [{ name: 'TestPlugin' }] };
@@ -31,12 +31,12 @@ describe('ToolService', () => {
       ) as any;
 
       // Act
-      const pluginList = await toolService.getPluginList();
+      const pluginList = await toolService.getToolList();
 
       // Assert
       expect(globalHelpers.getCurrentLanguage).toHaveBeenCalled();
       expect(fetch).toHaveBeenCalledWith('/api/plugin/store?locale=tt');
-      expect(pluginList).toEqual(fakeResponse);
+      expect(pluginList).toEqual(fakeResponse.plugins);
     });
 
     it('should handle fetch error', async () => {
@@ -46,11 +46,11 @@ describe('ToolService', () => {
       global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
 
       // Act & Assert
-      await expect(toolService.getPluginList()).rejects.toThrow('Network error');
+      await expect(toolService.getToolList()).rejects.toThrow('Network error');
     });
   });
 
-  describe('getPluginManifest', () => {
+  describe('getToolManifest', () => {
     it('should return manifest', async () => {
       const manifestUrl = 'http://fake-url.com/manifest.json';
 
@@ -98,7 +98,7 @@ describe('ToolService', () => {
         }),
       ) as any;
 
-      const manifest = await toolService.getPluginManifest(manifestUrl);
+      const manifest = await toolService.getToolManifest(manifestUrl);
 
       expect(fetch).toHaveBeenCalledWith(manifestUrl);
       expect(manifest).toEqual(fakeManifest);
@@ -106,7 +106,7 @@ describe('ToolService', () => {
 
     it('should return error on noManifest', async () => {
       try {
-        await toolService.getPluginManifest();
+        await toolService.getToolManifest();
       } catch (e) {
         expect(e).toEqual(new TypeError('noManifest'));
       }
@@ -124,7 +124,7 @@ describe('ToolService', () => {
       ) as any;
 
       try {
-        await toolService.getPluginManifest(manifestUrl);
+        await toolService.getToolManifest(manifestUrl);
       } catch (e) {
         expect(e).toEqual(new TypeError('manifestInvalid'));
       }
@@ -135,7 +135,7 @@ describe('ToolService', () => {
       global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
 
       try {
-        await toolService.getPluginManifest(manifestUrl);
+        await toolService.getToolManifest(manifestUrl);
       } catch (e) {
         expect(e).toEqual(new TypeError('fetchError'));
       }
@@ -156,7 +156,7 @@ describe('ToolService', () => {
       ) as any;
 
       try {
-        await toolService.getPluginManifest(manifestUrl);
+        await toolService.getToolManifest(manifestUrl);
       } catch (e) {
         expect(e).toEqual(new TypeError('urlError'));
       }
@@ -174,7 +174,7 @@ describe('ToolService', () => {
       ) as any;
 
       try {
-        await toolService.getPluginManifest(manifestUrl);
+        await toolService.getToolManifest(manifestUrl);
       } catch (e) {
         expect(e).toEqual(new TypeError('fetchError'));
       }
@@ -214,7 +214,7 @@ describe('ToolService', () => {
           }),
         ) as any;
 
-        const manifest = await toolService.getPluginManifest(manifestUrl);
+        const manifest = await toolService.getToolManifest(manifestUrl);
 
         expect(manifest).toMatchSnapshot();
       });
@@ -252,7 +252,7 @@ describe('ToolService', () => {
         ) as any;
 
         try {
-          await toolService.getPluginManifest(manifestUrl);
+          await toolService.getToolManifest(manifestUrl);
         } catch (e) {
           expect(e).toEqual(new TypeError('openAPIInvalid'));
         }

package/src/services/_url.ts

@@ -21,8 +21,8 @@ export const API_ENDPOINTS = mapWithBasePath({
   oauth: '/api/auth',
 
   // agent markets
-  market: '/api/market',
-  marketItem: (identifier: string) => withBasePath(`/api/market/${identifier}`),
+  assistantStore: '/api/assistant/store',
+  assistant: (identifier: string) => withBasePath(`/api/assistant/${identifier}`),
 
   // plugins
   gateway: '/api/plugin/gateway',

package/src/services/assistant.ts

@@ -0,0 +1,30 @@
+import { cloneDeep, merge } from 'lodash-es';
+
+import { DEFAULT_DISCOVER_ASSISTANT_ITEM } from '@/const/discover';
+import { globalHelpers } from '@/store/user/helpers';
+import { DiscoverAssistantItem } from '@/types/discover';
+
+import { API_ENDPOINTS } from './_url';
+
+class AssistantService {
+  getAssistantList = async (): Promise<DiscoverAssistantItem[]> => {
+    const locale = globalHelpers.getCurrentLanguage();
+
+    const res = await fetch(`${API_ENDPOINTS.assistantStore}?locale=${locale}`);
+
+    const json = await res.json();
+
+    return json.agents;
+  };
+
+  getAssistantById = async (identifier: string): Promise<DiscoverAssistantItem> => {
+    const locale = globalHelpers.getCurrentLanguage();
+
+    const res = await fetch(`${API_ENDPOINTS.assistant(identifier)}?locale=${locale}`);
+
+    const assistant: DiscoverAssistantItem = await res.json();
+
+    return merge(cloneDeep(DEFAULT_DISCOVER_ASSISTANT_ITEM), assistant);
+  };
+}
+export const assistantService = new AssistantService();

package/src/services/chat.ts

@@ -335,7 +335,7 @@ class ChatService {
     const s = useToolStore.getState();
 
     const settings = pluginSelectors.getPluginSettingsById(params.identifier)(s);
-    const manifest = pluginSelectors.getPluginManifestById(params.identifier)(s);
+    const manifest = pluginSelectors.getToolManifestById(params.identifier)(s);
 
     const traceHeader = createTraceHeader(this.mapTrace(options?.trace, TraceTagMap.ToolCalling));
 

package/src/services/tool.ts

@@ -1,144 +1,22 @@
-import {
-  LobeChatPluginManifest,
-  LobeChatPluginsMarketIndex,
-  pluginManifestSchema,
-} from '@lobehub/chat-plugin-sdk';
-
 import { globalHelpers } from '@/store/user/helpers';
-import { OpenAIPluginManifest } from '@/types/openai/plugin';
+import { DiscoverPlugintem } from '@/types/discover';
+import { convertOpenAIManifestToLobeManifest, getToolManifest } from '@/utils/toolManifest';
 
 import { API_ENDPOINTS } from './_url';
 
 class ToolService {
-  private _fetchJSON = async <T = any>(url: string, proxy = false): Promise<T> => {
-    // 2. 发送请求
-    let res: Response;
-    try {
-      res = await (proxy ? fetch(API_ENDPOINTS.proxy, { body: url, method: 'POST' }) : fetch(url));
-    } catch {
-      throw new TypeError('fetchError');
-    }
-
-    if (!res.ok) {
-      throw new TypeError('fetchError');
-    }
-
-    let data;
-    const contentType = res.headers.get('Content-Type');
-
-    try {
-      if (contentType === 'application/json') {
-        data = await res.json();
-      } else {
-        const { default: YAML } = await import('yaml');
-
-        const yaml = await res.text();
-        data = YAML.parse(yaml);
-      }
-    } catch {
-      throw new TypeError('urlError');
-    }
-
-    return data;
-  };
-  /**
-   * get plugin list from store
-   */
-  getPluginList = async (): Promise<LobeChatPluginsMarketIndex> => {
+  getToolList = async (): Promise<DiscoverPlugintem[]> => {
     const locale = globalHelpers.getCurrentLanguage();
 
     const res = await fetch(`${API_ENDPOINTS.pluginStore}?locale=${locale}`);
 
-    return res.json();
-  };
-
-  getPluginManifest = async (
-    url?: string,
-    useProxy: boolean = false,
-  ): Promise<LobeChatPluginManifest> => {
-    // 1. valid plugin
-    if (!url) {
-      throw new TypeError('noManifest');
-    }
-
-    // 2. 发送请求
+    const json = await res.json();
 
-    let data = await this._fetchJSON<LobeChatPluginManifest>(url, useProxy);
-
-    // @ts-ignore
-    // if there is a description_for_model, it is an OpenAI plugin
-    // we need convert to lobe plugin
-    if (data['description_for_model']) {
-      data = this.convertOpenAIManifestToLobeManifest(data as any);
-    }
-
-    // 3. 校验插件文件格式规范
-    const parser = pluginManifestSchema.safeParse(data);
-
-    if (!parser.success) {
-      throw new TypeError('manifestInvalid', { cause: parser.error });
-    }
-
-    // 4. if exist OpenAPI api, merge the OpenAPIs to api
-    if (parser.data.openapi) {
-      const openapiJson = await this._fetchJSON(parser.data.openapi, useProxy);
-
-      try {
-        const { OpenAPIConvertor } = await import('@lobehub/chat-plugin-sdk/openapi');
-
-        const convertor = new OpenAPIConvertor(openapiJson);
-        const openAPIs = await convertor.convertOpenAPIToPluginSchema();
-        data.api = [...data.api, ...openAPIs];
-
-        data.settings = await convertor.convertAuthToSettingsSchema(data.settings);
-      } catch (error) {
-        throw new TypeError('openAPIInvalid', { cause: error });
-      }
-    }
-
-    return data;
+    return json.plugins;
   };
 
-  private convertOpenAIManifestToLobeManifest = (
-    data: OpenAIPluginManifest,
-  ): LobeChatPluginManifest => {
-    const manifest: LobeChatPluginManifest = {
-      api: [],
-      homepage: data.legal_info_url,
-      identifier: data.name_for_model,
-      meta: {
-        avatar: data.logo_url,
-        description: data.description_for_human,
-        title: data.name_for_human,
-      },
-      openapi: data.api.url,
-      systemRole: data.description_for_model,
-      type: 'default',
-      version: '1',
-    };
-    switch (data.auth.type) {
-      case 'none': {
-        break;
-      }
-      case 'service_http': {
-        manifest.settings = {
-          properties: {
-            apiAuthKey: {
-              default: data.auth.verification_tokens['openai'],
-              description: 'API Key',
-              format: 'password',
-              title: 'API Key',
-              type: 'string',
-            },
-          },
-          type: 'object',
-        };
-        break;
-      }
-    }
-
-    return manifest;
-  };
+  getToolManifest = getToolManifest;
+  convertOpenAIManifestToLobeManifest = convertOpenAIManifestToLobeManifest;
 }
 
 export const toolService = new ToolService();

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

@@ -33,6 +33,118 @@ afterEach(() => {
 });
 
 describe('ChatPluginAction', () => {
+  describe('summaryPluginContent', () => {
+    it('should summarize plugin content', async () => {
+      const messageId = 'message-id';
+      const toolMessage = {
+        id: messageId,
+        role: 'tool',
+        content: 'Tool content to summarize',
+      } as ChatMessage;
+
+      const internal_coreProcessMessageMock = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-id',
+          messagesMap: { [messageMapKey('session-id')]: [toolMessage] },
+          internal_coreProcessMessage: internal_coreProcessMessageMock,
+        });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.summaryPluginContent(messageId);
+      });
+
+      expect(internal_coreProcessMessageMock).toHaveBeenCalledWith(
+        [
+          {
+            role: 'assistant',
+            content: '作为一名总结专家，请结合以上系统提示词，将以下内容进行总结：',
+          },
+          {
+            ...toolMessage,
+            meta: {
+              avatar: '🤯',
+              backgroundColor: 'rgba(0,0,0,0)',
+              description: undefined,
+              title: undefined,
+            },
+            content: toolMessage.content,
+            role: 'assistant',
+            name: undefined,
+            tool_call_id: undefined,
+          },
+        ],
+        messageId,
+      );
+    });
+
+    it('should not summarize non-tool messages', async () => {
+      const messageId = 'message-id';
+      const nonToolMessage = {
+        id: messageId,
+        role: 'user',
+        content: 'User message',
+      } as ChatMessage;
+
+      const internal_coreProcessMessageMock = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-id',
+          messagesMap: { [messageMapKey('session-id')]: [nonToolMessage] },
+          internal_coreProcessMessage: internal_coreProcessMessageMock,
+        });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.summaryPluginContent(messageId);
+      });
+
+      expect(internal_coreProcessMessageMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('internal_togglePluginApiCalling', () => {
+    it('should toggle plugin API calling state', () => {
+      const internal_toggleLoadingArraysMock = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          internal_toggleLoadingArrays: internal_toggleLoadingArraysMock,
+        });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+
+      const messageId = 'message-id';
+      const action = 'test-action';
+
+      result.current.internal_togglePluginApiCalling(true, messageId, action);
+
+      expect(internal_toggleLoadingArraysMock).toHaveBeenCalledWith(
+        'pluginApiLoadingIds',
+        true,
+        messageId,
+        action,
+      );
+
+      result.current.internal_togglePluginApiCalling(false, messageId, action);
+
+      expect(internal_toggleLoadingArraysMock).toHaveBeenCalledWith(
+        'pluginApiLoadingIds',
+        false,
+        messageId,
+        action,
+      );
+    });
+  });
+
   describe('fillPluginMessageContent', () => {
     it('should update message content and trigger the ai message', async () => {
       // 设置模拟函数的返回值

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

@@ -445,9 +445,7 @@ export const chatPlugin: StateCreator<
         // if the apiName is md5, try to find the correct apiName in the plugins
         if (apiName.startsWith(PLUGIN_SCHEMA_API_MD5_PREFIX)) {
           const md5 = apiName.replace(PLUGIN_SCHEMA_API_MD5_PREFIX, '');
-          const manifest = pluginSelectors.getPluginManifestById(identifier)(
-            useToolStore.getState(),
-          );
+          const manifest = pluginSelectors.getToolManifestById(identifier)(useToolStore.getState());
 
           const api = manifest?.api.find((api) => Md5.hashStr(api.name).toString() === md5);
           if (api) {

package/src/store/global/initialState.ts

@@ -5,8 +5,8 @@ import { AsyncLocalStorage } from '@/utils/localStorage';
 
 export enum SidebarTabKey {
   Chat = 'chat',
+  Discover = 'discover',
   Files = 'files',
-  Market = 'market',
   Me = 'me',
   Setting = 'settings',
 }

package/src/store/tool/selectors/tool.test.ts

@@ -154,7 +154,7 @@ describe('toolSelectors', () => {
     });
   });
 
-  describe('getPluginManifestLoadingStatus', () => {
+  describe('getToolManifestLoadingStatus', () => {
     it('should return "loading" if the plugin manifest is being loaded', () => {
       const result = toolSelectors.getManifestLoadingStatus('plugin-2')(mockState);
       expect(result).toBe('loading');

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

@@ -21,7 +21,7 @@ vi.mock('@/services/plugin', () => ({
 
 vi.mock('@/services/tool', () => ({
   toolService: {
-    getPluginManifest: vi.fn(),
+    getToolManifest: vi.fn(),
   },
 }));
 

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

@@ -42,7 +42,7 @@ export const createCustomPluginSlice: StateCreator<
     const { refreshPlugins, updateInstallLoadingState } = get();
     try {
       updateInstallLoadingState(id, true);
-      const manifest = await toolService.getPluginManifest(
+      const manifest = await toolService.getToolManifest(
         plugin.customParams?.manifestUrl,
         plugin.customParams?.useProxy,
       );

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

@@ -61,7 +61,7 @@ export const createPluginSlice: StateCreator<
   },
   useCheckPluginsIsInstalled: (plugins) => useSWR(plugins, get().checkPluginsIsInstalled),
   validatePluginSettings: async (identifier) => {
-    const manifest = pluginSelectors.getPluginManifestById(identifier)(get());
+    const manifest = pluginSelectors.getToolManifestById(identifier)(get());
     if (!manifest || !manifest.settings) return;
     const settings = pluginSelectors.getPluginSettingsById(identifier)(get());
 

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

@@ -58,9 +58,9 @@ const mockState = {
 } as ToolStoreState;
 
 describe('pluginSelectors', () => {
-  describe('getPluginManifestById', () => {
-    it('getPluginManifestById should return the correct manifest', () => {
-      const result = pluginSelectors.getPluginManifestById('plugin-1')(mockState);
+  describe('getToolManifestById', () => {
+    it('getToolManifestById should return the correct manifest', () => {
+      const result = pluginSelectors.getToolManifestById('plugin-1')(mockState);
       expect(result).toEqual(mockState.installedPlugins[0].manifest);
     });
   });

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

@@ -27,7 +27,7 @@ const getCustomPluginById = (id: string) => (s: ToolStoreState) =>
     | LobeToolCustomPlugin
     | undefined;
 
-const getPluginManifestById = (id: string) => (s: ToolStoreState) =>
+const getToolManifestById = (id: string) => (s: ToolStoreState) =>
   getInstalledPluginById(id)(s)?.manifest;
 
 const getPluginSettingsById = (id: string) => (s: ToolStoreState) =>
@@ -59,7 +59,7 @@ const installedCustomPluginMetaList = (s: ToolStoreState) =>
   installedPluginMetaList(s).filter((p) => p.type === 'customPlugin');
 
 const isPluginHasUI = (id: string) => (s: ToolStoreState) => {
-  const plugin = getPluginManifestById(id)(s);
+  const plugin = getToolManifestById(id)(s);
 
   return !!plugin?.ui;
 };
@@ -67,9 +67,9 @@ const isPluginHasUI = (id: string) => (s: ToolStoreState) => {
 export const pluginSelectors = {
   getCustomPluginById,
   getInstalledPluginById,
-  getPluginManifestById,
   getPluginMetaById,
   getPluginSettingsById,
+  getToolManifestById,
   installedCustomPluginMetaList,
   installedPluginManifestList,
   installedPluginMetaList,