@lobehub/chat 1.96.19 → 1.97.0

package/src/server/sitemap.test.ts

@@ -2,7 +2,6 @@
 import { describe, expect, it, vi } from 'vitest';
 
 import { getCanonicalUrl } from '@/server/utils/url';
-import { AssistantCategory, PluginCategory } from '@/types/discover';
 
 import { LAST_MODIFIED, Sitemap, SitemapType } from './sitemap';
 
@@ -10,19 +9,32 @@ describe('Sitemap', () => {
   const sitemap = new Sitemap();
 
   describe('getIndex', () => {
-    it('should return a valid sitemap index', () => {
-      const index = sitemap.getIndex();
+    it('should return a valid sitemap index with pagination', async () => {
+      // Mock the page count methods to return specific values for testing
+      vi.spyOn(sitemap, 'getPluginPageCount').mockResolvedValue(2);
+      vi.spyOn(sitemap, 'getAssistantPageCount').mockResolvedValue(3);
+      vi.spyOn(sitemap, 'getMcpPageCount').mockResolvedValue(1);
+      vi.spyOn(sitemap, 'getModelPageCount').mockResolvedValue(2);
+
+      const index = await sitemap.getIndex();
       expect(index).toContain('<?xml version="1.0" encoding="UTF-8"?>');
       expect(index).toContain('<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
-      [
-        SitemapType.Pages,
-        SitemapType.Assistants,
-        SitemapType.Plugins,
-        SitemapType.Models,
-        SitemapType.Providers,
-      ].forEach((type) => {
+
+      // Check static sitemaps
+      [SitemapType.Pages, SitemapType.Providers].forEach((type) => {
         expect(index).toContain(`<loc>${getCanonicalUrl(`/sitemap/${type}.xml`)}</loc>`);
       });
+
+      // Check paginated sitemaps
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/plugins-1.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/plugins-2.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/assistants-1.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/assistants-2.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/assistants-3.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/mcp-1.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/models-1.xml')}</loc>`);
+      expect(index).toContain(`<loc>${getCanonicalUrl('/sitemap/models-2.xml')}</loc>`);
+
       expect(index).toContain(`<lastmod>${LAST_MODIFIED}</lastmod>`);
     });
   });
@@ -44,32 +56,29 @@ describe('Sitemap', () => {
           priority: 0.7,
         }),
       );
-      Object.values(AssistantCategory).forEach((category) => {
-        expect(pageSitemap).toContainEqual(
-          expect.objectContaining({
-            url: getCanonicalUrl(`/discover/assistants/${category}`),
-            changeFrequency: 'daily',
-            priority: 0.7,
-          }),
-        );
-      });
-      Object.values(PluginCategory).forEach((category) => {
-        expect(pageSitemap).toContainEqual(
-          expect.objectContaining({
-            url: getCanonicalUrl(`/discover/plugins/${category}`),
-            changeFrequency: 'daily',
-            priority: 0.7,
-          }),
-        );
-      });
+      // Note: The actual implementation generates URLs like /discover/assistant and /discover/plugin (not category-specific)
+      expect(pageSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/assistant'),
+          changeFrequency: 'daily',
+          priority: 0.7,
+        }),
+      );
+      expect(pageSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/plugin'),
+          changeFrequency: 'daily',
+          priority: 0.7,
+        }),
+      );
     });
   });
 
   describe('getAssistants', () => {
-    it('should return a valid assistants sitemap', async () => {
-      vi.spyOn(sitemap['discoverService'], 'getAssistantList').mockResolvedValue([
+    it('should return a valid assistants sitemap without pagination', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getAssistantIdentifiers').mockResolvedValue([
         // @ts-ignore
-        { identifier: 'test-assistant', createdAt: '2023-01-01' },
+        { identifier: 'test-assistant', lastModified: '2023-01-01' },
       ]);
 
       const assistantsSitemap = await sitemap.getAssistants();
@@ -87,13 +96,45 @@ describe('Sitemap', () => {
         }),
       );
     });
+
+    it('should return a valid assistants sitemap with pagination', async () => {
+      const mockAssistants = Array.from({ length: 150 }, (_, i) => ({
+        identifier: `test-assistant-${i}`,
+        lastModified: '2023-01-01',
+      }));
+
+      vi.spyOn(sitemap['discoverService'], 'getAssistantIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        mockAssistants,
+      );
+
+      // Test first page (should have 100 items)
+      const firstPageSitemap = await sitemap.getAssistants(1);
+      expect(firstPageSitemap.length).toBe(100 * 15); // 100 items * 15 locales
+      expect(firstPageSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/assistant/test-assistant-0'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+
+      // Test second page (should have 50 items)
+      const secondPageSitemap = await sitemap.getAssistants(2);
+      expect(secondPageSitemap.length).toBe(50 * 15); // 50 items * 15 locales
+      expect(secondPageSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/assistant/test-assistant-100'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+    });
   });
 
   describe('getPlugins', () => {
-    it('should return a valid plugins sitemap', async () => {
-      vi.spyOn(sitemap['discoverService'], 'getPluginList').mockResolvedValue([
+    it('should return a valid plugins sitemap without pagination', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getPluginIdentifiers').mockResolvedValue([
         // @ts-ignore
-        { identifier: 'test-plugin', createdAt: '2023-01-01' },
+        { identifier: 'test-plugin', lastModified: '2023-01-01' },
       ]);
 
       const pluginsSitemap = await sitemap.getPlugins();
@@ -111,13 +152,33 @@ describe('Sitemap', () => {
         }),
       );
     });
+
+    it('should return a valid plugins sitemap with pagination', async () => {
+      const mockPlugins = Array.from({ length: 250 }, (_, i) => ({
+        identifier: `test-plugin-${i}`,
+        lastModified: '2023-01-01',
+      }));
+
+      vi.spyOn(sitemap['discoverService'], 'getPluginIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        mockPlugins,
+      );
+
+      // Test first page (should have 100 items)
+      const firstPageSitemap = await sitemap.getPlugins(1);
+      expect(firstPageSitemap.length).toBe(100 * 15); // 100 items * 15 locales
+
+      // Test third page (should have 50 items)
+      const thirdPageSitemap = await sitemap.getPlugins(3);
+      expect(thirdPageSitemap.length).toBe(50 * 15); // 50 items * 15 locales
+    });
   });
 
   describe('getModels', () => {
-    it('should return a valid models sitemap', async () => {
-      vi.spyOn(sitemap['discoverService'], 'getModelList').mockResolvedValue([
+    it('should return a valid models sitemap without pagination', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getModelIdentifiers').mockResolvedValue([
         // @ts-ignore
-        { identifier: 'test:model', createdAt: '2023-01-01' },
+        { identifier: 'test:model', lastModified: '2023-01-01' },
       ]);
 
       const modelsSitemap = await sitemap.getModels();
@@ -135,13 +196,73 @@ describe('Sitemap', () => {
         }),
       );
     });
+
+    it('should return a valid models sitemap with pagination', async () => {
+      const mockModels = Array.from({ length: 120 }, (_, i) => ({
+        identifier: `test:model-${i}`,
+        lastModified: '2023-01-01',
+      }));
+
+      vi.spyOn(sitemap['discoverService'], 'getModelIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        mockModels,
+      );
+
+      // Test first page (should have 100 items)
+      const firstPageSitemap = await sitemap.getModels(1);
+      expect(firstPageSitemap.length).toBe(100 * 15); // 100 items * 15 locales
+
+      // Test second page (should have 20 items)
+      const secondPageSitemap = await sitemap.getModels(2);
+      expect(secondPageSitemap.length).toBe(20 * 15); // 20 items * 15 locales
+    });
+  });
+
+  describe('getMcp', () => {
+    it('should return a valid mcp sitemap without pagination', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getMcpIdentifiers').mockResolvedValue([
+        // @ts-ignore
+        { identifier: 'test-mcp', lastModified: '2023-01-01' },
+      ]);
+
+      const mcpSitemap = await sitemap.getMcp();
+      expect(mcpSitemap.length).toBe(15);
+      expect(mcpSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/mcp/test-mcp'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+      expect(mcpSitemap).toContainEqual(
+        expect.objectContaining({
+          url: getCanonicalUrl('/discover/mcp/test-mcp?hl=zh-CN'),
+          lastModified: '2023-01-01T00:00:00.000Z',
+        }),
+      );
+    });
+
+    it('should return a valid mcp sitemap with pagination', async () => {
+      const mockMcps = Array.from({ length: 80 }, (_, i) => ({
+        identifier: `test-mcp-${i}`,
+        lastModified: '2023-01-01',
+      }));
+
+      vi.spyOn(sitemap['discoverService'], 'getMcpIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        mockMcps,
+      );
+
+      // Test first page (should have 80 items, all on first page)
+      const firstPageSitemap = await sitemap.getMcp(1);
+      expect(firstPageSitemap.length).toBe(80 * 15); // 80 items * 15 locales
+    });
   });
 
   describe('getProviders', () => {
     it('should return a valid providers sitemap', async () => {
-      vi.spyOn(sitemap['discoverService'], 'getProviderList').mockResolvedValue([
+      vi.spyOn(sitemap['discoverService'], 'getProviderIdentifiers').mockResolvedValue([
         // @ts-ignore
-        { identifier: 'test-provider', createdAt: '2023-01-01' },
+        { identifier: 'test-provider', lastModified: '2023-01-01' },
       ]);
 
       const providersSitemap = await sitemap.getProviders();
@@ -161,17 +282,53 @@ describe('Sitemap', () => {
     });
   });
 
+  describe('page count methods', () => {
+    it('should return correct plugin page count', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getPluginIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        Array.from({ length: 150 }, (_, i) => ({ identifier: `plugin-${i}` })),
+      );
+
+      const pageCount = await sitemap.getPluginPageCount();
+      expect(pageCount).toBe(2); // 150 items / 100 per page = ceil(1.5) = 2 pages
+    });
+
+    it('should return correct assistant page count', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getAssistantIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        Array.from({ length: 250 }, (_, i) => ({ identifier: `assistant-${i}` })),
+      );
+
+      const pageCount = await sitemap.getAssistantPageCount();
+      expect(pageCount).toBe(3); // 250 items / 100 per page = ceil(2.5) = 3 pages
+    });
+
+    it('should return correct mcp page count', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getMcpIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        Array.from({ length: 50 }, (_, i) => ({ identifier: `mcp-${i}` })),
+      );
+
+      const pageCount = await sitemap.getMcpPageCount();
+      expect(pageCount).toBe(1); // 50 items / 100 per page = 1 page
+    });
+
+    it('should return correct model page count', async () => {
+      vi.spyOn(sitemap['discoverService'], 'getModelIdentifiers').mockResolvedValue(
+        // @ts-ignore
+        Array.from({ length: 120 }, (_, i) => ({ identifier: `model-${i}` })),
+      );
+
+      const pageCount = await sitemap.getModelPageCount();
+      expect(pageCount).toBe(2); // 120 items / 100 per page = ceil(1.2) = 2 pages
+    });
+  });
+
   describe('getRobots', () => {
     it('should return correct robots.txt entries', () => {
       const robots = sitemap.getRobots();
       expect(robots).toContain(getCanonicalUrl('/sitemap-index.xml'));
-      [
-        SitemapType.Pages,
-        SitemapType.Assistants,
-        SitemapType.Plugins,
-        SitemapType.Models,
-        SitemapType.Providers,
-      ].forEach((type) => {
+      [SitemapType.Pages, SitemapType.Providers].forEach((type) => {
         expect(robots).toContain(getCanonicalUrl(`/sitemap/${type}.xml`));
       });
     });

package/src/server/sitemap.ts

@@ -9,7 +9,6 @@ import { SITEMAP_BASE_URL } from '@/const/url';
 import { Locales, locales as allLocales } from '@/locales/resources';
 import { DiscoverService } from '@/server/services/discover';
 import { getCanonicalUrl } from '@/server/utils/url';
-import { AssistantCategory, PluginCategory } from '@/types/discover';
 import { isDev } from '@/utils/env';
 
 export interface SitemapItem {
@@ -24,6 +23,7 @@ export interface SitemapItem {
 
 export enum SitemapType {
   Assistants = 'assistants',
+  Mcp = 'mcp',
   Models = 'models',
   Pages = 'pages',
   Plugins = 'plugins',
@@ -32,17 +32,38 @@ export enum SitemapType {
 
 export const LAST_MODIFIED = new Date().toISOString();
 
+// 每页条目数量
+const ITEMS_PER_PAGE = 100;
+
 export class Sitemap {
-  sitemapIndexs = [
-    { id: SitemapType.Pages },
-    { id: SitemapType.Assistants },
-    { id: SitemapType.Plugins },
-    { id: SitemapType.Models },
-    { id: SitemapType.Providers },
-  ];
+  sitemapIndexs = [{ id: SitemapType.Pages }, { id: SitemapType.Providers }];
 
   private discoverService = new DiscoverService();
 
+  // 获取插件总页数
+  async getPluginPageCount(): Promise<number> {
+    const list = await this.discoverService.getPluginIdentifiers();
+    return Math.ceil(list.length / ITEMS_PER_PAGE);
+  }
+
+  // 获取助手总页数
+  async getAssistantPageCount(): Promise<number> {
+    const list = await this.discoverService.getAssistantIdentifiers();
+    return Math.ceil(list.length / ITEMS_PER_PAGE);
+  }
+
+  // 获取MCP总页数
+  async getMcpPageCount(): Promise<number> {
+    const list = await this.discoverService.getMcpIdentifiers();
+    return Math.ceil(list.length / ITEMS_PER_PAGE);
+  }
+
+  // 获取模型总页数
+  async getModelPageCount(): Promise<number> {
+    const list = await this.discoverService.getModelIdentifiers();
+    return Math.ceil(list.length / ITEMS_PER_PAGE);
+  }
+
   private _generateSitemapLink(url: string) {
     return [
       '<sitemap>',
@@ -142,54 +163,162 @@ export class Sitemap {
     );
   }
 
-  getIndex(): string {
-    return [
-      '<?xml version="1.0" encoding="UTF-8"?>',
-      '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
-      ...this.sitemapIndexs.map((item) =>
+  async getIndex(): Promise<string> {
+    const staticSitemaps = this.sitemapIndexs.map((item) =>
+      this._generateSitemapLink(
+        getCanonicalUrl(SITEMAP_BASE_URL, isDev ? item.id : `${item.id}.xml`),
+      ),
+    );
+
+    // 获取需要分页的类型的页数
+    const [pluginPages, assistantPages, mcpPages, modelPages] = await Promise.all([
+      this.getPluginPageCount(),
+      this.getAssistantPageCount(),
+      this.getMcpPageCount(),
+      this.getModelPageCount(),
+    ]);
+
+    // 生成分页sitemap链接
+    const paginatedSitemaps = [
+      ...Array.from({ length: pluginPages }, (_, i) =>
         this._generateSitemapLink(
-          getCanonicalUrl(SITEMAP_BASE_URL, isDev ? item.id : `${item.id}.xml`),
+          getCanonicalUrl(SITEMAP_BASE_URL, isDev ? `plugins-${i + 1}` : `plugins-${i + 1}.xml`),
         ),
       ),
+      ...Array.from({ length: assistantPages }, (_, i) =>
+        this._generateSitemapLink(
+          getCanonicalUrl(
+            SITEMAP_BASE_URL,
+            isDev ? `assistants-${i + 1}` : `assistants-${i + 1}.xml`,
+          ),
+        ),
+      ),
+      ...Array.from({ length: mcpPages }, (_, i) =>
+        this._generateSitemapLink(
+          getCanonicalUrl(SITEMAP_BASE_URL, isDev ? `mcp-${i + 1}` : `mcp-${i + 1}.xml`),
+        ),
+      ),
+      ...Array.from({ length: modelPages }, (_, i) =>
+        this._generateSitemapLink(
+          getCanonicalUrl(SITEMAP_BASE_URL, isDev ? `models-${i + 1}` : `models-${i + 1}.xml`),
+        ),
+      ),
+    ];
+
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+      ...staticSitemaps,
+      ...paginatedSitemaps,
       '</sitemapindex>',
     ].join('\n');
   }
 
-  async getAssistants(): Promise<MetadataRoute.Sitemap> {
-    const list = await this.discoverService.getAssistantList(DEFAULT_LANG);
+  async getAssistants(page?: number): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getAssistantIdentifiers();
+
+    if (page !== undefined) {
+      const startIndex = (page - 1) * ITEMS_PER_PAGE;
+      const endIndex = startIndex + ITEMS_PER_PAGE;
+      const pageAssistants = list.slice(startIndex, endIndex);
+
+      const sitmap = pageAssistants.map((item) =>
+        this._genSitemap(urlJoin('/discover/assistant', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
+      return flatten(sitmap);
+    }
+
+    // 如果没有指定页数，返回所有（向后兼容）
     const sitmap = list.map((item) =>
       this._genSitemap(urlJoin('/discover/assistant', item.identifier), {
-        lastModified: item?.createdAt || LAST_MODIFIED,
+        lastModified: item?.lastModified || LAST_MODIFIED,
       }),
     );
     return flatten(sitmap);
   }
 
-  async getPlugins(): Promise<MetadataRoute.Sitemap> {
-    const list = await this.discoverService.getPluginList(DEFAULT_LANG);
+  async getMcp(page?: number): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getMcpIdentifiers();
+
+    if (page !== undefined) {
+      const startIndex = (page - 1) * ITEMS_PER_PAGE;
+      const endIndex = startIndex + ITEMS_PER_PAGE;
+      const pageMcps = list.slice(startIndex, endIndex);
+
+      const sitmap = pageMcps.map((item) =>
+        this._genSitemap(urlJoin('/discover/mcp', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
+      return flatten(sitmap);
+    }
+
+    // 如果没有指定页数，返回所有（向后兼容）
+    const sitmap = list.map((item) =>
+      this._genSitemap(urlJoin('/discover/mcp', item.identifier), {
+        lastModified: item?.lastModified || LAST_MODIFIED,
+      }),
+    );
+    return flatten(sitmap);
+  }
+
+  async getPlugins(page?: number): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getPluginIdentifiers();
+
+    if (page !== undefined) {
+      const startIndex = (page - 1) * ITEMS_PER_PAGE;
+      const endIndex = startIndex + ITEMS_PER_PAGE;
+      const pagePlugins = list.slice(startIndex, endIndex);
+
+      const sitmap = pagePlugins.map((item) =>
+        this._genSitemap(urlJoin('/discover/plugin', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
+      return flatten(sitmap);
+    }
+
+    // 如果没有指定页数，返回所有（向后兼容）
     const sitmap = list.map((item) =>
       this._genSitemap(urlJoin('/discover/plugin', item.identifier), {
-        lastModified: item?.createdAt || LAST_MODIFIED,
+        lastModified: item?.lastModified || LAST_MODIFIED,
       }),
     );
     return flatten(sitmap);
   }
 
-  async getModels(): Promise<MetadataRoute.Sitemap> {
-    const list = await this.discoverService.getModelList(DEFAULT_LANG);
+  async getModels(page?: number): Promise<MetadataRoute.Sitemap> {
+    const list = await this.discoverService.getModelIdentifiers();
+
+    if (page !== undefined) {
+      const startIndex = (page - 1) * ITEMS_PER_PAGE;
+      const endIndex = startIndex + ITEMS_PER_PAGE;
+      const pageModels = list.slice(startIndex, endIndex);
+
+      const sitmap = pageModels.map((item) =>
+        this._genSitemap(urlJoin('/discover/model', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
+      return flatten(sitmap);
+    }
+
+    // 如果没有指定页数，返回所有（向后兼容）
     const sitmap = list.map((item) =>
       this._genSitemap(urlJoin('/discover/model', item.identifier), {
-        lastModified: item?.createdAt || LAST_MODIFIED,
+        lastModified: item?.lastModified || LAST_MODIFIED,
       }),
     );
     return flatten(sitmap);
   }
 
   async getProviders(): Promise<MetadataRoute.Sitemap> {
-    const list = await this.discoverService.getProviderList(DEFAULT_LANG);
+    const list = await this.discoverService.getProviderIdentifiers();
     const sitmap = list.map((item) =>
       this._genSitemap(urlJoin('/discover/provider', item.identifier), {
-        lastModified: item?.createdAt || LAST_MODIFIED,
+        lastModified: item?.lastModified || LAST_MODIFIED,
       }),
     );
     return flatten(sitmap);
@@ -197,9 +326,6 @@ export class Sitemap {
 
   async getPage(): Promise<MetadataRoute.Sitemap> {
     const hideDocs = serverFeatureFlags().hideDocs;
-    const assistantsCategory = Object.values(AssistantCategory);
-    const pluginCategory = Object.values(PluginCategory);
-    const modelCategory = await this.discoverService.getProviderList(DEFAULT_LANG);
     return [
       ...this._genSitemap('/', { noLocales: true }),
       ...this._genSitemap('/chat', { noLocales: true }),
@@ -208,28 +334,11 @@ export class Sitemap {
 
       /* ↑ cloud slot ↑ */
       ...this._genSitemap('/discover', { changeFrequency: 'daily', priority: 0.7 }),
-      ...this._genSitemap('/discover/assistants', { changeFrequency: 'daily', priority: 0.7 }),
-      ...assistantsCategory.flatMap((slug) =>
-        this._genSitemap(`/discover/assistants/${slug}`, {
-          changeFrequency: 'daily',
-          priority: 0.7,
-        }),
-      ),
-      ...this._genSitemap('/discover/plugins', { changeFrequency: 'daily', priority: 0.7 }),
-      ...pluginCategory.flatMap((slug) =>
-        this._genSitemap(`/discover/plugins/${slug}`, {
-          changeFrequency: 'daily',
-          priority: 0.7,
-        }),
-      ),
-      ...this._genSitemap('/discover/models', { changeFrequency: 'daily', priority: 0.7 }),
-      ...modelCategory.flatMap((slug) =>
-        this._genSitemap(`/discover/models/${slug}`, {
-          changeFrequency: 'daily',
-          priority: 0.7,
-        }),
-      ),
-      ...this._genSitemap('/discover/providers', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/discover/assistant', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/discover/mcp', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/discover/plugin', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/discover/model', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/discover/provider', { changeFrequency: 'daily', priority: 0.7 }),
     ].filter(Boolean);
   }
   getRobots() {
@@ -241,5 +350,3 @@ export class Sitemap {
     ];
   }
 }
-
-export const sitemapModule = new Sitemap();

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

@@ -1,6 +1,6 @@
 import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { edgeClient } from '@/libs/trpc/client';
+import { lambdaClient } from '@/libs/trpc/client';
 import { GlobalRuntimeConfig } from '@/types/serverConfig';
 
 import { globalService } from '../global';
@@ -13,14 +13,11 @@ beforeEach(() => {
 
 vi.mock('@/libs/trpc/client', () => {
   return {
-    edgeClient: {
+    lambdaClient: {
       config: {
         getGlobalConfig: { query: vi.fn() },
         getDefaultAgentConfig: { query: vi.fn() },
       },
-      appStatus: {
-        getLatestChangelogId: { query: vi.fn() },
-      },
     },
   };
 });
@@ -81,7 +78,7 @@ describe('GlobalService', () => {
         serverConfig: { enabledOAuthSSO: true },
         serverFeatureFlags: {},
       } as GlobalRuntimeConfig;
-      vi.spyOn(edgeClient.config.getGlobalConfig, 'query').mockResolvedValue(mockConfig);
+      vi.spyOn(lambdaClient.config.getGlobalConfig, 'query').mockResolvedValue(mockConfig);
 
       // Act
       const config = await globalService.getGlobalConfig();
@@ -92,7 +89,7 @@ describe('GlobalService', () => {
 
     it('should return the defaultAgentConfig when fetch is successful', async () => {
       // Arrange
-      vi.spyOn(edgeClient.config.getDefaultAgentConfig, 'query').mockResolvedValue({
+      vi.spyOn(lambdaClient.config.getDefaultAgentConfig, 'query').mockResolvedValue({
         model: 'gemini-pro',
       });