@lobehub/chat 1.17.6 → 1.18.0

package/src/server/metadata.ts

@@ -1,7 +1,10 @@
 import { Metadata } from 'next';
+import qs from 'query-string';
 
 import { BRANDING_NAME } from '@/const/branding';
+import { DEFAULT_LANG } from '@/const/locale';
 import { OG_URL, getCanonicalUrl } from '@/const/url';
+import { Locales, locales } from '@/locales/resources';
 import { formatDescLength, formatTitleLength } from '@/utils/genOG';
 
 export class Meta {
@@ -12,9 +15,13 @@ export class Meta {
     url,
     type = 'website',
     tags,
+    alternate,
+    locale = DEFAULT_LANG,
   }: {
+    alternate?: boolean;
     description?: string;
     image?: string;
+    locale?: Locales;
     tags?: string[];
     title: string;
     type?: 'website' | 'article';
@@ -26,11 +33,16 @@ export class Meta {
     const formatedDescription = formatDescLength(description, tags);
     const siteTitle = title.includes(BRANDING_NAME) ? title : title + ` · ${BRANDING_NAME}`;
     return {
-      alternates: { canonical: getCanonicalUrl(url) },
+      alternates: {
+        canonical: getCanonicalUrl(url),
+        languages: alternate ? this.genAlternateLocales(locale, url) : undefined,
+      },
       description: formatedDescription,
       openGraph: this.genOpenGraph({
+        alternate,
         description,
         image,
+        locale,
         title: siteTitle,
         type,
         url,
@@ -43,6 +55,22 @@ export class Meta {
     };
   }
 
+  private genAlternateLocales = (locale: Locales, path: string = '/') => {
+    let links: any = {};
+    const defaultLink = getCanonicalUrl(path);
+    for (const alterLocales of locales) {
+      if (locale === alterLocales) continue;
+      links[alterLocales] = qs.stringifyUrl({
+        query: { hl: alterLocales },
+        url: defaultLink,
+      });
+    }
+    return {
+      'x-default': defaultLink,
+      ...links,
+    };
+  };
+
   private genTwitter({
     description,
     title,
@@ -65,19 +93,23 @@ export class Meta {
   }
 
   private genOpenGraph({
+    alternate,
+    locale = DEFAULT_LANG,
     description,
     title,
     image,
     url,
     type = 'website',
   }: {
+    alternate?: boolean;
     description: string;
     image: string;
+    locale: Locales;
     title: string;
     type?: 'website' | 'article';
     url: string;
   }) {
-    return {
+    const data: any = {
       description,
       images: [
         {
@@ -85,12 +117,18 @@ export class Meta {
           url: image,
         },
       ],
-      locale: 'en-US',
+      locale,
       siteName: 'LobeChat',
       title,
       type,
       url,
     };
+
+    if (alternate) {
+      data['alternateLocale'] = locales.filter((l) => l !== locale);
+    }
+
+    return data;
   }
 }
 

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

@@ -1,54 +1,54 @@
 // @vitest-environment node
 import { describe, expect, it } from 'vitest';
 
-import { AgentMarket } from './AgentMarket';
+import { AssistantStore } from './index';
 
 const baseURL = 'https://chat-agents.lobehub.com';
-describe('AgentMarket', () => {
+describe('AssistantStore', () => {
   it('should return the default index URL when no language is provided', () => {
-    const agentMarket = new AgentMarket();
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentIndexUrl();
     expect(url).toBe(baseURL);
   });
 
-  it('should return the index URL for a supported language', () => {
-    const agentMarket = new AgentMarket();
+  it('should return the index URL for a not supported language', () => {
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentIndexUrl('ko-KR');
-    expect(url).toBe('https://chat-agents.lobehub.com/index.ko-KR.json');
+    expect(url).toBe('https://chat-agents.lobehub.com');
   });
 
   it('should return the zh-CN URL for zh locale', () => {
-    const agentMarket = new AgentMarket();
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentIndexUrl('zh' as any);
     expect(url).toBe('https://chat-agents.lobehub.com/index.zh-CN.json');
   });
 
   it('should return the default URL for en locale', () => {
-    const agentMarket = new AgentMarket();
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentIndexUrl('en' as any);
     expect(url).toBe('https://chat-agents.lobehub.com');
   });
 
   it('should return the base URL if the provided language is not supported', () => {
-    const agentMarket = new AgentMarket();
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentIndexUrl('fr' as any);
     expect(url).toBe(baseURL);
   });
 
   it('should return the agent URL with default language when no language is provided', () => {
-    const agentMarket = new AgentMarket();
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentUrl('agent-123');
     expect(url).toBe(`${baseURL}/agent-123.json`);
   });
 
-  it('should return the agent URL for a supported language', () => {
-    const agentMarket = new AgentMarket();
-    const url = agentMarket.getAgentUrl('agent-123', 'es-ES');
-    expect(url).toBe(`${baseURL}/agent-123.es-ES.json`);
+  it('should return the agent URL for a  supported language', () => {
+    const agentMarket = new AssistantStore();
+    const url = agentMarket.getAgentUrl('agent-123', 'zh-CN');
+    expect(url).toBe(`${baseURL}/agent-123.zh-CN.json`);
   });
 
   it('should return the agent URL without language suffix if the provided language is not supported', () => {
-    const agentMarket = new AgentMarket();
+    const agentMarket = new AssistantStore();
     const url = agentMarket.getAgentUrl('agent-123', 'fr' as any);
     expect(url).toBe(`${baseURL}/agent-123.json`);
   });

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