feat: support MCP server and client

.gitignore

@@ -98,4 +98,5 @@ tools/workspace
 # jupyter
 .ipynb_checkpoints
 
-*.tsbuildinfo
+*.tsbuildinfo
+.env

packages/ai-native/__test__/node/mcp-server-manager-impl.test.ts

@@ -0,0 +1,195 @@
+import { MCPServerManagerImpl } from '../../src/node/mcp-server-manager-impl';
+import { MCPServerDescription } from '../../src/common/mcp-server-manager';
+import { IMCPServer, MCPServerImpl } from '../../src/node/mcp-server';
+
+jest.mock('../../src/node/mcp-server');
+
+describe('MCPServerManagerImpl', () => {
+  let manager: MCPServerManagerImpl;
+  let mockServer: jest.Mocked<IMCPServer>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    manager = new MCPServerManagerImpl();
+    mockServer = {
+      isStarted: jest.fn(),
+      start: jest.fn(),
+      callTool: jest.fn(),
+      getTools: jest.fn(),
+      update: jest.fn(),
+      stop: jest.fn(),
+    };
+    jest.mocked(MCPServerImpl).mockImplementation(() => mockServer as unknown as MCPServerImpl);
+  });
+
+  describe('addOrUpdateServer', () => {
+    const serverDescription: MCPServerDescription = {
+      name: 'test-server',
+      command: 'test-command',
+      args: [],
+      env: {}
+    };
+
+    it('should add a new server', () => {
+      manager.addOrUpdateServer(serverDescription);
+      expect(MCPServerImpl).toHaveBeenCalledWith(
+        serverDescription.name,
+        serverDescription.command,
+        serverDescription.args,
+        serverDescription.env
+      );
+    });
+
+    it('should update existing server', () => {
+      manager.addOrUpdateServer(serverDescription);
+      const updatedDescription = { ...serverDescription, command: 'new-command' };
+      manager.addOrUpdateServer(updatedDescription);
+      expect(mockServer.update).toHaveBeenCalledWith(
+        updatedDescription.command,
+        updatedDescription.args,
+        updatedDescription.env
+      );
+    });
+  });
+
+  describe('startServer', () => {
+    it('should start an existing server', async () => {
+      manager.addOrUpdateServer({
+        name: 'test-server',
+        command: 'test-command',
+        args: [],
+        env: {}
+      });
+
+      await manager.startServer('test-server');
+      expect(mockServer.start).toHaveBeenCalled();
+    });
+
+    it('should throw error when starting non-existent server', async () => {
+      await expect(manager.startServer('non-existent')).rejects.toThrow(
+        'MCP server "non-existent" not found.'
+      );
+    });
+  });
+
+  describe('stopServer', () => {
+    it('should stop an existing server', async () => {
+      manager.addOrUpdateServer({
+        name: 'test-server',
+        command: 'test-command',
+        args: [],
+        env: {}
+      });
+
+      await manager.stopServer('test-server');
+      expect(mockServer.stop).toHaveBeenCalled();
+    });
+
+    it('should throw error when stopping non-existent server', async () => {
+      await expect(manager.stopServer('non-existent')).rejects.toThrow(
+        'MCP server "non-existent" not found.'
+      );
+    });
+  });
+
+  describe('getStartedServers', () => {
+    it('should return list of started servers', async () => {
+      manager.addOrUpdateServer({
+        name: 'server1',
+        command: 'cmd1',
+        args: [],
+        env: {}
+      });
+      manager.addOrUpdateServer({
+        name: 'server2',
+        command: 'cmd2',
+        args: [],
+        env: {}
+      });
+
+      mockServer.isStarted.mockReturnValueOnce(true).mockReturnValueOnce(false);
+      const startedServers = await manager.getStartedServers();
+      expect(startedServers).toEqual(['server1']);
+    });
+  });
+
+  describe('getServerNames', () => {
+    it('should return list of all server names', async () => {
+      manager.addOrUpdateServer({
+        name: 'server1',
+        command: 'cmd1',
+        args: [],
+        env: {}
+      });
+      manager.addOrUpdateServer({
+        name: 'server2',
+        command: 'cmd2',
+        args: [],
+        env: {}
+      });
+
+      const serverNames = await manager.getServerNames();
+      expect(serverNames).toEqual(['server1', 'server2']);
+    });
+  });
+
+  describe('removeServer', () => {
+    it('should remove an existing server', () => {
+      manager.addOrUpdateServer({
+        name: 'test-server',
+        command: 'test-command',
+        args: [],
+        env: {}
+      });
+
+      manager.removeServer('test-server');
+      expect(mockServer.stop).toHaveBeenCalled();
+    });
+
+    it('should handle removing non-existent server', () => {
+      const consoleSpy = jest.spyOn(console, 'warn');
+      manager.removeServer('non-existent');
+      expect(consoleSpy).toHaveBeenCalledWith('MCP server "non-existent" not found.');
+    });
+  });
+
+  describe('callTool', () => {
+    it('should call tool on existing server', () => {
+      manager.addOrUpdateServer({
+        name: 'test-server',
+        command: 'test-command',
+        args: [],
+        env: {}
+      });
+
+      manager.callTool('test-server', 'test-tool', 'test-args');
+      expect(mockServer.callTool).toHaveBeenCalledWith('test-tool', 'test-args');
+    });
+
+    it('should throw error when calling tool on non-existent server', () => {
+      expect(() => manager.callTool('non-existent', 'test-tool', 'test-args')).toThrow(
+        'MCP server "test-tool" not found.'
+      );
+    });
+  });
+
+  describe('getTools', () => {
+    it('should get tools from existing server', async () => {
+      manager.addOrUpdateServer({
+        name: 'test-server',
+        command: 'test-command',
+        args: [],
+        env: {}
+      });
+
+      await manager.getTools('test-server');
+      expect(mockServer.getTools).toHaveBeenCalled();
+    });
+
+    it('should throw error when getting tools from non-existent server', async () => {
+      await expect(manager.getTools('non-existent')).rejects.toThrow(
+        'MCP server "non-existent" not found.'
+      );
+    });
+  });
+}); 

packages/ai-native/package.json

@@ -19,6 +19,10 @@
     "url": "[email protected]:opensumi/core.git"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^1.1.6",
+    "@ai-sdk/deepseek": "^0.1.8",
+    "@anthropic-ai/sdk": "^0.36.3",
+    "@modelcontextprotocol/sdk": "^1.3.1",
     "@opensumi/ide-components": "workspace:*",
     "@opensumi/ide-core-common": "workspace:*",
     "@opensumi/ide-core-node": "workspace:*",
@@ -38,8 +42,10 @@
     "@opensumi/ide-utils": "workspace:*",
     "@opensumi/ide-workspace": "workspace:*",
     "@xterm/xterm": "5.5.0",
+    "ai": "^4.1.21",
     "ansi-regex": "^2.0.0",
     "dom-align": "^1.7.0",
+    "openai": "^4.55.7",
     "react-chat-elements": "^12.0.10",
     "react-highlight": "^0.15.0",
     "tiktoken": "1.0.12",

packages/ai-native/src/browser/ai-core.contribution.ts

@@ -70,7 +70,11 @@ import {
   AI_CHAT_VIEW_ID,
   AI_MENU_BAR_DEBUG_TOOLBAR,
   ChatProxyServiceToken,
+  ISumiMCPServerBackend,
+  SumiMCPServerProxyServicePath,
 } from '../common';
+import { MCPServerDescription, MCPServerManager, MCPServerManagerPath } from '../common/mcp-server-manager';
+import { ToolInvocationRegistry, ToolInvocationRegistryImpl } from '../common/tool-invocation-registry';
 
 import { ChatProxyService } from './chat/chat-proxy.service';
 import { AIChatView } from './chat/chat.view';
@@ -94,10 +98,13 @@ import {
   IChatFeatureRegistry,
   IChatRenderRegistry,
   IIntelligentCompletionsRegistry,
+  IMCPServerRegistry,
   IProblemFixProviderRegistry,
   IRenameCandidatesProviderRegistry,
   IResolveConflictRegistry,
   ITerminalProviderRegistry,
+  MCPServerContribution,
+  TokenMCPServerRegistry,
 } from './types';
 import { InlineChatEditorController } from './widget/inline-chat/inline-chat-editor.controller';
 import { InlineChatFeatureRegistry } from './widget/inline-chat/inline-chat.feature.registry';
@@ -142,6 +149,12 @@ export class AINativeBrowserContribution
   @Autowired(AINativeCoreContribution)
   private readonly contributions: ContributionProvider<AINativeCoreContribution>;
 
+  @Autowired(MCPServerContribution)
+  private readonly mcpServerContributions: ContributionProvider<MCPServerContribution>;
+
+  @Autowired(TokenMCPServerRegistry)
+  private readonly mcpServerRegistry: IMCPServerRegistry;
+
   @Autowired(InlineChatFeatureRegistryToken)
   private readonly inlineChatFeatureRegistry: InlineChatFeatureRegistry;
 
@@ -205,6 +218,12 @@ export class AINativeBrowserContribution
   @Autowired(CodeActionSingleHandler)
   private readonly codeActionSingleHandler: CodeActionSingleHandler;
 
+  // @Autowired(MCPServerManagerPath)
+  // private readonly mcpServerManager: MCPServerManager;
+
+  @Autowired(SumiMCPServerProxyServicePath)
+  private readonly sumiMCPServerBackendProxy: ISumiMCPServerBackend;
+
   constructor() {
     this.registerFeature();
   }
@@ -289,6 +308,8 @@ export class AINativeBrowserContribution
       if (supportsInlineChat) {
         this.codeActionSingleHandler.load();
       }
+
+      this.sumiMCPServerBackendProxy.initBuiltinMCPServer();
     });
   }
 
@@ -303,6 +324,11 @@ export class AINativeBrowserContribution
       contribution.registerIntelligentCompletionFeature?.(this.intelligentCompletionsRegistry);
       contribution.registerProblemFixFeature?.(this.problemFixProviderRegistry);
     });
+
+    // 注册 Opensumi 框架提供的 MCP Server Tools 能力 (此时的 Opensumi 作为 MCP Server)
+    this.mcpServerContributions.getContributions().forEach((contribution) => {
+      contribution.registerMCPServer(this.mcpServerRegistry);
+    });
   }
 
   registerSetting(registry: ISettingRegistry) {
@@ -367,6 +393,21 @@ export class AINativeBrowserContribution
           },
         ],
       });
+
+      // Register language model API key settings
+      registry.registerSettingSection(AI_NATIVE_SETTING_GROUP_ID, {
+        title: localize('preference.ai.native.apiKeys.title'),
+        preferences: [
+          {
+            id: AINativeSettingSectionsId.DeepseekApiKey,
+            localized: 'preference.ai.native.deepseek.apiKey',
+          },
+          {
+            id: AINativeSettingSectionsId.AnthropicApiKey,
+            localized: 'preference.ai.native.anthropic.apiKey',
+          },
+        ],
+      });
     }
 
     if (this.aiNativeConfigService.capabilities.supportsInlineChat) {
@@ -407,6 +448,27 @@ export class AINativeBrowserContribution
   }
 
   registerCommands(commands: CommandRegistry): void {
+    commands.registerCommand(
+      { id: 'ai.native.mcp.start', label: 'MCP: Start MCP Server' },
+      {
+        execute: async () => {
+
+          // TODO 支持第三方 MCP Server
+          const description: MCPServerDescription = {
+            name: 'filesystem',
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-filesystem', '/Users/retrox/AlipayProjects/core'],
+            env: {},
+          };
+
+          // this.mcpServerManager.addOrUpdateServer(description);
+
+          // await this.mcpServerManager.startServer(description.name);
+          // await this.mcpServerManager.collectTools(description.name);
+        },
+      },
+    );
+
     commands.registerCommand(AI_INLINE_CHAT_VISIBLE, {
       execute: (value: boolean) => {
         this.aiInlineChatService._onInlineChatVisible.fire(value);