@opensumi/ide-ai-native 3.7.2-next-1740450374.0 → 3.7.2-next-1741226843.0

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

@@ -1,200 +0,0 @@
-// 想要通过 MCP 的方式暴露 Opensumi 的 IDE 能力，就需要 Node.js 层打通 MCP 的通信
-// 因为大部分 MCP 功能的实现在前端，因此需要再这里做前后端通信
-
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-
-import { Autowired, Injectable } from '@opensumi/di';
-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 { IToolInvocationRegistryManager, ToolInvocationRegistryManager } from '../../common/tool-invocation-registry';
-import { IMCPServerProxyService, MCPTool } from '../../common/types';
-import { IMCPServer } from '../mcp-server';
-import { MCPServerManagerImpl } from '../mcp-server-manager-impl';
-
-// 每个 BrowserTab 都对应了一个 SumiMCPServerBackend 实例
-// SumiMCPServerBackend 需要做的事情：
-// 维护 Browser 端工具的注册和调用
-// 处理第三方 MCP Server 的注册和调用
-
-@Injectable({ multiple: true })
-export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> implements ISumiMCPServerBackend {
-  // 这里需要考虑不同的 BrowserTab 的区分问题，目前的 POC 所有的 Tab 都会注册到 tools 中
-  // 后续需要区分不同的 Tab 对应的实例
-  private readonly mcpServerManager: MCPServerManagerImpl;
-
-  @Autowired(ToolInvocationRegistryManager)
-  private readonly toolInvocationRegistryManager: IToolInvocationRegistryManager;
-
-  @Autowired(INodeLogger)
-  private readonly logger: ILogger;
-
-  private server: Server | undefined;
-
-  // 对应 BrowserTab 的 clientId
-  private clientId: string = '';
-
-  constructor() {
-    super();
-    this.mcpServerManager = new MCPServerManagerImpl(this.toolInvocationRegistryManager, this.logger);
-  }
-
-  public setConnectionClientId(clientId: string) {
-    this.clientId = clientId;
-    this.mcpServerManager.setClientId(clientId);
-  }
-
-  async getMCPTools() {
-    if (!this.client) {
-      throw new Error('SUMI MCP RPC Client not initialized');
-    }
-    // 获取 MCP 工具
-    const tools = await this.client.$getMCPTools();
-    this.logger.log('[Node backend] SUMI MCP tools', tools);
-    return tools;
-  }
-
-  async callMCPTool(name: string, args: any) {
-    if (!this.client) {
-      throw new Error('SUMI MCP RPC Client not initialized');
-    }
-    return await this.client.$callMCPTool(name, args);
-  }
-
-  getServer() {
-    return this.server;
-  }
-
-  // TODO 这里涉及到 Chat Stream Call 中带上 ClientID，具体方案需要进一步讨论
-  async getAllMCPTools(): Promise<MCPTool[]> {
-    const registry = this.toolInvocationRegistryManager.getRegistry(this.clientId);
-    return registry.getAllFunctions().map((tool) => ({
-      name: tool.name || 'no-name',
-      description: tool.description || 'no-description',
-      inputSchema: tool.parameters,
-      providerName: tool.providerName || 'no-provider-name',
-    }));
-  }
-
-  public async initBuiltinMCPServer() {
-    const builtinMCPServer = new BuiltinMCPServer(this, this.logger);
-    this.mcpServerManager.setClientId(this.clientId);
-    await this.mcpServerManager.initBuiltinServer(builtinMCPServer);
-    this.client?.$updateMCPServers();
-  }
-
-  public async initExternalMCPServers(servers: MCPServerDescription[]) {
-    this.mcpServerManager.setClientId(this.clientId);
-    await this.mcpServerManager.addExternalMCPServers(servers);
-    this.client?.$updateMCPServers();
-  }
-
-  async initExposedMCPServer() {
-    // 初始化 MCP Server
-    this.server = new Server(
-      {
-        name: 'sumi-ide-mcp-server',
-        version: '0.2.0',
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
-
-    // 设置工具列表请求处理器
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      const tools = await this.getMCPTools();
-      return { tools };
-    });
-
-    // 设置工具调用请求处理器
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      try {
-        const { name, arguments: args } = request.params;
-        return await this.callMCPTool(name, args);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: 'text', text: `Error: ${errorMessage}` }],
-          isError: true,
-        };
-      }
-    });
-
-    return this.server;
-  }
-}
-
-export const TokenBuiltinMCPServer = Symbol('TokenBuiltinMCPServer');
-
-export class BuiltinMCPServer implements IMCPServer {
-  private started: boolean = true;
-
-  constructor(private readonly sumiMCPServer: SumiMCPServerBackend, private readonly logger: ILogger) {}
-
-  isStarted(): boolean {
-    return this.started;
-  }
-
-  getServerName(): string {
-    return 'sumi-builtin';
-  }
-
-  async start(): Promise<void> {
-    if (this.started) {
-      return;
-    }
-    // TODO 考虑 MCP Server 的对外暴露
-    // await this.sumiMCPServer.initMCPServer();
-    this.started = true;
-  }
-
-  async callTool(toolName: string, toolCallId: string, arg_string: string): Promise<any> {
-    if (!this.started) {
-      throw new Error('MCP Server not started');
-    }
-    let args;
-    try {
-      args = JSON.parse(arg_string);
-    } catch (error) {
-      this.logger.error(
-        `Failed to parse arguments for calling tool "${toolName}" in Builtin MCP server.
-        Invalid JSON: ${arg_string}`,
-        error,
-      );
-      throw error;
-    }
-    return this.sumiMCPServer.callMCPTool(toolName, {
-      ...args,
-      toolCallId,
-    });
-  }
-
-  async getTools(): ReturnType<Client['listTools']> {
-    if (!this.started) {
-      throw new Error('MCP Server not started');
-    }
-    const tools = await this.sumiMCPServer.getMCPTools();
-    this.logger.debug('[BuiltinMCPServer] getTools', tools);
-    return { tools } as any;
-  }
-
-  update(_command: string, _args?: string[], _env?: { [key: string]: string }): void {
-    // No-op for builtin server as it doesn't need command/args/env updates
-  }
-
-  stop(): void {
-    if (!this.started) {
-      return;
-    }
-    // No explicit cleanup needed for in-memory server
-    this.started = false;
-  }
-}

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

@@ -1,156 +0,0 @@
-import { ToolExecutionOptions } from 'ai';
-
-import { ILogger } from '@opensumi/ide-core-common';
-
-import { 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';
-
-// 这应该是 Browser Tab 维度的，每个 Tab 对应一个 MCPServerManagerImpl
-export class MCPServerManagerImpl implements MCPServerManager {
-  protected servers: Map<string, IMCPServer> = new Map();
-
-  // 当前实例对应的 clientId
-  private clientId: string;
-
-  constructor(
-    private readonly toolInvocationRegistryManager: IToolInvocationRegistryManager,
-    private readonly logger: ILogger,
-  ) {}
-
-  setClientId(clientId: string) {
-    this.clientId = clientId;
-  }
-
-  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.`);
-  }
-
-  async getStartedServers(): Promise<string[]> {
-    const startedServers: string[] = [];
-    for (const [name, server] of this.servers.entries()) {
-      if (server.isStarted()) {
-        startedServers.push(name);
-      }
-    }
-    return startedServers;
-  }
-
-  callTool(
-    serverName: string,
-    toolName: string,
-    toolCallId: string,
-    arg_string: string,
-  ): ReturnType<IMCPServer['callTool']> {
-    const server = this.servers.get(serverName);
-    if (!server) {
-      throw new Error(`MCP server "${toolName}" not found.`);
-    }
-    return server.callTool(toolName, toolCallId, arg_string);
-  }
-
-  async startServer(serverName: string): Promise<void> {
-    const server = this.servers.get(serverName);
-    if (!server) {
-      throw new Error(`MCP server "${serverName}" not found.`);
-    }
-    await server.start();
-  }
-
-  async getServerNames(): Promise<string[]> {
-    return Array.from(this.servers.keys());
-  }
-
-  private convertToToolRequest(tool: MCPTool, serverName: string): ToolRequest {
-    const id = getToolName(tool.name, serverName);
-
-    return {
-      id,
-      name: id,
-      providerName: serverName,
-      parameters: tool.inputSchema,
-      description: tool.description,
-      handler: async (arg_string: string, options?: ToolExecutionOptions) => {
-        try {
-          const res = await this.callTool(serverName, tool.name, options?.toolCallId || '', arg_string);
-          this.logger.debug(`[MCP: ${serverName}] ${tool.name} called with ${arg_string}`);
-          this.logger.debug('Tool execution result:', res);
-          return JSON.stringify(res);
-        } catch (error) {
-          this.logger.error(`Error in tool handler for ${tool.name} on MCP server ${serverName}:`, error);
-          throw error;
-        }
-      },
-    };
-  }
-
-  public async registerTools(serverName: string): Promise<void> {
-    const server = this.servers.get(serverName);
-    if (!server) {
-      throw new Error(`MCP server "${serverName}" not found.`);
-    }
-
-    const { tools } = await server.getTools();
-    const toolRequests: ToolRequest[] = tools.map((tool) => this.convertToToolRequest(tool, serverName));
-
-    const registry = this.toolInvocationRegistryManager.getRegistry(this.clientId);
-    for (const toolRequest of toolRequests) {
-      registry.registerTool(toolRequest);
-    }
-  }
-
-  public async getTools(serverName: string): ReturnType<IMCPServer['getTools']> {
-    const server = this.servers.get(serverName);
-    if (!server) {
-      throw new Error(`MCP server "${serverName}" not found.`);
-    }
-    return server.getTools();
-  }
-
-  addOrUpdateServer(description: MCPServerDescription): void {
-    const { name, command, args, env } = description;
-    const existingServer = this.servers.get(name);
-
-    if (existingServer) {
-      existingServer.update(command, args, env);
-    } else {
-      const newServer = new MCPServerImpl(name, command, args, env, this.logger);
-      this.servers.set(name, newServer);
-    }
-  }
-
-  addOrUpdateServerDirectly(server: IMCPServer): void {
-    this.servers.set(server.getServerName(), server);
-  }
-
-  async initBuiltinServer(builtinMCPServer: BuiltinMCPServer): Promise<void> {
-    this.addOrUpdateServerDirectly(builtinMCPServer);
-    await this.registerTools(builtinMCPServer.getServerName());
-  }
-
-  async addExternalMCPServers(servers: MCPServerDescription[]): Promise<void> {
-    for (const server of servers) {
-      this.addOrUpdateServer(server);
-      await this.startServer(server.name);
-      await this.registerTools(server.name);
-    }
-  }
-
-  removeServer(name: string): void {
-    const server = this.servers.get(name);
-    if (server) {
-      server.stop();
-      this.servers.delete(name);
-    } else {
-      this.logger.warn(`MCP server "${name}" not found.`);
-    }
-  }
-}

package/src/node/mcp-server.ts

@@ -1,127 +0,0 @@
-// have to import with extension since the exports map is ./* -> ./dist/cjs/*
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-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;
-}
-
-export class MCPServerImpl implements IMCPServer {
-  private name: string;
-  private command: string;
-  private args?: string[];
-  private client: Client;
-  private env?: { [key: string]: string };
-  private started: boolean = false;
-
-  constructor(
-    name: string,
-    command: string,
-    args?: string[],
-    env?: Record<string, string>,
-    private readonly logger?: ILogger,
-  ) {
-    this.name = name;
-    this.command = command;
-    this.args = args;
-    this.env = env;
-  }
-
-  isStarted(): boolean {
-    return this.started;
-  }
-
-  getServerName(): string {
-    return this.name;
-  }
-
-  async start(): Promise<void> {
-    if (this.started) {
-      return;
-    }
-    this.logger?.log(
-      `Starting server "${this.name}" with command: ${this.command} and args: ${this.args?.join(
-        ' ',
-      )} and env: ${JSON.stringify(this.env)}`,
-    );
-    // Filter process.env to exclude undefined values
-    const sanitizedEnv: Record<string, string> = Object.fromEntries(
-      Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
-    );
-
-    const mergedEnv: Record<string, string> = {
-      ...sanitizedEnv,
-      ...(this.env || {}),
-    };
-    const transport = new StdioClientTransport({
-      command: this.command,
-      args: this.args,
-      env: mergedEnv,
-    });
-    transport.onerror = (error) => {
-      this.logger?.error('Transport Error:', error);
-    };
-
-    this.client = new Client(
-      {
-        name: 'opensumi-mcp-client',
-        version: '1.0.0',
-      },
-      {
-        capabilities: {},
-      },
-    );
-    this.client.onerror = (error) => {
-      this.logger?.error('Error in MCP client:', error);
-    };
-
-    await this.client.connect(transport);
-    this.started = true;
-  }
-
-  async callTool(toolName: string, toolCallId: string, arg_string: string) {
-    let args;
-    try {
-      args = JSON.parse(arg_string);
-    } catch (error) {
-      this.logger?.error(
-        `Failed to parse arguments for calling tool "${toolName}" in MCP server "${this.name}" with command "${this.command}".
-                Invalid JSON: ${arg_string}`,
-        error,
-      );
-    }
-    const params = {
-      name: toolName,
-      arguments: args,
-      toolCallId,
-    };
-    return this.client.callTool(params);
-  }
-
-  async getTools() {
-    return await this.client.listTools();
-  }
-
-  update(command: string, args?: string[], env?: { [key: string]: string }): void {
-    this.command = command;
-    this.args = args;
-    this.env = env;
-  }
-
-  stop(): void {
-    if (!this.started || !this.client) {
-      return;
-    }
-    this.logger?.log(`Stopping MCP server "${this.name}"`);
-    this.client.close();
-    this.started = false;
-  }
-}

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

@@ -1,25 +0,0 @@
-import { OpenAIProvider, createOpenAI } from '@ai-sdk/openai';
-
-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 {
-    const apiKey = options.apiKey;
-    if (!apiKey) {
-      throw new Error(`Please provide OpenAI API Key in preferences (${AINativeSettingSectionsId.OpenaiApiKey})`);
-    }
-    return createOpenAI({
-      apiKey,
-      baseURL: options.baseURL || 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-    });
-  }
-
-  protected getModelIdentifier(provider: OpenAIProvider, modelId?: string) {
-    return provider(modelId || 'qwen-max');
-  }
-}