@opensumi/ide-ai-native 3.8.1-next-1740452912.0 → 3.8.1-next-1740463566.0

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

@@ -10,11 +10,11 @@ import { RPCService } from '@opensumi/ide-connection';
 import { ILogger } from '@opensumi/ide-core-common';
 import { INodeLogger } from '@opensumi/ide-core-node';
 
-import { ISumiMCPServerBackend } from '../../common';
-import { MCPServerDescription, MCPServerManager } from '../../common/mcp-server-manager';
+import { BUILTIN_MCP_SERVER_NAME, ISumiMCPServerBackend } from '../../common';
+import { IMCPServer, MCPServerDescription } from '../../common/mcp-server-manager';
 import { IToolInvocationRegistryManager, ToolInvocationRegistryManager } from '../../common/tool-invocation-registry';
 import { IMCPServerProxyService, MCPTool } from '../../common/types';
-import { IMCPServer } from '../mcp-server';
+import { StdioMCPServerImpl } from '../mcp-server';
 import { MCPServerManagerImpl } from '../mcp-server-manager-impl';
 
 // 每个 BrowserTab 都对应了一个 SumiMCPServerBackend 实例
@@ -55,7 +55,6 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
     }
     // 获取 MCP 工具
     const tools = await this.client.$getMCPTools();
-    this.logger.log('[Node backend] SUMI MCP tools', tools);
     return tools;
   }
 
@@ -81,10 +80,10 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
     }));
   }
 
-  public async initBuiltinMCPServer() {
+  public async initBuiltinMCPServer(enabled: boolean) {
     const builtinMCPServer = new BuiltinMCPServer(this, this.logger);
     this.mcpServerManager.setClientId(this.clientId);
-    await this.mcpServerManager.initBuiltinServer(builtinMCPServer);
+    await this.mcpServerManager.initBuiltinServer(builtinMCPServer, enabled);
     this.client?.$updateMCPServers();
   }
 
@@ -130,12 +129,72 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
 
     return this.server;
   }
+
+  async getServers() {
+    const servers = Array.from(this.mcpServerManager.getServers().entries());
+    const serverInfos = await Promise.all(
+      servers.map(async ([serverName, server]) => {
+        let toolNames: string[] = [];
+        if (server.isStarted()) {
+          // 只获取正在运行的 MCP Server 的工具列表
+          const toolsResponse = await server.getTools();
+          toolNames = toolsResponse.tools.map((tool) => tool.name);
+        }
+
+        // OpenSumi 内置的 MCP Server
+        if (serverName === BUILTIN_MCP_SERVER_NAME) {
+          return {
+            name: server.getServerName(),
+            isStarted: server.isStarted(),
+            type: 'builtin rpc',
+            tools: toolNames,
+          };
+        }
+
+        // 第三方 Stdio 类型的 MCP Server
+        if (server instanceof StdioMCPServerImpl) {
+          return {
+            name: server.getServerName(),
+            isStarted: server.isStarted(),
+            type: 'stdio',
+            command: server.command + ' ' + (server.args?.join(' ') || ''),
+            tools: toolNames,
+          };
+        }
+
+        // TODO SSE 类型的 MCP Server
+
+        return {
+          name: server.getServerName(),
+          isStarted: server.isStarted(),
+          type: '[MOCK] stdio',
+          command: '[MOCK] npx sumi-ide-mcp-server',
+          tools: toolNames,
+        };
+      }),
+    );
+
+    // 将 builtin server 放在第一位
+    const builtinServer = serverInfos.find((server) => server.name === BUILTIN_MCP_SERVER_NAME);
+    const otherServers = serverInfos.filter((server) => server.name !== BUILTIN_MCP_SERVER_NAME);
+    return builtinServer ? [builtinServer, ...otherServers] : otherServers;
+  }
+
+  async startServer(serverName: string) {
+    await this.mcpServerManager.startServer(serverName);
+    this.client?.$updateMCPServers();
+  }
+
+  async stopServer(serverName: string) {
+    await this.mcpServerManager.stopServer(serverName);
+    this.client?.$updateMCPServers();
+  }
 }
 
 export const TokenBuiltinMCPServer = Symbol('TokenBuiltinMCPServer');
 
 export class BuiltinMCPServer implements IMCPServer {
-  private started: boolean = true;
+  private started: boolean = false;
 
   constructor(private readonly sumiMCPServer: SumiMCPServerBackend, private readonly logger: ILogger) {}
 
@@ -144,7 +203,7 @@ export class BuiltinMCPServer implements IMCPServer {
   }
 
   getServerName(): string {
-    return 'sumi-builtin';
+    return BUILTIN_MCP_SERVER_NAME;
   }
 
   async start(): Promise<void> {
@@ -182,7 +241,6 @@ export class BuiltinMCPServer implements IMCPServer {
       throw new Error('MCP Server not started');
     }
     const tools = await this.sumiMCPServer.getMCPTools();
-    this.logger.debug('[BuiltinMCPServer] getTools', tools);
     return { tools } as any;
   }
 

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

@@ -2,13 +2,12 @@ import { ToolExecutionOptions } from 'ai';
 
 import { ILogger } from '@opensumi/ide-core-common';
 
-import { MCPServerDescription, MCPServerManager, MCPTool } from '../common/mcp-server-manager';
+import { IMCPServer, MCPServerDescription, MCPServerManager, MCPTool } from '../common/mcp-server-manager';
 import { IToolInvocationRegistryManager, ToolRequest } from '../common/tool-invocation-registry';
 import { getToolName } from '../common/utils';
 
 import { BuiltinMCPServer } from './mcp/sumi-mcp-server';
-import { IMCPServer, MCPServerImpl } from './mcp-server';
-
+import { StdioMCPServerImpl } from './mcp-server';
 // 这应该是 Browser Tab 维度的，每个 Tab 对应一个 MCPServerManagerImpl
 export class MCPServerManagerImpl implements MCPServerManager {
   protected servers: Map<string, IMCPServer> = new Map();
@@ -16,6 +15,10 @@ export class MCPServerManagerImpl implements MCPServerManager {
   // 当前实例对应的 clientId
   private clientId: string;
 
+  getServers(): Map<string, IMCPServer> {
+    return this.servers;
+  }
+
   constructor(
     private readonly toolInvocationRegistryManager: IToolInvocationRegistryManager,
     private readonly logger: ILogger,
@@ -25,13 +28,20 @@ export class MCPServerManagerImpl implements MCPServerManager {
     this.clientId = clientId;
   }
 
+  private unregisterServerTools(serverName: string) {
+    const registry = this.toolInvocationRegistryManager.getRegistry(this.clientId);
+    registry.unregisterProviderTools(serverName);
+  }
+
   async stopServer(serverName: string): Promise<void> {
     const server = this.servers.get(serverName);
     if (!server) {
       throw new Error(`MCP server "${serverName}" not found.`);
     }
-    server.stop();
-    this.logger.log(`MCP server "${serverName}" stopped.`);
+    await server.stop();
+    // 停止服务器后，需要从注册表中移除该服务器的所有工具
+    this.unregisterServerTools(serverName);
+    this.logger.log(`MCP server "${serverName}" stopped and tools unregistered.`);
   }
 
   async getStartedServers(): Promise<string[]> {
@@ -63,6 +73,7 @@ export class MCPServerManagerImpl implements MCPServerManager {
       throw new Error(`MCP server "${serverName}" not found.`);
     }
     await server.start();
+    await this.registerTools(serverName);
   }
 
   async getServerNames(): Promise<string[]> {
@@ -122,7 +133,7 @@ export class MCPServerManagerImpl implements MCPServerManager {
     if (existingServer) {
       existingServer.update(command, args, env);
     } else {
-      const newServer = new MCPServerImpl(name, command, args, env, this.logger);
+      const newServer = new StdioMCPServerImpl(name, command, args, env, this.logger);
       this.servers.set(name, newServer);
     }
   }
@@ -131,16 +142,23 @@ export class MCPServerManagerImpl implements MCPServerManager {
     this.servers.set(server.getServerName(), server);
   }
 
-  async initBuiltinServer(builtinMCPServer: BuiltinMCPServer): Promise<void> {
+  // enabled 为 true 时，会自动启动内置服务器, 并注册工具
+  async initBuiltinServer(builtinMCPServer: BuiltinMCPServer, enabled: boolean = true): Promise<void> {
     this.addOrUpdateServerDirectly(builtinMCPServer);
-    await this.registerTools(builtinMCPServer.getServerName());
+    if (enabled) {
+      await builtinMCPServer.start();
+      await this.registerTools(builtinMCPServer.getServerName());
+    }
   }
 
   async addExternalMCPServers(servers: MCPServerDescription[]): Promise<void> {
     for (const server of servers) {
       this.addOrUpdateServer(server);
+      if (!server.enabled) {
+        // 如果是 enabled 为 false 的 server，则不进行启动
+        continue;
+      }
       await this.startServer(server.name);
-      await this.registerTools(server.name);
     }
   }
 
@@ -148,7 +166,10 @@ export class MCPServerManagerImpl implements MCPServerManager {
     const server = this.servers.get(name);
     if (server) {
       server.stop();
+      // 移除服务器时，也需要从注册表中移除该服务器的所有工具
+      this.unregisterServerTools(name);
       this.servers.delete(name);
+      this.logger.log(`MCP server "${name}" removed and tools unregistered.`);
     } else {
       this.logger.warn(`MCP server "${name}" not found.`);
     }

package/src/node/mcp-server.ts

@@ -4,20 +4,12 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 
 import { ILogger } from '@opensumi/ide-core-common';
 
-export interface IMCPServer {
-  isStarted(): boolean;
-  start(): Promise<void>;
-  getServerName(): string;
-  callTool(toolName: string, toolCallId: string, arg_string: string): ReturnType<Client['callTool']>;
-  getTools(): ReturnType<Client['listTools']>;
-  update(command: string, args?: string[], env?: { [key: string]: string }): void;
-  stop(): void;
-}
+import { IMCPServer } from '../common/mcp-server-manager';
 
-export class MCPServerImpl implements IMCPServer {
+export class StdioMCPServerImpl implements IMCPServer {
   private name: string;
-  private command: string;
-  private args?: string[];
+  public command: string;
+  public args?: string[];
   private client: Client;
   private env?: { [key: string]: string };
   private started: boolean = false;
@@ -116,12 +108,17 @@ export class MCPServerImpl implements IMCPServer {
     this.env = env;
   }
 
-  stop(): void {
+  async stop(): Promise<void> {
     if (!this.started || !this.client) {
       return;
     }
     this.logger?.log(`Stopping MCP server "${this.name}"`);
-    this.client.close();
+    try {
+      await this.client.close();
+    } catch (error) {
+      this.logger?.error(`Failed to stop MCP server "${this.name}":`, error);
+    }
+    this.logger?.log(`MCP server "${this.name}" stopped`);
     this.started = false;
   }
 }

package/src/node/openai/openai-language-model.ts

@@ -1,25 +1,28 @@
-import { OpenAIProvider, createOpenAI } from '@ai-sdk/openai';
+import { OpenAICompatibleProvider, createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { LanguageModelV1 } from 'ai';
 
 import { Injectable } from '@opensumi/di';
 import { AINativeSettingSectionsId, IAIBackServiceOption } from '@opensumi/ide-core-common';
 
 import { BaseLanguageModel } from '../base-language-model';
+
 export const DeepSeekModelIdentifier = Symbol('DeepSeekModelIdentifier');
 
 @Injectable()
 export class OpenAIModel extends BaseLanguageModel {
-  protected initializeProvider(options: IAIBackServiceOption): OpenAIProvider {
+  protected initializeProvider(options: IAIBackServiceOption): OpenAICompatibleProvider {
     const apiKey = options.apiKey;
     if (!apiKey) {
       throw new Error(`Please provide OpenAI API Key in preferences (${AINativeSettingSectionsId.OpenaiApiKey})`);
     }
-    return createOpenAI({
+    return createOpenAICompatible({
       apiKey,
       baseURL: options.baseURL || 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+      name: 'openai',
     });
   }
 
-  protected getModelIdentifier(provider: OpenAIProvider, modelId?: string) {
+  protected getModelIdentifier(provider: OpenAICompatibleProvider, modelId?: string): LanguageModelV1 {
     return provider(modelId || 'qwen-max');
   }
 }