@opensumi/ide-ai-native 3.7.1-next-1737628160.0 → 3.7.1-next-1737703128.0

package/src/browser/mcp/tools/getOpenEditorFileDiagnostics.ts

@@ -0,0 +1,121 @@
+import * as path from 'path';
+
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain, URI } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+import { URI as MonacoURI } from '@opensumi/monaco-editor-core/esm/vs/base/common/uri';
+import { IMarkerService, MarkerSeverity } from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetOpenEditorFileDiagnosticsTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IMarkerService)
+  private readonly markerService: IMarkerService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_open_in_editor_file_diagnostics',
+      description:
+        'Retrieves diagnostic information (errors, warnings, etc.) from the currently active file in VS Code editor. ' +
+        'Use this tool to get information about problems in your current file. ' +
+        'IMPORTANT: This tool should be called after any code generation or modification operations to verify and fix potential issues. ' +
+        'Returns a JSON-formatted list of diagnostics, where each entry contains: ' +
+        '- path: The file path where the diagnostic was found ' +
+        '- line: The line number (1-based) of the diagnostic ' +
+        '- severity: The severity level ("error", "warning", "information", or "hint") ' +
+        '- message: The diagnostic message ' +
+        'Returns an empty list ([]) if no diagnostics are found or no file is open. ' +
+        'Best Practice: Always check diagnostics after code generation to ensure code quality and fix any issues immediately. ' +
+        'Diagnostic Severity Handling Guidelines: ' +
+        '- "error": Must be fixed immediately as they indicate critical issues that will prevent code from working correctly. ' +
+        '- "warning": For user code, preserve unless the warning indicates a clear improvement opportunity. For generated code, optimize to remove warnings. ' +
+        '- "information"/"hint": For user code, preserve as they might reflect intentional patterns. For generated code, optimize if it improves code quality without changing functionality.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    try {
+      // 获取当前活动的编辑器
+      const editor = this.editorService.currentEditor;
+      if (!editor || !editor.currentUri) {
+        logger.appendLine('Error: No active text editor found');
+        return {
+          content: [{ type: 'text', text: '[]' }],
+          isError: true,
+        };
+      }
+
+      // 获取工作区根目录
+      const workspaceRoots = this.workspaceService.tryGetRoots();
+      if (!workspaceRoots || workspaceRoots.length === 0) {
+        logger.appendLine('Error: Cannot determine project directory');
+        return {
+          content: [{ type: 'text', text: '[]' }],
+          isError: true,
+        };
+      }
+
+      // 获取当前文件的诊断信息
+      const monacoUri = MonacoURI.parse(editor.currentUri.toString());
+      const markers = this.markerService.read({ resource: monacoUri });
+      const rootUri = URI.parse(workspaceRoots[0].uri);
+      const relativePath = path.relative(rootUri.codeUri.fsPath, editor.currentUri.codeUri.fsPath);
+
+      // 转换诊断信息
+      const diagnosticInfos = markers.map((marker) => ({
+        path: relativePath,
+        line: marker.startLineNumber,
+        severity: this.getSeverityString(marker.severity),
+        message: marker.message,
+      }));
+
+      // 将结果转换为 JSON 字符串
+      const resultJson = JSON.stringify(diagnosticInfos, null, 2);
+      logger.appendLine(`Found ${diagnosticInfos.length} diagnostics in current file`);
+
+      return {
+        content: [{ type: 'text', text: resultJson }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error getting diagnostics: ${error}`);
+      return {
+        content: [{ type: 'text', text: '[]' }],
+        isError: true,
+      };
+    }
+  }
+
+  private getSeverityString(severity: MarkerSeverity): string {
+    switch (severity) {
+      case MarkerSeverity.Error:
+        return 'error';
+      case MarkerSeverity.Warning:
+        return 'warning';
+      case MarkerSeverity.Info:
+        return 'information';
+      case MarkerSeverity.Hint:
+        return 'hint';
+      default:
+        return 'unknown';
+    }
+  }
+}

package/src/browser/mcp/tools/getOpenEditorFileText.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetOpenEditorFileTextTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_open_in_editor_file_text',
+      description:
+        'Retrieves the complete text content of the currently active file in the IDE editor. ' +
+        "Use this tool to access and analyze the file's contents for tasks such as code review, content inspection, or text processing. " +
+        'Returns empty string if no file is currently open.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    const editor = this.editorService.currentEditor;
+    if (!editor || !editor.currentDocumentModel) {
+      logger.appendLine('Error: No active text editor found');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const document = editor.currentDocumentModel;
+    logger.appendLine(`Reading content from: ${document.uri.toString()}`);
+    const content = document.getText();
+
+    return {
+      content: [{ type: 'text', text: content }],
+    };
+  }
+}

package/src/browser/mcp/tools/getSelectedText.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetSelectedTextTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_selected_in_editor_text',
+      description:
+        'Retrieves the currently selected text from the active editor in VS Code. ' +
+        'Use this tool when you need to access and analyze text that has been highlighted/selected by the user. ' +
+        'Returns an empty string if no text is selected or no editor is open.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    const editor = this.editorService.currentEditor;
+    if (!editor || !editor.monacoEditor) {
+      logger.appendLine('Error: No active text editor found');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const selection = editor.monacoEditor.getSelection();
+    if (!selection) {
+      logger.appendLine('No text is currently selected');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const selectedText = editor.monacoEditor.getModel()?.getValueInRange(selection) || '';
+    logger.appendLine(`Retrieved selected text of length: ${selectedText.length}`);
+
+    return {
+      content: [{ type: 'text', text: selectedText }],
+    };
+  }
+}

package/src/browser/preferences/schema.ts

@@ -58,9 +58,5 @@ export const aiNativePreferenceSchema: PreferenceSchema = {
       type: 'boolean',
       default: false,
     },
-    [AINativeSettingSectionsId.CodeEditsTyping]: {
-      type: 'boolean',
-      default: false,
-    },
   },
 };

package/src/browser/types.ts

@@ -292,6 +292,45 @@ export interface AINativeCoreContribution {
   registerIntelligentCompletionFeature?(registry: IIntelligentCompletionsRegistry): void;
 }
 
+// MCP Server 的 贡献点
+export const MCPServerContribution = Symbol('MCPServerContribution');
+
+export const TokenMCPServerRegistry = Symbol('TokenMCPServerRegistry');
+
+export interface MCPServerContribution {
+  registerMCPServer(registry: IMCPServerRegistry): void;
+}
+
+export interface MCPLogger {
+  appendLine(message: string): void;
+}
+
+export interface MCPToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: any; // JSON Schema
+  handler: (
+    args: any,
+    logger: MCPLogger,
+  ) => Promise<{
+    content: { type: string; text: string }[];
+    isError?: boolean;
+  }>;
+}
+
+export interface IMCPServerRegistry {
+  registerMCPTool(tool: MCPToolDefinition): void;
+  getMCPTools(): MCPToolDefinition[];
+  callMCPTool(
+    name: string,
+    args: any,
+  ): Promise<{
+    content: { type: string; text: string }[];
+    isError?: boolean;
+  }>;
+  // 后续支持其他 MCP 功能
+}
+
 export interface IChatComponentConfig {
   id: string;
   component: React.ComponentType<Record<string, unknown>>;

package/src/common/index.ts

@@ -116,6 +116,15 @@ export const IChatAgentService = Symbol('IChatAgentService');
 
 export const ChatProxyServiceToken = Symbol('ChatProxyServiceToken');
 
+// 暴露给 Node.js 层，使其可以感知 Opensumi 注册的 MCP 能力
+export const TokenMCPServerProxyService = Symbol('TokenMCPServerProxyService');
+
+export interface ISumiMCPServerBackend {
+  initBuiltinMCPServer(): void;
+}
+
+export const SumiMCPServerProxyServicePath = 'SumiMCPServerProxyServicePath';
+
 export interface IChatAgentService {
   readonly onDidChangeAgents: Event<void>;
   readonly onDidSendMessage: Event<IChatProgress>;

package/src/common/mcp-server-manager.ts

@@ -0,0 +1,45 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+export interface MCPServerManager {
+    callTool(serverName: string, toolName: string, arg_string: string): ReturnType<Client['callTool']>;
+    removeServer(name: string): void;
+    addOrUpdateServer(description: MCPServerDescription): void;
+    // invoke in node.js only
+    addOrUpdateServerDirectly(server: any): void;
+    initBuiltinServer(builtinMCPServer: any): void;
+    getTools(serverName: string): ReturnType<Client['listTools']>;
+    getServerNames(): Promise<string[]>;
+    startServer(serverName: string): Promise<void>;
+    stopServer(serverName: string): Promise<void>;
+    getStartedServers(): Promise<string[]>;
+    collectTools(serverName: string): Promise<void>;
+}
+
+export type MCPTool = Awaited<ReturnType<MCPServerManager['getTools']>>['tools'][number];
+
+export type MCPToolParameter = Awaited<ReturnType<MCPServerManager['getTools']>>['tools'][number]['inputSchema'];
+
+export interface MCPServerDescription {
+  /**
+   * The unique name of the MCP server.
+   */
+  name: string;
+
+  /**
+   * The command to execute the MCP server.
+   */
+  command: string;
+
+  /**
+   * An array of arguments to pass to the command.
+   */
+  args?: string[];
+
+  /**
+   * Optional environment variables to set when starting the server.
+   */
+  env?: { [key: string]: string };
+}
+
+export const MCPServerManager = Symbol('MCPServerManager');
+export const MCPServerManagerPath = 'ServicesMCPServerManager';

package/src/common/tool-invocation-registry.ts

@@ -0,0 +1,124 @@
+import { Injectable } from '@opensumi/di';
+import { z } from 'zod';
+import { MCPToolParameter } from './mcp-server-manager';
+
+export const ToolParameterSchema = z.object({
+    type: z.enum(['string', 'number', 'boolean', 'object', 'array']),
+    description: z.string().optional(),
+    enum: z.array(z.any()).optional(),
+    items: z.lazy(() => ToolParameterSchema).optional(),
+    properties: z.record(z.lazy(() => ToolParameterSchema)).optional(),
+    required: z.array(z.string()).optional(),
+});
+
+export type ToolParameter = z.infer<typeof ToolParameterSchema>;
+
+export interface ToolRequest {
+    id: string;
+    name: string;
+    parameters?: any;
+    description?: string;
+    handler: (arg_string: string) => Promise<any>;
+    providerName?: string;
+}
+
+export namespace ToolRequest {
+    export function isToolParameter(obj: unknown): obj is ToolParameter {
+        return ToolParameterSchema.safeParse(obj).success;
+    }
+}
+
+export const ToolInvocationRegistry = Symbol('ToolInvocationRegistry');
+
+/**
+ * Registry for all the function calls available to Agents.
+ */
+export interface ToolInvocationRegistry {
+    /**
+     * Registers a tool into the registry.
+     *
+     * @param tool - The `ToolRequest` object representing the tool to be registered.
+     */
+    registerTool(tool: ToolRequest): void;
+
+    /**
+     * Retrieves a specific `ToolRequest` from the registry.
+     *
+     * @param toolId - The unique identifier of the tool to retrieve.
+     * @returns The `ToolRequest` object corresponding to the provided tool ID,
+     *          or `undefined` if the tool is not found in the registry.
+     */
+    getFunction(toolId: string): ToolRequest | undefined;
+
+    /**
+     * Retrieves multiple `ToolRequest`s from the registry.
+     *
+     * @param toolIds - A list of tool IDs to retrieve.
+     * @returns An array of `ToolRequest` objects for the specified tool IDs.
+     *          If a tool ID is not found, it is skipped in the returned array.
+     */
+    getFunctions(...toolIds: string[]): ToolRequest[];
+
+    /**
+     * Retrieves all `ToolRequest`s currently registered in the registry.
+     *
+     * @returns An array of all `ToolRequest` objects in the registry.
+     */
+    getAllFunctions(): ToolRequest[];
+
+    /**
+     * Unregisters all tools provided by a specific tool provider.
+     *
+     * @param providerName - The name of the tool provider whose tools should be removed (as specificed in the `ToolRequest`).
+     */
+    unregisterAllTools(providerName: string): void;
+}
+
+export const ToolProvider = Symbol('ToolProvider');
+export interface ToolProvider {
+    getTool(): ToolRequest;
+}
+
+@Injectable()
+export class ToolInvocationRegistryImpl implements ToolInvocationRegistry {
+
+    private tools: Map<string, ToolRequest> = new Map<string, ToolRequest>();
+
+    unregisterAllTools(providerName: string): void {
+        const toolsToRemove: string[] = [];
+        for (const [id, tool] of this.tools.entries()) {
+            if (tool.providerName === providerName) {
+                toolsToRemove.push(id);
+            }
+        }
+        toolsToRemove.forEach(id => this.tools.delete(id));
+    }
+    getAllFunctions(): ToolRequest[] {
+        return Array.from(this.tools.values());
+    }
+
+    registerTool(tool: ToolRequest): void {
+        if (this.tools.has(tool.id)) {
+            console.warn(`Function with id ${tool.id} is already registered.`);
+        } else {
+            this.tools.set(tool.id, tool);
+        }
+    }
+
+    getFunction(toolId: string): ToolRequest | undefined {
+        return this.tools.get(toolId);
+    }
+
+    getFunctions(...toolIds: string[]): ToolRequest[] {
+        const tools: ToolRequest[] = toolIds.map(toolId => {
+            const tool = this.tools.get(toolId);
+            if (tool) {
+                return tool;
+            } else {
+                throw new Error(`Function with id ${toolId} does not exist.`);
+            }
+        });
+        return tools;
+    }
+}
+

package/src/common/types.ts

@@ -18,3 +18,21 @@ export interface INearestCodeBlock {
   offset: number;
   type?: NearestCodeBlockType;
 }
+
+// SUMI MCP Server 网页部分暴露给 Node.js 部分的能力
+export interface IMCPServerProxyService {
+  $callMCPTool(
+    name: string,
+    args: any,
+  ): Promise<{
+    content: { type: string; text: string }[];
+    isError?: boolean;
+  }>;
+  $getMCPTools(): Promise<
+    {
+      name: string;
+      description: string;
+      inputSchema: any;
+    }[]
+  >;
+}

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

@@ -0,0 +1,96 @@
+import { AnthropicProvider, createAnthropic } from '@ai-sdk/anthropic';
+import { jsonSchema, streamText, tool } from 'ai';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { ChatReadableStream } from '@opensumi/ide-core-node';
+import { CancellationToken } from '@opensumi/ide-utils';
+
+import { ToolInvocationRegistry, ToolInvocationRegistryImpl, ToolRequest } from '../../common/tool-invocation-registry';
+
+
+export const AnthropicModelIdentifier = Symbol('AnthropicModelIdentifier');
+
+const apiKey = '';
+
+@Injectable()
+export class AnthropicModel {
+  @Autowired(ToolInvocationRegistry)
+  private readonly toolInvocationRegistry: ToolInvocationRegistryImpl;
+
+  protected initializeAnthropicProvider() {
+    if (!apiKey) {
+      throw new Error('Please provide ANTHROPIC_API_KEY in preferences or via environment variable');
+    }
+
+    const anthropic = createAnthropic({ apiKey });
+
+    return anthropic;
+  }
+
+  async request(request: string, chatReadableStream: ChatReadableStream, cancellationToken?: CancellationToken): Promise<any> {
+    const anthropic = this.initializeAnthropicProvider();
+    const allFunctions = this.toolInvocationRegistry.getAllFunctions();
+    return this.handleStreamingRequest(anthropic, request, allFunctions, chatReadableStream, 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 async handleStreamingRequest(
+    anthropic: AnthropicProvider,
+    request: string,
+    tools: ToolRequest[],
+    chatReadableStream: ChatReadableStream,
+    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 stream = await streamText({
+        model: anthropic('claude-3-5-sonnet-20241022'),
+        maxTokens: 4096,
+        tools: aiTools,
+        messages: [{ role: 'user', content: request }],
+        abortSignal: abortController.signal,
+        maxSteps: 5,
+      });
+
+      for await (const chunk of stream.fullStream) {
+        console.log(chunk);
+        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) },
+          }});
+        }
+      }
+
+      chatReadableStream.end();
+    } catch (error) {
+      console.error('Error during streaming:', error);
+      chatReadableStream.emitError(error);
+    }
+
+    return chatReadableStream;
+  }
+
+}

package/src/node/index.ts

@@ -3,6 +3,14 @@ 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 { MCPServerManager } from '../common/mcp-server-manager';
+import { ToolInvocationRegistry, ToolInvocationRegistryImpl } from '../common/tool-invocation-registry';
+
+import { SumiMCPServerBackend } from './mcp/sumi-mcp-server';
+import { MCPServerManagerImpl } from './mcp-server-manager-impl';
+
+
 @Injectable()
 export class AINativeModule extends NodeModule {
   providers: Provider[] = [
@@ -10,6 +18,18 @@ export class AINativeModule extends NodeModule {
       token: AIBackSerivceToken,
       useClass: BaseAIBackService,
     },
+    {
+      token: MCPServerManager,
+      useClass: MCPServerManagerImpl,
+    },
+    {
+      token: ToolInvocationRegistry,
+      useClass: ToolInvocationRegistryImpl,
+    },
+    {
+      token: TokenMCPServerProxyService,
+      useClass: SumiMCPServerBackend,
+    },
   ];
 
   backServices = [
@@ -17,5 +37,9 @@ export class AINativeModule extends NodeModule {
       servicePath: AIBackSerivcePath,
       token: AIBackSerivceToken,
     },
+    {
+      servicePath: SumiMCPServerProxyServicePath,
+      token: TokenMCPServerProxyService,
+    },
   ];
 }