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

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/server/sitemap.ts

@@ -210,20 +210,24 @@ export class Sitemap {
       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,
-        }),
-      );
+      const sitmap = pageAssistants
+        .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+        .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?.lastModified || LAST_MODIFIED,
-      }),
-    );
+    const sitmap = list
+      .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+      .map((item) =>
+        this._genSitemap(urlJoin('/discover/assistant', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
     return flatten(sitmap);
   }
 
@@ -235,20 +239,24 @@ export class Sitemap {
       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,
-        }),
-      );
+      const sitmap = pagePlugins
+        .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+        .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?.lastModified || LAST_MODIFIED,
-      }),
-    );
+    const sitmap = list
+      .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+      .map((item) =>
+        this._genSitemap(urlJoin('/discover/plugin', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
     return flatten(sitmap);
   }
 
@@ -260,30 +268,36 @@ export class Sitemap {
       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,
-        }),
-      );
+      const sitmap = pageModels
+        .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+        .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?.lastModified || LAST_MODIFIED,
-      }),
-    );
+    const sitmap = list
+      .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+      .map((item) =>
+        this._genSitemap(urlJoin('/discover/model', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
     return flatten(sitmap);
   }
 
   async getProviders(): Promise<MetadataRoute.Sitemap> {
     const list = await this.discoverService.getProviderIdentifiers();
-    const sitmap = list.map((item) =>
-      this._genSitemap(urlJoin('/discover/provider', item.identifier), {
-        lastModified: item?.lastModified || LAST_MODIFIED,
-      }),
-    );
+    const sitmap = list
+      .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+      .map((item) =>
+        this._genSitemap(urlJoin('/discover/provider', item.identifier), {
+          lastModified: item?.lastModified || LAST_MODIFIED,
+        }),
+      );
     return flatten(sitmap);
   }
 

package/src/services/_url.ts

@@ -1,6 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix */
 
-
 export const API_ENDPOINTS = {
   oauth: '/api/auth',
 
@@ -30,3 +29,18 @@ export const API_ENDPOINTS = {
   edge: '/webapi/tts/edge',
   microsoft: '/webapi/tts/microsoft',
 };
+
+export const MARKET_OIDC_ENDPOINTS = {
+  auth: '/lobehub-oidc/auth',
+  token: '/market/oidc/token',
+  userinfo: '/market/oidc/userinfo',
+  handoff: '/market/oidc/handoff',
+  desktopCallback: '/lobehub-oidc/callback/desktop',
+};
+
+export const MARKET_ENDPOINTS = {
+  base: '/market',
+  createAgent: '/market/agent/create',
+  getAgentDetail: (identifier: string) => `/market/agent/${encodeURIComponent(identifier)}`,
+  createAgentVersion: '/market/agent/versions/create',
+};

package/src/services/chat/chat.test.ts

@@ -27,7 +27,7 @@ vi.stubGlobal(
 );
 
 // Mock image processing utilities
-vi.mock('@/utils/fetch', async (importOriginal) => {
+vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
   const module = await importOriginal();
 
   return { ...(module as any), getMessageError: vi.fn() };
@@ -988,7 +988,7 @@ describe('ChatService', () => {
 
     beforeEach(async () => {
       // Setup common fetchSSE mock for getChatCompletion tests
-      const { fetchSSE } = await import('@/utils/fetch');
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
       mockFetchSSE = vi.fn().mockResolvedValue(new Response('mock response'));
       vi.mocked(fetchSSE).mockImplementation(mockFetchSSE);
     });
@@ -1049,7 +1049,7 @@ describe('ChatService', () => {
 
     it('should return InvalidAccessCode error when enableFetchOnClient is true and auth is enabled but user is not signed in', async () => {
       // Mock fetchSSE to call onErrorHandle with the error
-      const { fetchSSE } = await import('@/utils/fetch');
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
 
       const mockFetchSSEWithError = vi.fn().mockImplementation((url, options) => {
         // Simulate the error being caught and passed to onErrorHandle
@@ -1211,8 +1211,8 @@ vi.mock('../_auth', async (importOriginal) => {
 describe('ChatService private methods', () => {
   describe('getChatCompletion', () => {
     it('should merge responseAnimation styles correctly', async () => {
-      const { fetchSSE } = await import('@/utils/fetch');
-      vi.mock('@/utils/fetch', async (importOriginal) => {
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
+      vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
         const module = await importOriginal();
         return {
           ...(module as any),

package/src/services/chat/clientModelRuntime.test.ts

@@ -38,7 +38,7 @@ vi.stubGlobal(
   vi.fn(() => Promise.resolve(new Response(JSON.stringify({ some: 'data' })))),
 );
 
-vi.mock('@/utils/fetch', async (importOriginal) => {
+vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
   const module = await importOriginal();
 
   return { ...(module as any), getMessageError: vi.fn() };

package/src/services/chat/index.ts

@@ -1,3 +1,9 @@
+import {
+  FetchSSEOptions,
+  fetchSSE,
+  getMessageError,
+  standardizeAnimationStyle,
+} from '@lobechat/fetch-sse';
 import { AgentRuntimeError, ChatCompletionErrorPayload } from '@lobechat/model-runtime';
 import { ChatErrorType, TracePayload, TraceTagMap, UIChatMessage } from '@lobechat/types';
 import { PluginRequestPayload, createHeadersWithPluginSettings } from '@lobehub/chat-plugin-sdk';
@@ -25,12 +31,6 @@ import {
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
 import { fetchWithInvokeStream } from '@/utils/electron/desktopRemoteRPCFetch';
 import { createErrorResponse } from '@/utils/errorResponse';
-import {
-  FetchSSEOptions,
-  fetchSSE,
-  getMessageError,
-  standardizeAnimationStyle,
-} from '@/utils/fetch';
 import { createTraceHeader, getTraceId } from '@/utils/trace';
 
 import { createHeaderWithAuth } from '../_auth';

package/src/services/chat/types.ts

@@ -1,7 +1,6 @@
+import { FetchSSEOptions } from '@lobechat/fetch-sse';
 import { TracePayload } from '@lobechat/types';
 
-import { FetchSSEOptions } from '@/utils/fetch';
-
 export interface FetchOptions extends FetchSSEOptions {
   historySummary?: string;
   signal?: AbortSignal | undefined;

package/src/services/discover.ts

@@ -7,6 +7,7 @@ import { useUserStore } from '@/store/user';
 import { preferenceSelectors } from '@/store/user/selectors';
 import {
   AssistantListResponse,
+  AssistantMarketSource,
   AssistantQueryParams,
   DiscoverAssistantDetail,
   DiscoverMcpDetail,
@@ -30,27 +31,37 @@ class DiscoverService {
   private _isRetrying = false;
 
   // ============================== Assistant Market ==============================
-  getAssistantCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+  getAssistantCategories = async (
+    params: CategoryListQuery & { source?: AssistantMarketSource } = {},
+  ): Promise<CategoryItem[]> => {
     const locale = globalHelpers.getCurrentLanguage();
+    const { source, ...rest } = params;
     return lambdaClient.market.getAssistantCategories.query({
-      ...params,
+      ...rest,
       locale,
+      source,
     });
   };
 
   getAssistantDetail = async (params: {
     identifier: string;
     locale?: string;
+    source?: AssistantMarketSource;
+    version?: string;
   }): Promise<DiscoverAssistantDetail | undefined> => {
     const locale = globalHelpers.getCurrentLanguage();
     return lambdaClient.market.getAssistantDetail.query({
-      ...params,
+      identifier: params.identifier,
       locale,
+      source: params.source,
+      version: params.version,
     });
   };
 
-  getAssistantIdentifiers = async (): Promise<IdentifiersResponse> => {
-    return lambdaClient.market.getAssistantIdentifiers.query();
+  getAssistantIdentifiers = async (
+    params: { source?: AssistantMarketSource } = {},
+  ): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getAssistantIdentifiers.query(params);
   };
 
   getAssistantList = async (params: AssistantQueryParams = {}): Promise<AssistantListResponse> => {

package/src/services/electron/remoteServer.ts

@@ -1,4 +1,4 @@
-import { DataSyncConfig, dispatch } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig, MarketAuthorizationParams, dispatch } from '@lobechat/electron-client-ipc';
 
 class RemoteServerService {
   /**
@@ -28,6 +28,13 @@ class RemoteServerService {
   requestAuthorization = async (config: DataSyncConfig) => {
     return dispatch('requestAuthorization', config);
   };
+
+  /**
+   * 请求 Market 授权
+   */
+  requestMarketAuthorization = async (params: MarketAuthorizationParams) => {
+    return dispatch('requestMarketAuthorization', params);
+  };
 }
 
 export const remoteServerService = new RemoteServerService();