@opensumi/ide-ai-native 3.8.3-next-1745568063.0 → 3.8.3-next-1745835516.0

package/src/browser/mcp/config/mcp-config.service.ts

@@ -0,0 +1,285 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { ILogger } from '@opensumi/ide-core-browser';
+import { PreferenceService } from '@opensumi/ide-core-browser/lib/preferences';
+import {
+  Deferred,
+  Disposable,
+  Emitter,
+  IStorage,
+  PreferenceScope,
+  STORAGE_NAMESPACE,
+  StorageProvider,
+  localize,
+} from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { IMessageService } from '@opensumi/ide-overlay';
+
+import { BUILTIN_MCP_SERVER_NAME, ISumiMCPServerBackend, SumiMCPServerProxyServicePath } from '../../../common';
+import {
+  MCPServerDescription,
+  MCPServersEnabledKey,
+  SSEMCPServerDescription,
+  StdioMCPServerDescription,
+} from '../../../common/mcp-server-manager';
+import { MCPServer, MCP_SERVER_TYPE } from '../../../common/types';
+import { MCPServerProxyService } from '../mcp-server-proxy.service';
+
+import { MCPServerFormData } from './components/mcp-server-form';
+
+@Injectable()
+export class MCPConfigService extends Disposable {
+  @Autowired(SumiMCPServerProxyServicePath)
+  private readonly sumiMCPServerBackendProxy: ISumiMCPServerBackend;
+
+  @Autowired(MCPServerProxyService)
+  private readonly mcpServerProxyService: MCPServerProxyService;
+
+  @Autowired(PreferenceService)
+  private readonly preferenceService: PreferenceService;
+
+  @Autowired(IMessageService)
+  private readonly messageService: IMessageService;
+
+  @Autowired(StorageProvider)
+  private readonly storageProvider: StorageProvider;
+
+  @Autowired(WorkbenchEditorService)
+  private readonly workbenchEditorService: WorkbenchEditorService;
+
+  @Autowired(ILogger)
+  private readonly logger: ILogger;
+
+  private chatStorage: IStorage;
+  private whenReadyDeferred = new Deferred<void>();
+
+  private readonly mcpServersChangeEventEmitter = new Emitter<boolean>();
+
+  constructor() {
+    super();
+
+    this.init();
+    this.disposables.push(
+      this.mcpServerProxyService.onChangeMCPServers(() => {
+        this.fireMCPServersChange();
+      }),
+    );
+    this.disposables.push(
+      this.preferenceService.onSpecificPreferenceChange('mcp', () => {
+        this.fireMCPServersChange();
+      }),
+    );
+  }
+
+  private async init() {
+    this.chatStorage = await this.storageProvider(STORAGE_NAMESPACE.CHAT);
+    this.whenReadyDeferred.resolve();
+  }
+
+  get whenReady() {
+    return this.whenReadyDeferred.promise;
+  }
+
+  get onMCPServersChange() {
+    return this.mcpServersChangeEventEmitter.event;
+  }
+
+  fireMCPServersChange(isInit: boolean = false) {
+    this.mcpServersChangeEventEmitter.fire(isInit);
+  }
+
+  async getServers(): Promise<MCPServer[]> {
+    // Get workspace MCP server configurations
+    const { value: mcpConfig } = this.preferenceService.resolve<{ mcpServers: Record<string, any> }>(
+      'mcp',
+      { mcpServers: {} },
+      undefined,
+    );
+
+    if (!mcpConfig?.mcpServers || Object.keys(mcpConfig.mcpServers).length === 0) {
+      const runningServers = await this.mcpServerProxyService.$getServers();
+      const builtinServer = runningServers.find((server) => server.name === BUILTIN_MCP_SERVER_NAME);
+      return builtinServer ? [builtinServer] : [];
+    }
+
+    const userServers = mcpConfig.mcpServers.map((server) => {
+      const name = Object.keys(server)[0];
+      const serverConfig = server[name];
+      if (serverConfig.url) {
+        return {
+          name,
+          type: MCP_SERVER_TYPE.SSE,
+          url: serverConfig.url,
+        };
+      }
+      return {
+        name,
+        type: MCP_SERVER_TYPE.STDIO,
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: serverConfig.env,
+      };
+    });
+
+    const runningServers = await this.mcpServerProxyService.$getServers();
+    const builtinServer = runningServers.find((server) => server.name === BUILTIN_MCP_SERVER_NAME);
+
+    // Merge server configs with running status
+    const allServers = userServers.map((server) => {
+      const runningServer = runningServers.find((s) => s.name === server.name);
+      return {
+        ...server,
+        isStarted: runningServer?.isStarted || false,
+        tools: runningServer?.tools || [],
+      };
+    }) as MCPServer[];
+
+    // Add built-in server at the beginning if it exists
+    if (builtinServer) {
+      allServers.unshift(builtinServer);
+    }
+
+    return allServers;
+  }
+
+  async controlServer(serverName: string, start: boolean): Promise<void> {
+    try {
+      if (start) {
+        await this.mcpServerProxyService.$startServer(serverName);
+      } else {
+        await this.mcpServerProxyService.$stopServer(serverName);
+      }
+
+      const enabledMCPServers = this.chatStorage.get<string[]>(MCPServersEnabledKey, [BUILTIN_MCP_SERVER_NAME]);
+      const enabledMCPServersSet = new Set(enabledMCPServers);
+
+      if (start) {
+        enabledMCPServersSet.add(serverName);
+      } else {
+        enabledMCPServersSet.delete(serverName);
+      }
+      this.chatStorage.set(MCPServersEnabledKey, Array.from(enabledMCPServersSet));
+    } catch (error) {
+      const msg = error.message || error;
+      this.logger.error(`Failed to ${start ? 'start' : 'stop'} server ${serverName}:`, msg);
+      this.messageService.error(msg);
+      throw error;
+    }
+  }
+
+  async saveServer(data: MCPServerFormData): Promise<void> {
+    await this.whenReady;
+    const { value: mcpConfig } = this.preferenceService.resolve<{ mcpServers: Record<string, any>[] }>(
+      'mcp',
+      { mcpServers: [] },
+      undefined,
+    );
+    const servers = mcpConfig!.mcpServers;
+    const existingIndex = servers?.findIndex((s) => s.name === data.name);
+
+    let serverConfig;
+    if (data.type === MCP_SERVER_TYPE.SSE) {
+      serverConfig = { [data.name]: { url: (data as SSEMCPServerDescription).url } };
+    } else {
+      serverConfig = {
+        [data.name]: {
+          command: (data as StdioMCPServerDescription).command,
+          args: (data as StdioMCPServerDescription).args,
+          env: (data as StdioMCPServerDescription).env,
+        },
+      };
+    }
+    if (existingIndex !== undefined && existingIndex >= 0) {
+      servers[existingIndex] = serverConfig;
+    } else {
+      servers.push(serverConfig);
+    }
+    await this.sumiMCPServerBackendProxy.$addOrUpdateServer(data as MCPServerDescription);
+    await this.preferenceService.set('mcp', { mcpServers: servers });
+  }
+
+  async deleteServer(serverName: string): Promise<void> {
+    const { value: mcpConfig } = this.preferenceService.resolve<{ mcpServers: Record<string, any>[] }>(
+      'mcp',
+      { mcpServers: [] },
+      undefined,
+    );
+    const servers = mcpConfig?.mcpServers;
+    const serverIndex = servers?.findIndex((s) => Object.keys(s)[0] === serverName);
+    if (serverIndex !== undefined && serverIndex >= 0) {
+      servers?.splice(serverIndex, 1);
+    }
+    await this.sumiMCPServerBackendProxy.$removeServer(serverName);
+    await this.preferenceService.set('mcp', { mcpServers: servers });
+  }
+
+  async syncServer(serverName: string): Promise<void> {
+    await this.sumiMCPServerBackendProxy.$syncServer(serverName);
+  }
+
+  async getServerConfigByName(serverName: string): Promise<MCPServerDescription | undefined> {
+    const { value: mcpConfig } = this.preferenceService.resolve<{ mcpServers: Record<string, any>[] }>(
+      'mcp',
+      { mcpServers: [] },
+      undefined,
+    );
+    await this.whenReady;
+    const enabledMCPServers = this.chatStorage.get<string[]>(MCPServersEnabledKey, [BUILTIN_MCP_SERVER_NAME]);
+    const servers = mcpConfig?.mcpServers;
+    const server = servers?.find((s) => Object.keys(s)[0] === serverName);
+    if (server) {
+      if (server[serverName].url) {
+        return {
+          name: serverName,
+          type: MCP_SERVER_TYPE.SSE,
+          url: server[serverName].url,
+          enabled: enabledMCPServers.includes(serverName),
+        };
+      } else {
+        return {
+          name: serverName,
+          type: MCP_SERVER_TYPE.STDIO,
+          command: server[serverName].command,
+          args: server[serverName].args,
+          env: server[serverName].env,
+          enabled: enabledMCPServers.includes(serverName),
+        };
+      }
+    }
+    return undefined;
+  }
+
+  getReadableServerType(type: string): string {
+    switch (type) {
+      case MCP_SERVER_TYPE.STDIO:
+        return localize('ai.native.mcp.type.stdio');
+      case MCP_SERVER_TYPE.SSE:
+        return localize('ai.native.mcp.type.sse');
+      case MCP_SERVER_TYPE.BUILTIN:
+        return localize('ai.native.mcp.type.builtin');
+      default:
+        return type;
+    }
+  }
+
+  async openConfigFile(): Promise<void> {
+    let config = this.preferenceService.resolve<{ mcpServers: Record<string, any>[] }>(
+      'mcp',
+      { mcpServers: [] },
+      undefined,
+    );
+    if (config.scope === PreferenceScope.Default) {
+      await this.preferenceService.set('mcp', { mcpServers: [] }, PreferenceScope.Workspace);
+      config = this.preferenceService.resolve<{ mcpServers: Record<string, any>[] }>(
+        'mcp',
+        { mcpServers: [] },
+        undefined,
+      );
+    }
+    const uri = config.configUri;
+    if (uri) {
+      this.workbenchEditorService.open(uri, {
+        preview: false,
+      });
+    }
+  }
+}

package/src/browser/mcp/mcp-folder-preference-provider.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@opensumi/di';
+import { FolderFilePreferenceProvider } from '@opensumi/ide-preferences/lib/browser/folder-file-preference-provider';
+
+@Injectable()
+export class MCPFolderPreferenceProvider extends FolderFilePreferenceProvider {
+  protected parse(content: string): any {
+    const mcp = super.parse(content);
+    if (mcp === undefined) {
+      return undefined;
+    }
+    return { mcp: { ...mcp } };
+  }
+
+  protected getPath(preferenceName: string): string[] | undefined {
+    if (preferenceName === 'mcp') {
+      return [];
+    }
+    if (preferenceName.startsWith('mcp.')) {
+      return [preferenceName.substr('mcp.'.length)];
+    }
+    return undefined;
+  }
+}

package/src/browser/mcp/mcp-preferences-contribution.ts

@@ -0,0 +1,62 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import {
+  CodeSchemaId,
+  Domain,
+  IJSONSchema,
+  IJSONSchemaRegistry,
+  JsonSchemaContribution,
+  MaybePromise,
+  PreferenceConfiguration,
+  PreferenceContribution,
+  PreferenceSchema,
+  URI,
+  getIcon,
+  localize,
+} from '@opensumi/ide-core-browser';
+import {
+  BrowserEditorContribution,
+  IResource,
+  IResourceProvider,
+  ResourceService,
+} from '@opensumi/ide-editor/lib/browser';
+
+import { MCPPreferencesSchema, MCPSchema, MCPSchemaUri } from './mcp-preferences';
+
+@Injectable()
+export class MCPResourceProvider implements IResourceProvider {
+  provideResource(uri: URI): MaybePromise<IResource<any>> {
+    return {
+      supportsRevive: true,
+      name: localize('menu-bar.title.debug'),
+      icon: getIcon('debug'),
+      uri,
+    };
+  }
+
+  provideResourceSubname(): string | null {
+    return null;
+  }
+
+  async shouldCloseResource(): Promise<boolean> {
+    return true;
+  }
+}
+
+@Domain(PreferenceContribution, PreferenceConfiguration, BrowserEditorContribution, JsonSchemaContribution)
+export class MCPPreferencesContribution
+  implements PreferenceContribution, PreferenceConfiguration, BrowserEditorContribution, JsonSchemaContribution
+{
+  @Autowired(MCPResourceProvider)
+  private readonly prefResourceProvider: MCPResourceProvider;
+
+  schema: PreferenceSchema = MCPPreferencesSchema;
+  name = 'mcp';
+
+  registerResource(resourceService: ResourceService): void {
+    resourceService.registerResourceProvider(this.prefResourceProvider);
+  }
+
+  registerSchema(registry: IJSONSchemaRegistry) {
+    registry.registerSchema(MCPSchemaUri, MCPSchema, ['mcp.json']);
+  }
+}

package/src/browser/mcp/mcp-preferences.ts

@@ -0,0 +1,48 @@
+import { PreferenceSchema } from '@opensumi/ide-core-browser';
+import { CodeSchemaId, IJSONSchema } from '@opensumi/ide-core-common';
+
+export const MCPSchemaUri = `${CodeSchemaId.mcp}/user`;
+
+export const MCPPreferencesSchema: PreferenceSchema = {
+  type: 'object',
+  scope: 'resource',
+  properties: {
+    mcp: {
+      $ref: MCPSchemaUri,
+      description: 'MCP configuration for Workspace.',
+      defaultValue: { mcpServers: [] },
+    },
+  },
+};
+
+export const MCPSchema: IJSONSchema = {
+  $id: MCPSchemaUri,
+  type: 'object',
+  title: 'MCP',
+  required: [],
+  default: { mcpServers: [] },
+  properties: {
+    mcpServers: {
+      type: 'object',
+      description: 'List of MCP Servers. Add new servers or edit existing ones by using IntelliSense.',
+      properties: {
+        command: {
+          type: 'string',
+          description: 'The command to start the MCP server.',
+        },
+        args: {
+          type: 'array',
+          description: 'The arguments for the command to start the MCP server.',
+        },
+        env: {
+          type: 'object',
+          description: 'The environment variables for the command to start the MCP server.',
+        },
+        url: {
+          type: 'string',
+          description: 'The SSE URL for the MCP server.',
+        },
+      },
+    },
+  },
+};

package/src/browser/preferences/schema.ts

@@ -105,6 +105,9 @@ export const aiNativePreferenceSchema: PreferenceSchema = {
       type: 'number',
       description: localize('preference.ai.native.maxTokens.description'),
     },
+    /**
+     * @deprecated This configuration will be removed in the future. Please use `mcp.json` instead.
+     */
     [AINativeSettingSectionsId.MCPServers]: {
       type: 'array',
       default: [],

package/src/common/mcp-server-manager.ts

@@ -77,7 +77,7 @@ export interface SSEMCPServerDescription extends BaseMCPServerDescription {
   /**
    * The host of the MCP server.
    */
-  serverHost: string;
+  url: string;
   transportOptions?: SSEClientTransportOptions;
 }
 
@@ -99,3 +99,5 @@ export type MCPServerDescription =
 
 export const MCPServerManager = Symbol('MCPServerManager');
 export const MCPServerManagerPath = 'ServicesMCPServerManager';
+
+export const MCPServersEnabledKey = 'mcp_servers_enabled';

package/src/common/types.ts

@@ -49,7 +49,7 @@ export interface MCPServer {
   tools?: MCPTool[];
   command?: string;
   type?: string;
-  serverHost?: string;
+  url?: string;
 }
 
 export interface MCPTool {

package/src/node/mcp/sumi-mcp-server.ts

@@ -176,7 +176,7 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
             name: server.getServerName(),
             isStarted: server.isStarted(),
             type: MCP_SERVER_TYPE.SSE,
-            serverHost: server.serverHost,
+            url: server.url,
             tools,
           };
         }

package/src/node/mcp-server-manager-impl.ts

@@ -157,11 +157,11 @@ export class MCPServerManagerImpl implements MCPServerManager {
         this.servers.set(name, newServer);
       }
     } else if (description.type === MCP_SERVER_TYPE.SSE) {
-      const { name, serverHost, transportOptions } = description;
+      const { name, url, transportOptions } = description;
       if (existingServer) {
-        existingServer.update(serverHost);
+        existingServer.update(url);
       } else {
-        const newServer = new SSEMCPServer(name, serverHost, this.logger, transportOptions);
+        const newServer = new SSEMCPServer(name, url, this.logger, transportOptions);
         this.servers.set(name, newServer);
       }
     }
@@ -188,7 +188,11 @@ export class MCPServerManagerImpl implements MCPServerManager {
         // 如果是 enabled 为 false 的 server，则不进行启动
         continue;
       }
-      await this.startServer(server.name);
+      try {
+        await this.startServer(server.name);
+      } catch (error) {
+        this.logger.error(`Error in addExternalMCPServers for ${server.name}:`, error);
+      }
     }
   }
 

package/src/node/mcp-server.sse.ts

@@ -11,19 +11,20 @@ import { SSEClientTransportOptions } from '../common/types';
 global.EventSource = EventSource as any;
 export class SSEMCPServer implements IMCPServer {
   private name: string;
-  public serverHost: string;
+  public url: string;
   private transportOptions?: SSEClientTransportOptions;
   private client: Client;
   private started: boolean = false;
+  private toolNameMap: Map<string, string> = new Map(); // Map sanitized tool names to original names
 
   constructor(
     name: string,
-    serverHost: string,
+    url: string,
     private readonly logger?: ILogger,
     private readonly options?: SSEClientTransportOptions,
   ) {
     this.name = name;
-    this.serverHost = serverHost;
+    this.url = url;
     this.transportOptions = options;
   }
 
@@ -43,11 +44,11 @@ export class SSEMCPServer implements IMCPServer {
     if (this.started) {
       return;
     }
-    this.logger?.log(`Starting server "${this.name}" with serverHost: ${this.serverHost}`);
+    this.logger?.log(`Starting server "${this.name}" with url: ${this.url}`);
 
     const SSEClientTransport = (await import('@modelcontextprotocol/sdk/client/sse.js')).SSEClientTransport;
 
-    const transport = new SSEClientTransport(new URL(this.serverHost), this.transportOptions);
+    const transport = new SSEClientTransport(new URL(this.url), this.transportOptions);
 
     transport.onerror = (error) => {
       this.logger?.error('Transport Error:', error);
@@ -66,8 +67,13 @@ export class SSEMCPServer implements IMCPServer {
       this.logger?.error('Error in MCP client:', error);
     };
 
-    await this.client.connect(transport);
-    this.started = true;
+    try {
+      await this.client.connect(transport);
+      this.started = true;
+    } catch (error) {
+      this.logger?.error(`Error in startServer for ${this.name}:`, error);
+      throw error;
+    }
   }
 
   async callTool(toolName: string, toolCallId: string, arg_string: string) {
@@ -76,13 +82,15 @@ export class SSEMCPServer implements IMCPServer {
       args = JSON.parse(arg_string);
     } catch (error) {
       this.logger?.error(
-        `Failed to parse arguments for calling tool "${toolName}" in MCP server "${this.name}" with serverHost "${this.serverHost}".
+        `Failed to parse arguments for calling tool "${toolName}" in MCP server "${this.name}" with url "${this.url}".
                 Invalid JSON: ${arg_string}`,
         error,
       );
     }
+    // Convert sanitized tool name back to original name if it exists in the map
+    const originalToolName = this.toolNameMap.get(toolName) || toolName;
     const params = {
-      name: toolName,
+      name: originalToolName,
       arguments: args,
       toolCallId,
     };
@@ -90,13 +98,32 @@ export class SSEMCPServer implements IMCPServer {
   }
 
   async getTools() {
-    const tools = await this.client.listTools();
-    this.logger?.log(`Got tools from MCP server "${this.name}" with serverHost "${this.serverHost}":`, tools);
-    return tools;
+    const originalTools = await this.client.listTools();
+    this.toolNameMap.clear();
+    const toolsArray = originalTools.tools || [];
+    const sanitizedToolsArray = toolsArray.map((tool) => {
+      const originalName = tool.name;
+      // Remove Chinese characters from the tool name
+      // Claude 3.5+ Sonnet 不支持中文 Tool Name
+      const sanitizedName = originalName.replace(/[\u4e00-\u9fa5]/g, '');
+      // If the name changed, store the mapping
+      if (sanitizedName !== originalName) {
+        this.toolNameMap.set(sanitizedName, originalName);
+        return { ...tool, name: sanitizedName };
+      }
+      return tool;
+    });
+    const sanitizedTools = {
+      ...originalTools,
+      tools: sanitizedToolsArray,
+    };
+    this.logger?.log(`Got tools from MCP server "${this.name}" with url "${this.url}":`, sanitizedTools);
+    this.logger?.log('Tool name mapping: ', Object.fromEntries(this.toolNameMap));
+    return sanitizedTools;
   }
 
-  update(serverHost: string): void {
-    this.serverHost = serverHost;
+  update(url: string): void {
+    this.url = url;
   }
 
   async stop(): Promise<void> {

package/src/node/mcp-server.stdio.ts

@@ -14,6 +14,7 @@ export class StdioMCPServer implements IMCPServer {
   private client: Client;
   private env?: { [key: string]: string };
   private started: boolean = false;
+  private toolNameMap: Map<string, string> = new Map(); // Map sanitized tool names to original names
 
   constructor(
     name: string,
@@ -95,8 +96,10 @@ export class StdioMCPServer implements IMCPServer {
         error,
       );
     }
+    // Convert sanitized tool name back to original name if it exists in the map
+    const originalToolName = this.toolNameMap.get(toolName) || toolName;
     const params = {
-      name: toolName,
+      name: originalToolName,
       arguments: args,
       toolCallId,
     };
@@ -104,7 +107,28 @@ export class StdioMCPServer implements IMCPServer {
   }
 
   async getTools() {
-    return await this.client.listTools();
+    const originalTools = await this.client.listTools();
+    this.toolNameMap.clear();
+    // Process tool names to remove Chinese characters and create mapping
+    const toolsArray = originalTools.tools || [];
+    const sanitizedToolsArray = toolsArray.map((tool) => {
+      const originalName = tool.name;
+      // Remove Chinese characters from the tool name
+      // Claude 3.5+ Sonnet 不支持中文 Tool Name
+      const sanitizedName = originalName.replace(/[\u4e00-\u9fa5]/g, '');
+      if (sanitizedName !== originalName) {
+        this.toolNameMap.set(sanitizedName, originalName);
+        return { ...tool, name: sanitizedName };
+      }
+      return tool;
+    });
+    const sanitizedTools = {
+      ...originalTools,
+      tools: sanitizedToolsArray,
+    };
+    this.logger?.log(`Got tools from MCP server "${this.name}":`, sanitizedTools);
+    this.logger?.log('Tool name mapping: ', Object.fromEntries(this.toolNameMap));
+    return sanitizedTools;
   }
 
   update(command: string, args?: string[], env?: { [key: string]: string }): void {