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

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

@@ -1,22 +1,32 @@
 import { Autowired } from '@opensumi/di';
 import { CommandContribution, CommandRegistry, URI } from '@opensumi/ide-core-browser';
-import { Domain } from '@opensumi/ide-core-common';
+import { Domain, MCPConfigServiceToken } from '@opensumi/ide-core-common';
 import { WorkbenchEditorService } from '@opensumi/ide-editor';
 
 import { MCP_CONFIG_COMPONENTS_SCHEME_ID } from './mcp-config.contribution';
+import { MCPConfigService } from './mcp-config.service';
 
-export const OPEN_MCP_CONFIG_COMMAND = {
-  id: 'opensumi-mcp.openConfig',
-  label: 'Open MCP Configuration',
-};
+export namespace MCPConfigCommands {
+  export const OPEN_MCP_CONFIG = {
+    id: 'mcp.openConfig',
+    label: 'Open MCP Configuration',
+  };
 
+  export const OPEN_MCP_CONFIG_FILE = {
+    id: 'mcp.openConfigFile',
+    label: 'Open MCP Configuration (JSON)',
+  };
+}
 @Domain(CommandContribution)
 export class MCPConfigCommandContribution implements CommandContribution {
   @Autowired(WorkbenchEditorService)
   private readonly editorService: WorkbenchEditorService;
 
+  @Autowired(MCPConfigServiceToken)
+  private readonly mcpConfigService: MCPConfigService;
+
   registerCommands(registry: CommandRegistry) {
-    registry.registerCommand(OPEN_MCP_CONFIG_COMMAND, {
+    registry.registerCommand(MCPConfigCommands.OPEN_MCP_CONFIG, {
       execute: () => {
         const uri = new URI().withScheme(MCP_CONFIG_COMPONENTS_SCHEME_ID);
         this.editorService.open(uri, {
@@ -25,5 +35,11 @@ export class MCPConfigCommandContribution implements CommandContribution {
         });
       },
     });
+
+    registry.registerCommand(MCPConfigCommands.OPEN_MCP_CONFIG_FILE, {
+      execute: () => {
+        this.mcpConfigService.openConfigFile();
+      },
+    });
   }
 }

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

@@ -1,5 +1,8 @@
 import { Autowired } from '@opensumi/di';
 import { getIcon } from '@opensumi/ide-components';
+import { MenuContribution } from '@opensumi/ide-core-browser/lib/menu/next';
+import { IMenuRegistry } from '@opensumi/ide-core-browser/lib/menu/next/base';
+import { MenuId } from '@opensumi/ide-core-browser/lib/menu/next/menu-id';
 import { LabelService } from '@opensumi/ide-core-browser/lib/services';
 import { Domain, URI, localize } from '@opensumi/ide-core-common';
 import {
@@ -13,14 +16,15 @@ import { IconService } from '@opensumi/ide-theme/lib/browser';
 import { IWorkspaceService } from '@opensumi/ide-workspace/lib/common';
 
 import { MCPConfigView } from './components/mcp-config.view';
+import { MCPConfigCommands } from './mcp-config.commands';
 
 const COMPONENTS_ID = 'opensumi-mcp-config-viewer';
 export const MCP_CONFIG_COMPONENTS_SCHEME_ID = 'mcp-config';
 
 export type IMCPConfigResource = IResource<{ configType: string }>;
 
-@Domain(BrowserEditorContribution)
-export class MCPConfigContribution implements BrowserEditorContribution {
+@Domain(BrowserEditorContribution, MenuContribution)
+export class MCPConfigContribution implements BrowserEditorContribution, MenuContribution {
   @Autowired(IWorkspaceService)
   protected readonly workspaceService: IWorkspaceService;
 
@@ -63,4 +67,22 @@ export class MCPConfigContribution implements BrowserEditorContribution {
       },
     });
   }
+
+  registerMenus(menus: IMenuRegistry) {
+    menus.registerMenuItem(MenuId.EditorTitle, {
+      command: MCPConfigCommands.OPEN_MCP_CONFIG_FILE.id,
+      iconClass: getIcon('open'),
+      group: 'navigation',
+      order: 4,
+      when: `resourceScheme == ${MCP_CONFIG_COMPONENTS_SCHEME_ID}`,
+    });
+
+    menus.registerMenuItem(MenuId.EditorTitle, {
+      command: MCPConfigCommands.OPEN_MCP_CONFIG.id,
+      iconClass: getIcon('open'),
+      group: 'navigation',
+      order: 4,
+      when: 'resourceFilename =~ /mcp.json/',
+    });
+  }
 }

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