@lobehub/chat 1.17.7 → 1.18.0

package/src/{app/api/market/AgentMarket.ts → server/modules/AssistantStore/index.ts}

@@ -4,7 +4,11 @@ import { appEnv } from '@/config/app';
 import { DEFAULT_LANG, isLocaleNotSupport } from '@/const/locale';
 import { Locales, normalizeLocale } from '@/locales/resources';
 
-export class AgentMarket {
+const checkSupportLocale = (lang: Locales) => {
+  return isLocaleNotSupport(lang) || normalizeLocale(lang) !== 'zh-CN';
+};
+
+export class AssistantStore {
   private readonly baseUrl: string;
 
   constructor(baseUrl?: string) {
@@ -12,13 +16,13 @@ export class AgentMarket {
   }
 
   getAgentIndexUrl = (lang: Locales = DEFAULT_LANG) => {
-    if (isLocaleNotSupport(lang)) return this.baseUrl;
+    if (checkSupportLocale(lang)) return this.baseUrl;
 
     return urlJoin(this.baseUrl, `index.${normalizeLocale(lang)}.json`);
   };
 
   getAgentUrl = (identifier: string, lang: Locales = DEFAULT_LANG) => {
-    if (isLocaleNotSupport(lang)) return urlJoin(this.baseUrl, `${identifier}.json`);
+    if (checkSupportLocale(lang)) return urlJoin(this.baseUrl, `${identifier}.json`);
 
     return urlJoin(this.baseUrl, `${identifier}.${normalizeLocale(lang)}.json`);
   };

package/src/{app/api/plugin/store/Store.test.ts → server/modules/PluginStore/index.test.ts}

@@ -1,7 +1,7 @@
 // @vitest-environment node
 import { describe, expect, it, vi } from 'vitest';
 
-import { PluginStore } from './Store';
+import { PluginStore } from './index';
 
 const baseURL = 'https://chat-plugins.lobehub.com';
 

package/src/server/services/discover/index.ts

@@ -0,0 +1,352 @@
+import { cloneDeep, isString, merge, uniqBy } from 'lodash-es';
+import pMap from 'p-map';
+
+import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
+import {
+  DEFAULT_DISCOVER_ASSISTANT_ITEM,
+  DEFAULT_DISCOVER_MODEL_ITEM,
+  DEFAULT_DISCOVER_PLUGIN_ITEM,
+  DEFAULT_DISCOVER_PROVIDER_ITEM,
+} from '@/const/discover';
+import { DEFAULT_LANG } from '@/const/locale';
+import { Locales } from '@/locales/resources';
+import { AssistantStore } from '@/server/modules/AssistantStore';
+import { PluginStore } from '@/server/modules/PluginStore';
+import {
+  AssistantCategory,
+  DiscoverAssistantItem,
+  DiscoverModelItem,
+  DiscoverPlugintem,
+  DiscoverProviderItem,
+  PluginCategory,
+} from '@/types/discover';
+import { getToolManifest } from '@/utils/toolManifest';
+
+const revalidate: number = 3600;
+
+export class DiscoverService {
+  assistantStore = new AssistantStore();
+  pluginStore = new PluginStore();
+
+  // Assistants
+  searchAssistant = async (locale: Locales, keywords: string): Promise<DiscoverAssistantItem[]> => {
+    const list = await this.getAssistantList(locale);
+    return list.filter((item) => {
+      return [item.author, item.meta.title, item.meta.description, item.meta?.tags]
+        .flat()
+        .filter(Boolean)
+        .join(',')
+        .toLowerCase()
+        .includes(decodeURIComponent(keywords).toLowerCase());
+    });
+  };
+
+  getAssistantCategory = async (
+    locale: Locales,
+    category: AssistantCategory,
+  ): Promise<DiscoverAssistantItem[]> => {
+    const list = await this.getAssistantList(locale);
+    return list.filter((item) => item.meta.category === category);
+  };
+
+  getAssistantList = async (locale: Locales): Promise<DiscoverAssistantItem[]> => {
+    let res = await fetch(this.assistantStore.getAgentIndexUrl(locale), {
+      next: { revalidate },
+    });
+
+    if (!res.ok) {
+      res = await fetch(this.assistantStore.getAgentIndexUrl(DEFAULT_LANG), {
+        next: { revalidate },
+      });
+    }
+
+    const json = await res.json();
+
+    return json.agents;
+  };
+
+  getAssistantById = async (
+    locale: Locales,
+    identifier: string,
+  ): Promise<DiscoverAssistantItem | undefined> => {
+    let res = await fetch(this.assistantStore.getAgentUrl(identifier, locale), {
+      next: { revalidate: 12 * revalidate },
+    });
+
+    if (!res.ok) {
+      res = await fetch(this.assistantStore.getAgentUrl(DEFAULT_LANG), {
+        next: { revalidate: 12 * revalidate },
+      });
+    }
+
+    let assistant = await res.json();
+
+    if (!assistant) return;
+
+    assistant = merge(cloneDeep(DEFAULT_DISCOVER_ASSISTANT_ITEM), assistant);
+
+    const categoryItems = await this.getAssistantCategory(
+      locale,
+      assistant.meta.category || AssistantCategory.General,
+    );
+
+    assistant = {
+      ...assistant,
+      suggestions: categoryItems
+        .filter((item) => item.identifier !== assistant.identifier)
+        .slice(0, 5) as any,
+    };
+
+    return assistant;
+  };
+
+  getAssistantByIds = async (
+    locale: Locales,
+    identifiers: string[],
+  ): Promise<DiscoverAssistantItem[]> => {
+    const list = await pMap(
+      identifiers,
+      async (identifier) => this.getAssistantById(locale, identifier),
+      {
+        concurrency: 5,
+      },
+    );
+
+    return list.filter(Boolean) as DiscoverAssistantItem[];
+  };
+
+  // Tools
+
+  searchPlugin = async (locale: Locales, keywords: string): Promise<DiscoverPlugintem[]> => {
+    const list = await this.getPluginList(locale);
+    return list.filter((item) => {
+      return [item.author, item.meta.title, item.meta.description, item.meta?.tags]
+        .flat()
+        .filter(Boolean)
+        .join(',')
+        .toLowerCase()
+        .includes(decodeURIComponent(keywords).toLowerCase());
+    });
+  };
+
+  getPluginCategory = async (
+    locale: Locales,
+    category: PluginCategory,
+  ): Promise<DiscoverPlugintem[]> => {
+    const list = await this.getPluginList(locale);
+    return list.filter((item) => item.meta.category === category);
+  };
+
+  getPluginList = async (locale: Locales): Promise<DiscoverPlugintem[]> => {
+    let res = await fetch(this.pluginStore.getPluginIndexUrl(locale), {
+      next: { revalidate: 12 * revalidate },
+    });
+
+    if (!res.ok) {
+      res = await fetch(this.pluginStore.getPluginIndexUrl(DEFAULT_LANG), {
+        next: { revalidate: 12 * revalidate },
+      });
+    }
+
+    const json = await res.json();
+    return json.plugins;
+  };
+
+  getPluginByIds = async (locale: Locales, identifiers: string[]): Promise<DiscoverPlugintem[]> => {
+    let list = await pMap(
+      identifiers,
+      async (identifier) => this.getPluginById(locale, identifier),
+      {
+        concurrency: 5,
+      },
+    );
+
+    return list.filter(Boolean) as DiscoverPlugintem[];
+  };
+
+  getPluginById = async (
+    locale: Locales,
+    identifier: string,
+    withManifest?: boolean,
+  ): Promise<DiscoverPlugintem | undefined> => {
+    const list = await this.getPluginList(locale);
+    let plugin = list.find((item) => item.identifier === identifier) as DiscoverPlugintem;
+
+    if (!plugin) return;
+
+    plugin = merge(cloneDeep(DEFAULT_DISCOVER_PLUGIN_ITEM), plugin);
+
+    if (withManifest) {
+      const manifest = isString(plugin?.manifest)
+        ? await getToolManifest(plugin.manifest)
+        : plugin?.manifest;
+
+      plugin = {
+        ...plugin,
+        manifest,
+      } as DiscoverPlugintem;
+    }
+
+    const categoryItems = await this.getPluginCategory(
+      locale,
+      plugin.meta.category || PluginCategory.Tools,
+    );
+
+    plugin = {
+      ...plugin,
+      suggestions: categoryItems
+        .filter((item) => item.identifier !== plugin.identifier)
+        .slice(0, 5) as any,
+    } as DiscoverPlugintem;
+
+    return plugin;
+  };
+
+  // Providers
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getProviderList = async (locale: Locales): Promise<DiscoverProviderItem[]> => {
+    const list = DEFAULT_MODEL_PROVIDER_LIST.filter((item) => item.chatModels.length > 0);
+    return list.map((item) => {
+      const provider = {
+        identifier: item.id,
+        meta: {
+          ...item,
+          title: item.name,
+        },
+        models: item.chatModels.map((item) => item.id),
+      };
+      return merge(cloneDeep(DEFAULT_DISCOVER_PROVIDER_ITEM), provider) as DiscoverProviderItem;
+    });
+  };
+
+  searchProvider = async (locale: Locales, keywords: string): Promise<DiscoverProviderItem[]> => {
+    const list = await this.getProviderList(locale);
+    return list.filter((item) => {
+      return [item.identifier, item.meta.title]
+        .filter(Boolean)
+        .join(',')
+        .toLowerCase()
+        .includes(decodeURIComponent(keywords).toLowerCase());
+    });
+  };
+
+  getProviderById = async (
+    locale: Locales,
+    id: string,
+  ): Promise<DiscoverProviderItem | undefined> => {
+    const list = await this.getProviderList(locale);
+    let provider = list.find((item) => item.identifier === id);
+
+    if (!provider) return;
+
+    provider = {
+      ...provider,
+      suggestions: list
+        .filter((item) => item.identifier !== provider?.identifier)
+        .slice(0, 5) as any,
+    };
+
+    return merge(cloneDeep(DEFAULT_DISCOVER_PROVIDER_ITEM), provider) as DiscoverProviderItem;
+  };
+
+  getProviderByIds = async (
+    locale: Locales,
+    identifiers: string[],
+  ): Promise<DiscoverProviderItem[]> => {
+    const list = await pMap(
+      identifiers,
+      async (identifier) => this.getProviderById(locale, identifier),
+      {
+        concurrency: 5,
+      },
+    );
+
+    return list.filter(Boolean) as DiscoverProviderItem[];
+  };
+
+  // Models
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private _getModelList = async (locale: Locales): Promise<DiscoverModelItem[]> => {
+    const list = DEFAULT_MODEL_PROVIDER_LIST.filter((item) => item.chatModels.length > 0);
+    const providers = await this.getProviderList(locale);
+
+    return list.flatMap((provider) => {
+      return provider.chatModels.map((item) => {
+        const ids = item.id.split('/')[1] || item.id;
+        const providerIds = providers
+          .filter((provider) => provider.models.join('').includes(ids))
+          .map((provider) => provider.identifier);
+        const model = {
+          identifier: item.id,
+          meta: {
+            ...item,
+            category: provider.id,
+            title: item.displayName || item.id,
+          },
+          providers: providerIds,
+          suggestions: [],
+        };
+        return merge(cloneDeep(DEFAULT_DISCOVER_MODEL_ITEM), model) as DiscoverModelItem;
+      });
+    });
+  };
+
+  getModelList = async (locale: Locales): Promise<DiscoverModelItem[]> => {
+    const list = await this._getModelList(locale);
+
+    return uniqBy(list, (item) => {
+      const ids = item.identifier.split('/');
+      return ids[1] || item.identifier;
+    });
+  };
+
+  searchModel = async (locale: Locales, keywords: string): Promise<DiscoverModelItem[]> => {
+    const list = await this.getModelList(locale);
+    return list.filter((item) => {
+      return [item.identifier, item.meta.title, item.meta.description, item.providers]
+        .flat()
+        .filter(Boolean)
+        .join(',')
+        .toLowerCase()
+        .includes(decodeURIComponent(keywords).toLowerCase());
+    });
+  };
+
+  getModelCategory = async (locale: Locales, category: string): Promise<DiscoverModelItem[]> => {
+    const list = await this._getModelList(locale);
+    return list.filter((item) => item.meta.category === category);
+  };
+
+  getModelById = async (locale: Locales, id: string): Promise<DiscoverModelItem | undefined> => {
+    const list = await this.getModelList(locale);
+    let model = list.find((item) => item.identifier === id);
+
+    if (!model) return;
+
+    const categoryItems = model?.meta?.category
+      ? await this.getModelCategory(locale, model.meta.category)
+      : [];
+
+    model = {
+      ...model,
+      suggestions: categoryItems
+        .filter((item) => item.identifier !== model?.identifier)
+        .slice(0, 5) as any,
+    };
+
+    return merge(cloneDeep(DEFAULT_DISCOVER_MODEL_ITEM), model);
+  };
+
+  getModelByIds = async (locale: Locales, identifiers: string[]): Promise<DiscoverModelItem[]> => {
+    const list = await pMap(
+      identifiers,
+      async (identifier) => this.getModelById(locale, identifier),
+      {
+        concurrency: 5,
+      },
+    );
+    return list.filter(Boolean) as DiscoverModelItem[];
+  };
+}

package/src/server/services/doc/index.tsx

@@ -0,0 +1,40 @@
+import matter from 'gray-matter';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const LAST_MODIFIED = new Date().toISOString();
+
+export class DocService {
+  async getDocByPath(locale: string, path: string) {
+    const extra = locale === 'zh-CN' ? '.zh-CN.mdx' : '.mdx';
+
+    const localPath = join(process.cwd(), 'docs/', path) + extra;
+
+    const isLocalePathExist = existsSync(localPath);
+
+    if (!isLocalePathExist) return;
+
+    const text: string = readFileSync(localPath, 'utf8');
+
+    if (!text) return;
+
+    const { data, content } = matter(text);
+
+    const regex = /^#\s(.+)/;
+    const match = regex.exec(content);
+    const matches = content.split(regex);
+    const description = matches[1] ? matches[1].trim() : '';
+    return {
+      date: data?.date ? new Date(data.date) : new Date(LAST_MODIFIED),
+      description: description.replaceAll('\n', '').replaceAll('  ', ' ').slice(0, 160),
+      tags: [],
+      title: match ? match[1] : '',
+      ...data,
+      content,
+    };
+  }
+}
+
+// 很奇怪，需要加一行这个 `readdirSync` 才能在 vercel 部署后读到 md 文件
+// 否则没法正常找到 mdx 文件
+readdirSync(join(process.cwd(), 'docs'));

package/src/server/translation.ts

@@ -6,15 +6,20 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { DEFAULT_LANG, LOBE_LOCALE_COOKIE } from '@/const/locale';
-import { NS, normalizeLocale } from '@/locales/resources';
+import { Locales, NS, normalizeLocale } from '@/locales/resources';
 import { isDev } from '@/utils/env';
 
-export const translation = async (ns: NS = 'common') => {
+export const getLocale = async (hl?: string): Promise<Locales> => {
+  if (hl) return normalizeLocale(hl) as Locales;
+  const cookieStore = cookies();
+  const defaultLang = cookieStore.get(LOBE_LOCALE_COOKIE);
+  return (defaultLang?.value || DEFAULT_LANG) as Locales;
+};
+
+export const translation = async (ns: NS = 'common', hl?: string) => {
   let i18ns = {};
+  const lng = await getLocale(hl);
   try {
-    const cookieStore = cookies();
-    const defaultLang = cookieStore.get(LOBE_LOCALE_COOKIE);
-    const lng = defaultLang?.value || DEFAULT_LANG;
     let filepath = join(process.cwd(), `locales/${normalizeLocale(lng)}/${ns}.json`);
     const isExist = existsSync(filepath);
     if (!isExist)
@@ -29,6 +34,7 @@ export const translation = async (ns: NS = 'common') => {
   }
 
   return {
+    locale: lng,
     t: (key: string, options: { [key: string]: string } = {}) => {
       if (!i18ns) return key;
       let content = get(i18ns, key);

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

@@ -78,7 +78,7 @@ getWolframCloudResults guidelines:
 }
 `;
 
-exports[`ToolService > getPluginManifest > support OpenAPI manifest > should get plugin manifest 1`] = `
+exports[`ToolService > getToolManifest > support OpenAPI manifest > should get plugin manifest 1`] = `
 {
   "$schema": "../node_modules/@lobehub/chat-plugin-sdk/schema.json",
   "api": [

package/src/services/{_auth.test.ts → __tests__/_auth.test.ts}

@@ -9,7 +9,7 @@ import {
   UserModelProviderConfig,
 } from '@/types/user/settings';
 
-import { getProviderAuthPayload } from './_auth';
+import { getProviderAuthPayload } from '../_auth';
 
 // Mock data for different providers
 const mockZhiPuAPIKey = 'zhipu-api-key';

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',