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

package/src/server/routers/tools/mcp.ts

@@ -6,8 +6,12 @@ import {
 import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
 
+import { ToolCallContent } from '@/libs/mcp';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+import { FileService } from '@/server/services/file';
 import { mcpService } from '@/server/services/mcp';
+import { processContentBlocks } from '@/server/services/mcp/contentProcessor';
 
 // Define Zod schemas for MCP Client parameters
 const httpParamsSchema = z.object({
@@ -37,7 +41,13 @@ const checkStdioEnvironment = (params: z.infer<typeof mcpClientParamsSchema>) =>
   }
 };
 
-const mcpProcedure = authedProcedure;
+const mcpProcedure = authedProcedure.use(serverDatabase).use(async ({ ctx, next }) => {
+  return next({
+    ctx: {
+      fileService: new FileService(ctx.serverDB, ctx.userId),
+    },
+  });
+});
 
 export const mcpRouter = router({
   getStreamableMcpServerManifest: mcpProcedure
@@ -95,11 +105,21 @@ export const mcpRouter = router({
         toolName: z.string(),
       }),
     )
-    .mutation(async ({ input }) => {
+    .mutation(async ({ input, ctx }) => {
       // Stdio check can be done here or rely on the service/client layer
       checkStdioEnvironment(input.params);
 
-      // Pass the validated params, toolName, and args to the service
-      return await mcpService.callTool(input.params, input.toolName, input.args);
+      // Create a closure that binds fileService and userId to processContentBlocks
+      const boundProcessContentBlocks = async (blocks: ToolCallContent[]) => {
+        return processContentBlocks(blocks, ctx.fileService);
+      };
+
+      // Pass the validated params, toolName, args, and bound processContentBlocks to the service
+      return await mcpService.callTool({
+        clientParams: input.params,
+        toolName: input.toolName,
+        argsStr: input.args,
+        processContentBlocks: boundProcessContentBlocks,
+      });
     }),
 });

package/src/server/services/file/impls/local.ts

@@ -1,3 +1,4 @@
+import debug from 'debug';
 import { sha256 } from 'js-sha256';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
@@ -8,6 +9,8 @@ import { inferContentTypeFromImageUrl } from '@/utils/url';
 import { FileServiceImpl } from './type';
 import { extractKeyFromUrlOrReturnOriginal } from './utils';
 
+const log = debug('lobe-file:desktop-local');
+
 /**
  * 桌面应用本地文件服务实现
  */
@@ -202,7 +205,7 @@ export class DesktopLocalFileImpl implements FileServiceImpl {
         throw new Error('Failed to upload file via Electron IPC');
       }
 
-      console.log('[DesktopLocalFileImpl] File uploaded successfully:', result.metadata);
+      log('File uploaded successfully: %O', result.metadata);
       return { key: result.metadata.path };
     } catch (error) {
       console.error('[DesktopLocalFileImpl] Failed to upload media file:', error);

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

@@ -1,11 +1,12 @@
 import { LobeChatDatabase } from '@lobechat/database';
+import { inferContentTypeFromImageUrl, nanoid, uuid } from '@lobechat/utils';
 import { TRPCError } from '@trpc/server';
+import { sha256 } from 'js-sha256';
 
 import { serverDBEnv } from '@/config/db';
 import { FileModel } from '@/database/models/file';
 import { FileItem } from '@/database/schemas';
 import { TempFileManager } from '@/server/utils/tempFileManager';
-import { nanoid } from '@/utils/uuid';
 
 import { FileServiceImpl, createFileServiceModule } from './impls';
 
@@ -94,6 +95,100 @@ export class FileService {
     return this.impl.uploadMedia(key, buffer);
   }
 
+  /**
+   * Create file record (common method)
+   * Automatically handles globalFiles deduplication logic
+   *
+   * @param params - File parameters
+   * @param params.id - Optional custom file ID (defaults to auto-generated)
+   * @returns File record and proxy URL
+   */
+  public async createFileRecord(params: {
+    fileHash: string;
+    fileType: string;
+    id?: string;
+    name: string;
+    size: number;
+    url: string;
+  }): Promise<{ fileId: string; url: string }> {
+    // Check if hash already exists in globalFiles
+    const { isExist } = await this.fileModel.checkHash(params.fileHash);
+
+    // Create database record
+    // If hash doesn't exist, also create globalFiles record
+    const { id } = await this.fileModel.create(
+      {
+        fileHash: params.fileHash,
+        fileType: params.fileType,
+        id: params.id, // Use custom ID if provided
+        name: params.name,
+        size: params.size,
+        url: params.url,
+      },
+      !isExist, // insertToGlobalFiles
+    );
+
+    // Return unified proxy URL: /f/:id
+    return {
+      fileId: id,
+      url: `/f/${id}`,
+    };
+  }
+
+  /**
+   * Upload base64 data and create database record
+   * @param base64Data - Base64 data (supports data URI format or pure base64)
+   * @param pathname - File storage path (must include file extension)
+   * @returns Contains key (storage path), fileId (database record ID) and url (proxy access path)
+   */
+  public async uploadBase64(
+    base64Data: string,
+    pathname: string,
+  ): Promise<{ fileId: string; key: string; url: string }> {
+    let base64String: string;
+
+    // If data URI format (data:image/png;base64,xxx)
+    if (base64Data.startsWith('data:')) {
+      const commaIndex = base64Data.indexOf(',');
+      if (commaIndex === -1) {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Invalid base64 data format' });
+      }
+      base64String = base64Data.slice(commaIndex + 1);
+    } else {
+      // Pure base64 string
+      base64String = base64Data;
+    }
+
+    // Convert to Buffer
+    const buffer = Buffer.from(base64String, 'base64');
+
+    // Upload to storage (S3 or local)
+    const { key } = await this.uploadMedia(pathname, buffer);
+
+    // Extract filename from pathname
+    const name = pathname.split('/').pop() || 'unknown';
+
+    // Calculate file metadata
+    const size = buffer.length;
+    const fileType = inferContentTypeFromImageUrl(pathname) || 'application/octet-stream';
+    const hash = sha256(buffer);
+
+    // Generate UUID for cleaner URLs
+    const fileId = uuid();
+
+    // Use common method to create file record
+    const { fileId: createdId, url } = await this.createFileRecord({
+      fileHash: hash,
+      fileType,
+      id: fileId, // Use UUID instead of auto-generated ID
+      name,
+      size,
+      url: key, // Store original key (S3 key or desktop://)
+    });
+
+    return { fileId: createdId, key, url };
+  }
+
   async downloadFileToLocal(
     fileId: string,
   ): Promise<{ cleanup: () => void; file: FileItem; filePath: string }> {

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 });
   };