@lobehub/lobehub 2.0.0-next.45 → 2.0.0-next.47

package/src/server/services/mcp/contentProcessor.ts

@@ -0,0 +1,101 @@
+import debug from 'debug';
+import pMap from 'p-map';
+import urlJoin from 'url-join';
+
+import { appEnv } from '@/envs/app';
+import { fileEnv } from '@/envs/file';
+import { AudioContent, ImageContent, ToolCallContent } from '@/libs/mcp';
+import { FileService } from '@/server/services/file';
+import { nanoid } from '@/utils/uuid';
+
+const log = debug('lobe-mcp:content-processor');
+
+export type ProcessContentBlocksFn = (blocks: ToolCallContent[]) => Promise<ToolCallContent[]>;
+
+/**
+ * 处理 MCP 返回的 content blocks
+ * - 上传图片/音频到存储并替换 data 为代理 URL
+ * - 保持其他类型的 block 不变
+ */
+export const processContentBlocks = async (
+  blocks: ToolCallContent[],
+  fileService: FileService,
+): Promise<ToolCallContent[]> => {
+  // Use date-based sharding for privacy compliance (GDPR, CCPA)
+  const today = new Date().toISOString().split('T')[0]; // e.g., "2025-11-08"
+
+  return pMap(blocks, async (block) => {
+    if (block.type === 'image') {
+      const imageBlock = block as ImageContent;
+
+      // Extract file extension from mimeType (e.g., "image/png" -> "png")
+      const fileExtension = imageBlock.mimeType.split('/')[1] || 'png';
+
+      // Generate unique pathname with date-based sharding
+      const pathname = `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/mcp/images/${today}/${nanoid()}.${fileExtension}`;
+
+      // Upload base64 image and get proxy URL
+      const { url } = await fileService.uploadBase64(imageBlock.data, pathname);
+
+      log(`Image uploaded, proxy URL: ${url}`);
+
+      return { ...block, data: url };
+    }
+
+    if (block.type === 'audio') {
+      const audioBlock = block as AudioContent;
+
+      // Extract file extension from mimeType (e.g., "audio/mp3" -> "mp3")
+      const fileExtension = audioBlock.mimeType.split('/')[1] || 'mp3';
+
+      // Generate unique pathname with date-based sharding
+      const pathname = `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/mcp/audio/${today}/${nanoid()}.${fileExtension}`;
+
+      // Upload base64 audio and get proxy URL
+      const { url } = await fileService.uploadBase64(audioBlock.data, pathname);
+
+      log(`Audio uploaded, proxy URL: ${url}`);
+
+      return { ...block, data: url };
+    }
+
+    return block;
+  });
+};
+
+/**
+ * 将 content blocks 转换为字符串
+ * - text: 提取 text 字段
+ * - image/audio: 提取 data 字段（通常是上传后的代理 URL）
+ * - 其他: 返回空字符串
+ */
+export const contentBlocksToString = (blocks: ToolCallContent[] | null | undefined): string => {
+  if (!blocks) return '';
+
+  return blocks
+    .map((item) => {
+      switch (item.type) {
+        case 'text': {
+          return item.text;
+        }
+
+        case 'image': {
+          return `![](${urlJoin(appEnv.APP_URL, item.data)})`;
+        }
+
+        case 'audio': {
+          return `<resource type="${item.type}" url="${urlJoin(appEnv.APP_URL, item.data)}" />`;
+        }
+
+        case 'resource': {
+          return `<resource type="${item.type}">${JSON.stringify(item.resource)}</resource>}`;
+        }
+
+        default: {
+          return '';
+        }
+      }
+    })
+    .filter(Boolean)
+    .join('\n\n');
+};

package/src/server/services/mcp/index.test.ts

@@ -39,7 +39,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe('');
       expect(result.success).toBe(true);
@@ -52,7 +56,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe('');
       expect(result.success).toBe(true);
@@ -65,7 +73,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe(JSON.stringify(jsonData));
       expect(result.success).toBe(true);
@@ -78,7 +90,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe(textData);
       expect(result.success).toBe(true);
@@ -92,7 +108,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe('');
       expect(result.success).toBe(true);
@@ -111,7 +131,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe('First message\n\nSecond message\n\n{"json": "data"}');
       expect(result.success).toBe(true);
@@ -129,7 +153,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe('First message\n\nSecond message');
       expect(result.success).toBe(true);
@@ -144,7 +172,11 @@ describe('MCPService', () => {
 
       mockClient.callTool.mockResolvedValue(errorResult);
 
-      const result = await mcpService.callTool(mockParams, 'testTool', '{}');
+      const result = await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: '{}',
+      });
 
       expect(result.content).toBe('Error occurred');
       expect(result.success).toBe(true);
@@ -155,7 +187,13 @@ describe('MCPService', () => {
       const error = new Error('MCP client error');
       mockClient.callTool.mockRejectedValue(error);
 
-      await expect(mcpService.callTool(mockParams, 'testTool', '{}')).rejects.toThrow(TRPCError);
+      await expect(
+        mcpService.callTool({
+          clientParams: mockParams,
+          toolName: 'testTool',
+          argsStr: '{}',
+        }),
+      ).rejects.toThrow(TRPCError);
     });
 
     it('should parse args string correctly', async () => {
@@ -167,7 +205,11 @@ describe('MCPService', () => {
         isError: false,
       });
 
-      await mcpService.callTool(mockParams, 'testTool', argsString);
+      await mcpService.callTool({
+        clientParams: mockParams,
+        toolName: 'testTool',
+        argsStr: argsString,
+      });
 
       expect(mockClient.callTool).toHaveBeenCalledWith('testTool', argsObject);
     });

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

@@ -15,6 +15,7 @@ import {
   StdioMCPParams,
 } from '@/libs/mcp';
 
+import { ProcessContentBlocksFn, contentBlocksToString } from './contentProcessor';
 import { mcpSystemDepsCheckService } from './deps';
 
 const log = debug('lobe-mcp:service');
@@ -154,12 +155,19 @@ export class MCPService {
     }
   }
 
-  // callTool now accepts MCPClientParams, toolName, and args
-  async callTool(params: MCPClientParams, toolName: string, argsStr: any): Promise<any> {
-    const client = await this.getClient(params); // Get client using params
+  // callTool now accepts an object with clientParams, toolName, argsStr, and processContentBlocks
+  async callTool(options: {
+    argsStr: any;
+    clientParams: MCPClientParams;
+    processContentBlocks?: ProcessContentBlocksFn;
+    toolName: string;
+  }): Promise<any> {
+    const { clientParams, toolName, argsStr, processContentBlocks } = options;
+
+    const client = await this.getClient(clientParams); // Get client using params
 
     const args = safeParseJSON(argsStr);
-    const loggableParams = this.sanitizeForLogging(params);
+    const loggableParams = this.sanitizeForLogging(clientParams);
 
     log(
       `Calling tool "${toolName}" using client for params: %O with args: %O`,
@@ -170,32 +178,27 @@ export class MCPService {
     try {
       // Delegate the call to the MCPClient instance
       const result = await client.callTool(toolName, args); // Pass args directly
+
+      // Process content blocks (upload images, etc.)
+      const newContent =
+        result.isError || !processContentBlocks
+          ? result.content
+          : await processContentBlocks(result.content);
+
+      // Convert content blocks to string
+      const content = contentBlocksToString(newContent);
+
+      const state = { ...result, content: newContent };
+
       log(
         `Tool "${toolName}" called successfully for params: %O, result: %O`,
         loggableParams,
-        result,
+        state,
       );
 
-      // TODO: map more type
-      const content = result.content
-        ? result.content
-            .map((item) => {
-              switch (item.type) {
-                case 'text': {
-                  return item.text;
-                }
-                default: {
-                  return '';
-                }
-              }
-            })
-            .filter(Boolean)
-            .join('\n\n')
-        : '';
-
-      if (result.isError) return { content, state: result, success: true };
-
-      return { content, state: result, success: true };
+      if (result.isError) return { content, state, success: true };
+
+      return { content, state, success: true };
     } catch (error) {
       if (error instanceof McpError) {
         const mcpError = error as McpError;
@@ -213,7 +216,7 @@ export class MCPService {
 
       console.error(
         `Error calling tool "${toolName}" for params %O:`,
-        this.sanitizeForLogging(params),
+        this.sanitizeForLogging(clientParams),
         error,
       );
       // Propagate a TRPCError

package/src/services/session/index.ts

@@ -4,14 +4,12 @@ import type { PartialDeep } from 'type-fest';
 import { lambdaClient } from '@/libs/trpc/client';
 import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
 import { MetaData } from '@/types/meta';
-import { BatchTaskResult } from '@/types/service';
 import {
   ChatSessionList,
   LobeAgentSession,
   LobeSessionType,
   LobeSessions,
   SessionGroupItem,
-  SessionGroups,
   SessionRankItem,
   UpdateSessionParams,
 } from '@/types/session';
@@ -114,18 +112,6 @@ export class SessionService {
     return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
   };
 
-  getSessionGroups = (): Promise<SessionGroupItem[]> => {
-    return lambdaClient.sessionGroup.getSessionGroup.query();
-  };
-
-  /**
-   * 需要废弃
-   * @deprecated
-   */
-  batchCreateSessionGroups = (groups: SessionGroups): Promise<BatchTaskResult> => {
-    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
-  };
-
   removeSessionGroup = (id: string, removeChildren?: boolean) => {
     return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
   };

package/src/utils/server/routeVariants.test.ts

@@ -0,0 +1,340 @@
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_LANG } from '@/const/locale';
+import { DynamicLayoutProps } from '@/types/next';
+
+import { DEFAULT_VARIANTS, IRouteVariants, RouteVariants } from './routeVariants';
+
+describe('RouteVariants', () => {
+  describe('DEFAULT_VARIANTS', () => {
+    it('should have correct default values', () => {
+      expect(DEFAULT_VARIANTS).toEqual({
+        isMobile: false,
+        locale: DEFAULT_LANG,
+        theme: 'light',
+      });
+    });
+  });
+
+  describe('serializeVariants', () => {
+    it('should serialize variants with default values', () => {
+      const variants: IRouteVariants = {
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('en-US__0__light');
+    });
+
+    it('should serialize variants with mobile enabled', () => {
+      const variants: IRouteVariants = {
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('zh-CN__1__dark');
+    });
+
+    it('should serialize variants with different locales', () => {
+      const variants: IRouteVariants = {
+        isMobile: false,
+        locale: 'ja-JP',
+        theme: 'light',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('ja-JP__0__light');
+    });
+
+    it('should serialize variants with custom colors', () => {
+      const variants: IRouteVariants = {
+        isMobile: true,
+        locale: 'en-US',
+        neutralColor: '#cccccc',
+        primaryColor: '#ff0000',
+        theme: 'dark',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('en-US__1__dark');
+    });
+  });
+
+  describe('deserializeVariants', () => {
+    it('should deserialize valid serialized string', () => {
+      const serialized = 'en-US__0__light';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      });
+    });
+
+    it('should deserialize mobile variants', () => {
+      const serialized = 'zh-CN__1__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      });
+    });
+
+    it('should return default values for invalid serialized string', () => {
+      const serialized = 'invalid';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should return default values for empty string', () => {
+      const serialized = '';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should handle invalid locale by falling back to default', () => {
+      const serialized = 'invalid-locale__0__light';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: DEFAULT_LANG,
+        theme: 'light',
+      });
+    });
+
+    it('should handle invalid theme by falling back to default', () => {
+      const serialized = 'en-US__0__invalid-theme';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      });
+    });
+
+    it('should handle malformed serialized string', () => {
+      const serialized = 'en-US';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should handle isMobile value correctly for "0"', () => {
+      const serialized = 'en-US__0__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result.isMobile).toBe(false);
+    });
+
+    it('should handle isMobile value correctly for "1"', () => {
+      const serialized = 'en-US__1__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result.isMobile).toBe(true);
+    });
+
+    it('should handle isMobile value correctly for other values', () => {
+      const serialized = 'en-US__2__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result.isMobile).toBe(false);
+    });
+  });
+
+  describe('getVariantsFromProps', () => {
+    it('should extract and deserialize variants from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'en-US__0__light' }),
+      };
+      const result = await RouteVariants.getVariantsFromProps(props);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      });
+    });
+
+    it('should handle mobile variants from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'zh-CN__1__dark' }),
+      };
+      const result = await RouteVariants.getVariantsFromProps(props);
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      });
+    });
+
+    it('should handle invalid variants in props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid' }),
+      };
+      const result = await RouteVariants.getVariantsFromProps(props);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+  });
+
+  describe('getIsMobile', () => {
+    it('should extract isMobile as false from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'en-US__0__light' }),
+      };
+      const result = await RouteVariants.getIsMobile(props);
+      expect(result).toBe(false);
+    });
+
+    it('should extract isMobile as true from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'en-US__1__dark' }),
+      };
+      const result = await RouteVariants.getIsMobile(props);
+      expect(result).toBe(true);
+    });
+
+    it('should return default isMobile for invalid props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid' }),
+      };
+      const result = await RouteVariants.getIsMobile(props);
+      expect(result).toBe(DEFAULT_VARIANTS.isMobile);
+    });
+  });
+
+  describe('getLocale', () => {
+    it('should extract locale from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'zh-CN__0__light' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe('zh-CN');
+    });
+
+    it('should extract different locale from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'ja-JP__1__dark' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe('ja-JP');
+    });
+
+    it('should return default locale for invalid props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe(DEFAULT_LANG);
+    });
+
+    it('should return default locale for invalid locale in props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid-locale__0__light' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe(DEFAULT_LANG);
+    });
+  });
+
+  describe('createVariants', () => {
+    it('should create variants with default values when no options provided', () => {
+      const result = RouteVariants.createVariants();
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should create variants with custom isMobile', () => {
+      const result = RouteVariants.createVariants({ isMobile: true });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        isMobile: true,
+      });
+    });
+
+    it('should create variants with custom locale', () => {
+      const result = RouteVariants.createVariants({ locale: 'zh-CN' });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        locale: 'zh-CN',
+      });
+    });
+
+    it('should create variants with custom theme', () => {
+      const result = RouteVariants.createVariants({ theme: 'dark' });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        theme: 'dark',
+      });
+    });
+
+    it('should create variants with multiple custom options', () => {
+      const result = RouteVariants.createVariants({
+        isMobile: true,
+        locale: 'ja-JP',
+        theme: 'dark',
+      });
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'ja-JP',
+        theme: 'dark',
+      });
+    });
+
+    it('should create variants with custom colors', () => {
+      const result = RouteVariants.createVariants({
+        neutralColor: '#cccccc',
+        primaryColor: '#ff0000',
+      });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        neutralColor: '#cccccc',
+        primaryColor: '#ff0000',
+      });
+    });
+
+    it('should create variants with all custom options', () => {
+      const result = RouteVariants.createVariants({
+        isMobile: true,
+        locale: 'zh-CN',
+        neutralColor: '#aaaaaa',
+        primaryColor: '#00ff00',
+        theme: 'dark',
+      });
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'zh-CN',
+        neutralColor: '#aaaaaa',
+        primaryColor: '#00ff00',
+        theme: 'dark',
+      });
+    });
+  });
+
+  describe('roundtrip serialization', () => {
+    it('should maintain data integrity through serialize and deserialize', () => {
+      const original: IRouteVariants = {
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      };
+      const serialized = RouteVariants.serializeVariants(original);
+      const deserialized = RouteVariants.deserializeVariants(serialized);
+      expect(deserialized).toEqual(original);
+    });
+
+    it('should maintain data integrity for default variants', () => {
+      const serialized = RouteVariants.serializeVariants(DEFAULT_VARIANTS);
+      const deserialized = RouteVariants.deserializeVariants(serialized);
+      expect(deserialized).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should maintain data integrity for various locales', () => {
+      const locales = ['en-US', 'zh-CN', 'ja-JP', 'ko-KR', 'fr-FR'];
+      locales.forEach((locale) => {
+        const original: IRouteVariants = {
+          isMobile: false,
+          locale: locale as any,
+          theme: 'light',
+        };
+        const serialized = RouteVariants.serializeVariants(original);
+        const deserialized = RouteVariants.deserializeVariants(serialized);
+        expect(deserialized).toEqual(original);
+      });
+    });
+  });
+});