@opensumi/ide-ai-native 3.7.2-next-1739848467.0 → 3.7.2-next-1739945875.0

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

@@ -0,0 +1,163 @@
+import { CoreMessage, jsonSchema, streamText, tool } from 'ai';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { ChatMessageRole, IAIBackServiceOption, IChatMessage } from '@opensumi/ide-core-common';
+import { ChatReadableStream } from '@opensumi/ide-core-node';
+import { CancellationToken } from '@opensumi/ide-utils';
+
+import {
+  IToolInvocationRegistryManager,
+  ToolInvocationRegistryManager,
+  ToolRequest,
+} from '../common/tool-invocation-registry';
+
+@Injectable()
+export abstract class BaseLanguageModel {
+  @Autowired(ToolInvocationRegistryManager)
+  protected readonly toolInvocationRegistryManager: IToolInvocationRegistryManager;
+
+  protected abstract initializeProvider(options: IAIBackServiceOption): any;
+
+  private convertChatMessageRole(role: ChatMessageRole) {
+    switch (role) {
+      case ChatMessageRole.System:
+        return 'system';
+      case ChatMessageRole.User:
+        return 'user';
+      case ChatMessageRole.Assistant:
+        return 'assistant';
+      case ChatMessageRole.Function:
+        return 'tool';
+      default:
+        return 'user';
+    }
+  }
+
+  async request(
+    request: string,
+    chatReadableStream: ChatReadableStream,
+    options: IAIBackServiceOption,
+    cancellationToken?: CancellationToken,
+  ): Promise<any> {
+    const provider = this.initializeProvider(options);
+    const clientId = options.clientId;
+    if (!clientId) {
+      throw new Error('clientId is required');
+    }
+    const registry = this.toolInvocationRegistryManager.getRegistry(clientId);
+    const allFunctions = registry.getAllFunctions();
+    return this.handleStreamingRequest(
+      provider,
+      request,
+      allFunctions,
+      chatReadableStream,
+      options.history || [],
+      cancellationToken,
+    );
+  }
+
+  private convertToolRequestToAITool(toolRequest: ToolRequest) {
+    return tool({
+      description: toolRequest.description || '',
+      // TODO 这里应该是 z.object 而不是 JSON Schema
+      parameters: jsonSchema(toolRequest.parameters),
+      execute: async (args: any) => await toolRequest.handler(JSON.stringify(args)),
+    });
+  }
+
+  protected abstract getModelIdentifier(provider: any): any;
+
+  protected async handleStreamingRequest(
+    provider: any,
+    request: string,
+    tools: ToolRequest[],
+    chatReadableStream: ChatReadableStream,
+    history: IChatMessage[] = [],
+    cancellationToken?: CancellationToken,
+  ): Promise<any> {
+    try {
+      const aiTools = Object.fromEntries(tools.map((tool) => [tool.name, this.convertToolRequestToAITool(tool)]));
+
+      const abortController = new AbortController();
+      if (cancellationToken) {
+        cancellationToken.onCancellationRequested(() => {
+          abortController.abort();
+        });
+      }
+
+      const messages: CoreMessage[] = [
+        ...history.map((msg) => ({
+          role: this.convertChatMessageRole(msg.role) as any, // 这个 SDK 包里的类型不太好完全对应，
+          content: msg.content,
+        })),
+        { role: 'user', content: request },
+      ];
+
+      const stream = await streamText({
+        model: this.getModelIdentifier(provider),
+        maxTokens: 4096,
+        tools: aiTools,
+        messages,
+        abortSignal: abortController.signal,
+        experimental_toolCallStreaming: true,
+        maxSteps: 12,
+      });
+
+      for await (const chunk of stream.fullStream) {
+        if (chunk.type === 'text-delta') {
+          chatReadableStream.emitData({ kind: 'content', content: chunk.textDelta });
+        } else if (chunk.type === 'tool-call') {
+          chatReadableStream.emitData({
+            kind: 'toolCall',
+            content: {
+              id: chunk.toolCallId || Date.now().toString(),
+              type: 'function',
+              function: { name: chunk.toolName, arguments: JSON.stringify(chunk.args) },
+              state: 'complete',
+            },
+          });
+        } else if (chunk.type === 'tool-call-streaming-start') {
+          chatReadableStream.emitData({
+            kind: 'toolCall',
+            content: {
+              id: chunk.toolCallId,
+              type: 'function',
+              function: { name: chunk.toolName },
+              state: 'streaming-start',
+            },
+          });
+        } else if (chunk.type === 'tool-call-delta') {
+          chatReadableStream.emitData({
+            kind: 'toolCall',
+            content: {
+              id: chunk.toolCallId,
+              type: 'function',
+              function: { name: chunk.toolName, arguments: chunk.argsTextDelta },
+              state: 'streaming',
+            },
+          });
+        } else if (chunk.type === 'tool-result') {
+          chatReadableStream.emitData({
+            kind: 'toolCall',
+            content: {
+              id: chunk.toolCallId,
+              type: 'function',
+              function: { name: chunk.toolName, arguments: JSON.stringify(chunk.args) },
+              result: chunk.result,
+              state: 'result',
+            },
+          });
+        } else if (chunk.type === 'error') {
+          chatReadableStream.emitError(new Error(chunk.error as string));
+        }
+      }
+
+      chatReadableStream.end();
+    } catch (error) {
+      // Use a logger service in production instead of console
+      chatReadableStream.emitError(error);
+    }
+
+    return chatReadableStream;
+  }
+}

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

@@ -0,0 +1,25 @@
+import { DeepSeekProvider, createDeepSeek } from '@ai-sdk/deepseek';
+
+import { Injectable } from '@opensumi/di';
+import { IAIBackServiceOption } from '@opensumi/ide-core-common';
+import { AINativeSettingSectionsId } from '@opensumi/ide-core-common/lib/settings/ai-native';
+
+import { BaseLanguageModel } from '../base-language-model';
+
+export const DeepSeekModelIdentifier = Symbol('DeepSeekModelIdentifier');
+
+@Injectable()
+export class DeepSeekModel extends BaseLanguageModel {
+  protected initializeProvider(options: IAIBackServiceOption): DeepSeekProvider {
+    const apiKey = options.apiKey;
+    if (!apiKey) {
+      throw new Error(`Please provide Deepseek API Key in preferences (${AINativeSettingSectionsId.DeepseekApiKey})`);
+    }
+
+    return createDeepSeek({ apiKey });
+  }
+
+  protected getModelIdentifier(provider: DeepSeekProvider) {
+    return provider('deepseek-chat');
+  }
+}

package/src/node/index.ts

@@ -3,6 +3,11 @@ import { AIBackSerivcePath, AIBackSerivceToken } from '@opensumi/ide-core-common
 import { NodeModule } from '@opensumi/ide-core-node';
 import { BaseAIBackService } from '@opensumi/ide-core-node/lib/ai-native/base-back.service';
 
+import { SumiMCPServerProxyServicePath, TokenMCPServerProxyService } from '../common';
+import { ToolInvocationRegistryManager, ToolInvocationRegistryManagerImpl } from '../common/tool-invocation-registry';
+
+import { SumiMCPServerBackend } from './mcp/sumi-mcp-server';
+
 @Injectable()
 export class AINativeModule extends NodeModule {
   providers: Provider[] = [
@@ -10,6 +15,14 @@ export class AINativeModule extends NodeModule {
       token: AIBackSerivceToken,
       useClass: BaseAIBackService,
     },
+    {
+      token: ToolInvocationRegistryManager,
+      useClass: ToolInvocationRegistryManagerImpl,
+    },
+    {
+      token: TokenMCPServerProxyService,
+      useClass: SumiMCPServerBackend,
+    },
   ];
 
   backServices = [
@@ -17,5 +30,13 @@ export class AINativeModule extends NodeModule {
       servicePath: AIBackSerivcePath,
       token: AIBackSerivceToken,
     },
+    // {
+    //   servicePath: MCPServerManagerPath,
+    //   token: MCPServerManager,
+    // },
+    {
+      servicePath: SumiMCPServerProxyServicePath,
+      token: TokenMCPServerProxyService,
+    },
   ];
 }

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

@@ -0,0 +1,197 @@
+// 想要通过 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, 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);
+  }
+
+  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

@@ -0,0 +1,148 @@
+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 { 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, 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, 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 = `mcp_${serverName}_${tool.name}`;
+
+    return {
+      id,
+      name: id,
+      providerName: serverName,
+      parameters: tool.inputSchema,
+      description: tool.description,
+      handler: async (arg_string: string) => {
+        try {
+          const res = await this.callTool(serverName, tool.name, 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

@@ -0,0 +1,126 @@
+// 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, 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, 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,
+    };
+    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;
+  }
+}