@lobehub/chat 1.96.20 → 1.97.1

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

@@ -18,7 +18,7 @@ vi.mock('@/store/global/helpers', () => ({
 vi.mock('@/libs/trpc/client', () => ({
   edgeClient: {
     market: {
-      getPluginIndex: {
+      getLegacyPluginList: {
         query: vi.fn(),
       },
     },
@@ -30,34 +30,6 @@ beforeEach(() => {
 });
 
 describe('ToolService', () => {
-  describe('getToolList', () => {
-    it('should fetch and return the plugin list', async () => {
-      // Arrange
-      const fakeResponse = { plugins: [{ name: 'TestPlugin' }] };
-      (globalHelpers.getCurrentLanguage as Mock).mockReturnValue('tt');
-
-      (edgeClient.market.getPluginIndex.query as Mock).mockResolvedValue(fakeResponse);
-
-      // Act
-      const pluginList = await toolService.getToolList();
-
-      // Assert
-      expect(globalHelpers.getCurrentLanguage).toHaveBeenCalled();
-      expect(pluginList).toEqual(fakeResponse.plugins);
-    });
-
-    it('should handle fetch error', async () => {
-      // Arrange
-      (globalHelpers.getCurrentLanguage as Mock).mockReturnValue('en');
-      (edgeClient.market.getPluginIndex.query as Mock).mockRejectedValue(
-        new Error('Network error'),
-      );
-
-      // Act & Assert
-      await expect(toolService.getToolList()).rejects.toThrow('Network error');
-    });
-  });
-
   describe('getToolManifest', () => {
     it('should return manifest', async () => {
       const manifestUrl = 'http://fake-url.com/manifest.json';

package/src/services/discover.ts

@@ -0,0 +1,365 @@
+import { CategoryItem, CategoryListQuery, PluginManifest } from '@lobehub/market-sdk';
+import { CallReportRequest, InstallReportRequest } from '@lobehub/market-types';
+
+import { lambdaClient } from '@/libs/trpc/client';
+import { globalHelpers } from '@/store/global/helpers';
+import {
+  AssistantListResponse,
+  AssistantQueryParams,
+  DiscoverAssistantDetail,
+  DiscoverMcpDetail,
+  DiscoverModelDetail,
+  DiscoverPluginDetail,
+  DiscoverProviderDetail,
+  IdentifiersResponse,
+  McpListResponse,
+  McpQueryParams,
+  ModelListResponse,
+  ModelQueryParams,
+  PluginListResponse,
+  PluginQueryParams,
+  ProviderListResponse,
+  ProviderQueryParams,
+} from '@/types/discover';
+import { MCPPluginListParams } from '@/types/plugins';
+import { cleanObject } from '@/utils/object';
+
+class DiscoverService {
+  private _isRetrying = false;
+
+  // ============================== Assistant Market ==============================
+  getAssistantCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getAssistantCategories.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getAssistantDetail = async (params: {
+    identifier: string;
+    locale?: string;
+  }): Promise<DiscoverAssistantDetail | undefined> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getAssistantDetail.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getAssistantIdentifiers = async (): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getAssistantIdentifiers.query();
+  };
+
+  getAssistantList = async (params: AssistantQueryParams = {}): Promise<AssistantListResponse> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getAssistantList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 20,
+    });
+  };
+
+  // ============================== MCP Market ==============================
+
+  getMcpCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getMcpCategories.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getMcpDetail = async (params: {
+    identifier: string;
+    locale?: string;
+    version?: string;
+  }): Promise<DiscoverMcpDetail> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getMcpDetail.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getMcpIdentifiers = async (): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getMcpIdentifiers.query();
+  };
+
+  getMcpList = async (params: McpQueryParams = {}): Promise<McpListResponse> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getMcpList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 20,
+    });
+  };
+
+  getMCPPluginList = async (params: MCPPluginListParams): Promise<McpListResponse> => {
+    await this.injectMPToken();
+
+    const locale = globalHelpers.getCurrentLanguage();
+
+    return lambdaClient.market.getMcpList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 21,
+    });
+  };
+
+  getMcpManifest = async (params: { identifier: string; locale?: string; version?: string }) => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getMcpManifest.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getMCPPluginManifest = async (
+    identifier: string,
+    options: { install?: boolean } = {},
+  ): Promise<PluginManifest> => {
+    const locale = globalHelpers.getCurrentLanguage();
+
+    return lambdaClient.market.getMcpManifest.query({
+      identifier,
+      install: options.install,
+      locale,
+    });
+  };
+
+  registerClient = () => {
+    return lambdaClient.market.registerClientInMarketplace.mutate({});
+  };
+
+  /**
+   * 上报 MCP 插件安装结果
+   */
+  reportMcpInstallResult = async ({
+    success,
+    manifest,
+    errorMessage,
+    errorCode,
+    ...params
+  }: InstallReportRequest) => {
+    await this.injectMPToken();
+
+    const reportData = {
+      errorCode: success ? undefined : errorCode,
+      errorMessage: success ? undefined : errorMessage,
+      manifest: success ? manifest : undefined,
+      success,
+      ...params,
+    };
+
+    lambdaClient.market.reportMcpInstallResult
+      .mutate(cleanObject(reportData))
+      .catch((reportError) => {
+        console.warn('Failed to report MCP installation result:', reportError);
+      });
+  };
+
+  /**
+   * 上报插件调用结果
+   */
+  reportPluginCall = async (reportData: CallReportRequest) => {
+    await this.injectMPToken();
+
+    lambdaClient.market.reportCall.mutate(cleanObject(reportData)).catch((reportError) => {
+      console.warn('Failed to report call:', reportError);
+    });
+  };
+
+  // ============================== Models ==============================
+
+  getModelCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+    return lambdaClient.market.getModelCategories.query(params);
+  };
+
+  getModelDetail = async (params: {
+    identifier: string;
+    locale?: string;
+  }): Promise<DiscoverModelDetail | undefined> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getModelDetail.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getModelIdentifiers = async (): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getModelIdentifiers.query();
+  };
+
+  getModelList = async (params: ModelQueryParams = {}): Promise<ModelListResponse> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getModelList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 20,
+    });
+  };
+
+  // ============================== Plugin Market ==============================
+
+  getPluginCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getPluginCategories.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getPluginDetail = async (params: {
+    identifier: string;
+    locale?: string;
+    withManifest?: boolean;
+  }): Promise<DiscoverPluginDetail | undefined> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getPluginDetail.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getPluginIdentifiers = async (): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getPluginIdentifiers.query();
+  };
+
+  getPluginList = async (params: PluginQueryParams = {}): Promise<PluginListResponse> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getPluginList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 20,
+    });
+  };
+
+  // ============================== Providers ==============================
+
+  getProviderDetail = async (params: {
+    identifier: string;
+    locale?: string;
+    withReadme?: boolean;
+  }): Promise<DiscoverProviderDetail | undefined> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getProviderDetail.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getProviderIdentifiers = async (): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getProviderIdentifiers.query();
+  };
+
+  getProviderList = async (params: ProviderQueryParams = {}): Promise<ProviderListResponse> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getProviderList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 20,
+    });
+  };
+
+  // ============================== Helpers ==============================
+
+  private async injectMPToken() {
+    if (typeof localStorage === 'undefined') return;
+
+    // 检查服务端设置的状态标记 cookie
+    const tokenStatus = this.getTokenStatusFromCookie();
+    if (tokenStatus === 'active') return;
+
+    let clientId: string;
+    let clientSecret: string;
+
+    // 1. 从 localStorage 获取客户端信息
+    const item = localStorage.getItem('_mpc');
+    if (!item) {
+      // 2. 如果没有，则注册客户端
+      const clientInfo = await this.registerClient();
+      clientId = clientInfo.clientId;
+      clientSecret = clientInfo.clientSecret;
+
+      // 3. Base64 编码并保存到 localStorage
+      const clientData = JSON.stringify({ clientId, clientSecret });
+      const encodedData = btoa(clientData);
+      localStorage.setItem('_mpc', encodedData);
+    } else {
+      // 4. 如果有，则解码获取客户端信息
+      try {
+        const decodedData = atob(item);
+        const clientData = JSON.parse(decodedData);
+        clientId = clientData.clientId;
+        clientSecret = clientData.clientSecret;
+      } catch (error) {
+        console.error('Failed to decode client data:', error);
+        // 如果解码失败，重新注册
+        const clientInfo = await this.registerClient();
+        clientId = clientInfo.clientId;
+        clientSecret = clientInfo.clientSecret;
+
+        const clientData = JSON.stringify({ clientId, clientSecret });
+        const encodedData = btoa(clientData);
+        localStorage.setItem('_mpc', encodedData);
+      }
+    }
+
+    // 5. 获取访问令牌（服务端会自动设置 HTTP-Only cookie）
+    try {
+      const result = await lambdaClient.market.registerM2MToken.query({
+        clientId,
+        clientSecret,
+      });
+
+      // 检查服务端返回的结果
+      if (!result.success) {
+        console.warn(
+          'Token registration failed, client credentials may be invalid. Clearing and retrying...',
+        );
+
+        // 清空相关的本地存储数据
+        localStorage.removeItem('_mpc');
+
+        // 重新执行完整的注册流程（但只重试一次）
+        if (!this._isRetrying) {
+          this._isRetrying = true;
+          try {
+            await this.injectMPToken();
+          } finally {
+            this._isRetrying = false;
+          }
+        } else {
+          console.error('Failed to re-register after credential invalidation');
+        }
+
+        return;
+      }
+    } catch (error) {
+      console.error('Failed to register M2M token:', error);
+      return null;
+    }
+  }
+
+  private getTokenStatusFromCookie(): string | null {
+    if (typeof document === 'undefined') return null;
+
+    const cookies = document.cookie.split(';');
+    for (const cookie of cookies) {
+      const [name, value] = cookie.trim().split('=');
+      if (name === 'mp_token_status') {
+        return value;
+      }
+    }
+    return null;
+  }
+}
+
+export const discoverService = new DiscoverService();

package/src/services/global.ts

@@ -1,6 +1,6 @@
 import { DeepPartial } from 'utility-types';
 
-import { edgeClient } from '@/libs/trpc/client';
+import { lambdaClient } from '@/libs/trpc/client';
 import { LobeAgentConfig } from '@/types/agent';
 import { GlobalRuntimeConfig } from '@/types/serverConfig';
 
@@ -18,11 +18,11 @@ class GlobalService {
   };
 
   getGlobalConfig = async (): Promise<GlobalRuntimeConfig> => {
-    return edgeClient.config.getGlobalConfig.query();
+    return lambdaClient.config.getGlobalConfig.query();
   };
 
   getDefaultAgentConfig = async (): Promise<DeepPartial<LobeAgentConfig>> => {
-    return edgeClient.config.getDefaultAgentConfig.query();
+    return lambdaClient.config.getDefaultAgentConfig.query();
   };
 }
 

package/src/services/mcp.ts

@@ -1,42 +1,142 @@
-import { isDesktop } from '@/const/version';
+import { PluginManifest } from '@lobehub/market-sdk';
+import { CallReportRequest } from '@lobehub/market-types';
+
+import { CURRENT_VERSION, isDesktop } from '@/const/version';
 import { desktopClient, toolsClient } from '@/libs/trpc/client';
 import { ChatToolPayload } from '@/types/message';
+import { CheckMcpInstallResult } from '@/types/plugins';
 import { CustomPluginMetadata } from '@/types/tool/plugin';
+import { safeParseJSON } from '@/utils/safeParseJSON';
+
+import { discoverService } from './discover';
+
+/**
+ * 计算对象的字节大小
+ * @param obj 要计算大小的对象
+ * @returns 字节大小
+ */
+function calculateObjectSizeBytes(obj: any): number {
+  try {
+    const jsonString = JSON.stringify(obj);
+    return new TextEncoder().encode(jsonString).length;
+  } catch (error) {
+    console.warn('Failed to calculate object size:', error);
+    return 0;
+  }
+}
 
 class MCPService {
-  async invokeMcpToolCall(payload: ChatToolPayload, { signal }: { signal?: AbortSignal }) {
+  async invokeMcpToolCall(
+    payload: ChatToolPayload,
+    { signal, topicId }: { signal?: AbortSignal; topicId?: string },
+  ) {
     const { pluginSelectors } = await import('@/store/tool/selectors');
     const { getToolStoreState } = await import('@/store/tool/store');
 
     const s = getToolStoreState();
     const { identifier, arguments: args, apiName } = payload;
 
-    const plugin = pluginSelectors.getCustomPluginById(identifier)(s);
+    const installPlugin = pluginSelectors.getInstalledPluginById(identifier)(s);
+    const customPlugin = pluginSelectors.getCustomPluginById(identifier)(s);
+
+    const plugin = installPlugin || customPlugin;
 
     if (!plugin) return;
 
     const data = {
       args,
+      env: plugin.settings,
       params: { ...plugin.customParams?.mcp, name: identifier } as any,
       toolName: apiName,
     };
 
     const isStdio = plugin?.customParams?.mcp?.type === 'stdio';
 
-    // For desktop and stdio, use the desktopClient
-    if (isDesktop && isStdio) {
-      return desktopClient.mcp.callTool.mutate(data, { signal });
-    }
+    // 记录调用开始时间
+    const callStartTime = Date.now();
+    let success = false;
+    let errorCode: string | undefined;
+    let errorMessage: string | undefined;
+    let result: any;
+
+    try {
+      // For desktop and stdio, use the desktopClient
+      if (isDesktop && isStdio) {
+        result = await desktopClient.mcp.callTool.mutate(data, { signal });
+      } else {
+        result = await toolsClient.mcp.callTool.mutate(data, { signal });
+      }
 
-    return toolsClient.mcp.callTool.mutate(data, { signal });
+      success = true;
+      return result;
+    } catch (error) {
+      success = false;
+      const err = error as Error;
+      errorCode = 'CALL_FAILED';
+      errorMessage = err.message;
+
+      // 重新抛出错误，保持原有的错误处理逻辑
+      throw error;
+    } finally {
+      // 异步上报调用结果，不影响主流程
+      const callEndTime = Date.now();
+      const callDurationMs = callEndTime - callStartTime;
+
+      // 计算请求大小
+      const inputParams = safeParseJSON(args) || args;
+
+      const requestSizeBytes = calculateObjectSizeBytes(inputParams);
+      // 计算响应大小
+      const responseSizeBytes = success ? calculateObjectSizeBytes(result) : 0;
+
+      const isCustomPlugin = !!customPlugin;
+      // 构造上报数据
+      const reportData: CallReportRequest = {
+        callDurationMs,
+        customPluginInfo: isCustomPlugin
+          ? {
+              avatar: plugin.manifest?.meta.avatar,
+              description: plugin.manifest?.meta.description,
+              name: plugin.manifest?.meta.title,
+            }
+          : undefined,
+        errorCode,
+        errorMessage,
+        identifier,
+        inputParams,
+        isCustomPlugin,
+        metadata: {
+          appVersion: CURRENT_VERSION,
+          command: plugin.customParams?.mcp?.command,
+          mcpType: plugin.customParams?.mcp?.type,
+        },
+        methodName: apiName,
+        methodType: 'tool' as const,
+        outputResult: success ? result : undefined,
+        requestSizeBytes,
+        responseSizeBytes,
+        sessionId: topicId,
+        success,
+        version: plugin.manifest!.version || 'unknown',
+      };
+
+      // 异步上报，不影响主流程
+      discoverService.reportPluginCall(reportData).catch((reportError) => {
+        console.warn('Failed to report MCP tool call:', reportError);
+      });
+    }
   }
 
   async getStreamableMcpServerManifest(
     identifier: string,
     url: string,
     metadata?: CustomPluginMetadata,
+    signal?: AbortSignal,
   ) {
-    return toolsClient.mcp.getStreamableMcpServerManifest.query({ identifier, metadata, url });
+    return toolsClient.mcp.getStreamableMcpServerManifest.query(
+      { identifier, metadata, url },
+      { signal },
+    );
   }
 
   async getStdioMcpServerManifest(
@@ -47,8 +147,29 @@ class MCPService {
       name: string;
     },
     metadata?: CustomPluginMetadata,
+    signal?: AbortSignal,
   ) {
-    return desktopClient.mcp.getStdioMcpServerManifest.query({ ...stdioParams, metadata });
+    return desktopClient.mcp.getStdioMcpServerManifest.query(
+      { ...stdioParams, metadata },
+      { signal },
+    );
+  }
+
+  /**
+   * 检查 MCP 插件安装状态
+   * @param manifest MCP 插件清单
+   * @param signal AbortSignal 用于取消请求
+   * @returns 安装检测结果
+   */
+  async checkInstallation(
+    manifest: PluginManifest,
+    signal?: AbortSignal,
+  ): Promise<CheckMcpInstallResult> {
+    // 将所有部署选项传递给主进程进行检查
+    return desktopClient.mcp.validMcpServerInstallable.mutate(
+      { deploymentOptions: manifest.deploymentOptions as any },
+      { signal },
+    );
   }
 }
 

package/src/services/plugin/_deprecated.ts

@@ -23,7 +23,7 @@ export class ClientService implements IPluginService {
     return PluginModel.create({ ...customPlugin, type: 'customPlugin' });
   }
 
-  async updatePlugin(id: string, value: LobeToolCustomPlugin) {
+  async updatePlugin(id: string, value: Partial<LobeToolCustomPlugin>) {
     await PluginModel.update(id, value);
     return;
   }

package/src/services/plugin/type.ts

@@ -4,8 +4,10 @@ import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
 export interface InstallPluginParams {
+  customParams?: Record<string, any>;
   identifier: string;
   manifest: LobeChatPluginManifest;
+  settings?: Record<string, any>;
   type: 'plugin' | 'customPlugin';
 }
 
@@ -15,7 +17,7 @@ export interface IPluginService {
   installPlugin: (plugin: InstallPluginParams) => Promise<void>;
   removeAllPlugins: () => Promise<void>;
   uninstallPlugin: (identifier: string) => Promise<void>;
-  updatePlugin: (id: string, value: LobeToolCustomPlugin) => Promise<void>;
+  updatePlugin: (id: string, value: Partial<LobeToolCustomPlugin>) => Promise<void>;
   updatePluginManifest: (id: string, manifest: LobeChatPluginManifest) => Promise<void>;
   updatePluginSettings: (id: string, settings: any, signal?: AbortSignal) => Promise<void>;
 }

package/src/services/tool.ts

@@ -1,15 +1,18 @@
-import { edgeClient } from '@/libs/trpc/client';
+import { lambdaClient } from '@/libs/trpc/client';
 import { globalHelpers } from '@/store/global/helpers';
-import { DiscoverPlugintem } from '@/types/discover';
+import { PluginQueryParams } from '@/types/discover';
 import { convertOpenAIManifestToLobeManifest, getToolManifest } from '@/utils/toolManifest';
 
 class ToolService {
-  getToolList = async (): Promise<DiscoverPlugintem[]> => {
+  getOldPluginList = async (params: PluginQueryParams): Promise<any> => {
     const locale = globalHelpers.getCurrentLanguage();
 
-    const data = await edgeClient.market.getPluginIndex.query({ locale });
-
-    return data.plugins;
+    return lambdaClient.market.getPluginList.query({
+      ...params,
+      locale,
+      page: params.page ? Number(params.page) : 1,
+      pageSize: params.pageSize ? Number(params.pageSize) : 20,
+    });
   };
 
   getToolManifest = getToolManifest;

package/src/store/chat/slices/plugin/action.test.ts

@@ -1,5 +1,4 @@
 import { act, renderHook } from '@testing-library/react';
-import { Md5 } from 'ts-md5';
 import { Mock, afterEach, describe, expect, it, vi } from 'vitest';
 
 import { LOADING_FLAT } from '@/const/message';
@@ -10,8 +9,8 @@ import { chatSelectors } from '@/store/chat/selectors';
 import { useChatStore } from '@/store/chat/store';
 import { messageMapKey } from '@/store/chat/utils/messageMapKey';
 import { useToolStore } from '@/store/tool';
-import { ChatErrorType } from '@/types/fetch';
 import { ChatMessage, ChatToolPayload, MessageToolCall } from '@/types/message';
+import { genToolCallShortMD5Hash } from '@/utils/toolCall';
 
 const invokeStandaloneTypePlugin = useChatStore.getState().invokeStandaloneTypePlugin;
 
@@ -1045,7 +1044,7 @@ describe('ChatPluginAction', () => {
 
     it('should handle MD5 hashed API names', () => {
       const apiName = 'testApi';
-      const md5Hash = Md5.hashStr(apiName);
+      const md5Hash = genToolCallShortMD5Hash(apiName);
       const toolCalls: MessageToolCall[] = [
         {
           id: 'tool1',