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

package/src/browser/types.ts

@@ -13,11 +13,20 @@ import {
   MaybePromise,
   MergeConflictEditorMode,
 } from '@opensumi/ide-core-common';
-import { ICodeEditor, IRange, ISelection, ITextModel, NewSymbolNamesProvider, Position } from '@opensumi/ide-monaco';
+import {
+  ICodeEditor,
+  IRange,
+  ISelection,
+  ITextModel,
+  InlineEditProvider,
+  NewSymbolNamesProvider,
+  Position,
+} from '@opensumi/ide-monaco';
 import { SumiReadableStream } from '@opensumi/ide-utils/lib/stream';
 import { IMarker } from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
 
 import { IChatWelcomeMessageContent, ISampleQuestions, ITerminalCommandSuggestionDesc } from '../common';
+import { SerializedContext } from '../common/llm-context';
 
 import {
   ICodeEditsContextBean,
@@ -226,14 +235,39 @@ export type ICodeEditsProvider = (
   token: CancellationToken,
 ) => MaybePromise<ICodeEditsResult | undefined>;
 
+export type IIntelligentInlineEditProvider = (
+  editor: ICodeEditor,
+  position: IPosition,
+  contextBean: IAICompletionOption,
+  token: CancellationToken,
+) => MaybePromise<IIntelligentCompletionsResult>;
+
+/**
+ * Interface for registering intelligent completion providers and code edits providers.
+ */
 export interface IIntelligentCompletionsRegistry {
   /**
-   *  @deprecated use registerInlineCompletionProvider API
+   * Registers an intelligent completion provider.
+   * @deprecated Use the `registerInlineCompletionsProvider` method instead.
+   * @param provider - The intelligent completion provider to register.
    */
   registerIntelligentCompletionProvider(provider: IIntelligentCompletionProvider): void;
+
+  /**
+   * Registers an inline completions provider.
+   * @param provider - The intelligent completion provider to register.
+   */
   registerInlineCompletionsProvider(provider: IIntelligentCompletionProvider): void;
+
   /**
-   * 注册 code edits 功能
+   * Registers an inline edit provider.
+   * @param provider The inline edit provider to register.
+   */
+  registerInlineEditProvider(provider: InlineEditProvider): void;
+
+  /**
+   * Registers a code edits provider.
+   * @param provider - The code edits provider to register.
    */
   registerCodeEditsProvider(provider: ICodeEditsProvider): void;
 }
@@ -292,6 +326,51 @@ export interface AINativeCoreContribution {
    * proposed api
    */
   registerIntelligentCompletionFeature?(registry: IIntelligentCompletionsRegistry): void;
+
+  /**
+   * 注册 Agent 模式下的 chat prompt provider
+   * @param provider
+   */
+  registerChatAgentPromptProvider?(): 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 {
@@ -326,3 +405,13 @@ export interface IAIMiddleware {
     provideInlineCompletions?: IProvideInlineCompletionsSignature;
   };
 }
+
+export const ChatAgentPromptProvider = Symbol('ChatAgentPromptProvider');
+
+export interface ChatAgentPromptProvider {
+  /**
+   * 提供上下文提示
+   * @param context 上下文
+   */
+  provideContextPrompt(context: SerializedContext, userMessage: string): MaybePromise<string>;
+}

package/src/browser/widget/inline-chat/inline-chat-editor.controller.ts

@@ -222,7 +222,7 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
 
   protected async showInlineChat(monacoEditor: monaco.ICodeEditor): Promise<void> {
     // 调试状态下禁用 inline chat。影响调试体验
-    const inDebugMode = this.contextKeyService.getContextValue(CONTEXT_IN_DEBUG_MODE_KEY);
+    const inDebugMode = this.contextKeyService.getContextKeyValue(CONTEXT_IN_DEBUG_MODE_KEY);
     if (inDebugMode) {
       return;
     }

package/src/browser/widget/inline-diff/inline-diff.controller.ts

@@ -51,7 +51,7 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
 
   private previewerStore: Map<string, IInlineDiffPreviewer>;
   private currentPreviewer: ISettableObservable<IInlineDiffPreviewer | undefined>;
-  private modelChangeObs: IObservable<monaco.editor.ITextModel, unknown>;
+  private modelChangeObs: IObservable<monaco.editor.ITextModel>;
 
   mount(): IDisposable {
     this.previewerStore = new Map();

package/src/browser/widget/inline-input/inline-input.controller.ts

@@ -67,7 +67,7 @@ export class InlineInputController extends BaseAIMonacoEditorController {
   private aiNativeContextKey: AINativeContextKey;
 
   private inputValue: ISettableObservable<string>;
-  private modelChangeObs: IObservable<monaco.editor.ITextModel, unknown>;
+  private modelChangeObs: IObservable<monaco.editor.ITextModel>;
   private inlineInputWidgetStore: Map<
     string,
     InlineInputWidgetStoreInEmptyLine | InlineInputWidgetStoreInSelection | null

package/src/common/index.ts

@@ -16,6 +16,9 @@ import { IChatMessage } from '@opensumi/ide-core-common/lib/types/ai-native';
 import { DESIGN_MENUBAR_CONTAINER_VIEW_ID } from '@opensumi/ide-design/lib/common/constants';
 import { IPosition, ITextModel, InlineCompletionContext } from '@opensumi/ide-monaco/lib/common';
 
+import { MCPServerDescription } from './mcp-server-manager';
+import { MCPTool } from './types';
+
 export const IAINativeService = Symbol('IAINativeService');
 
 /**
@@ -116,6 +119,17 @@ export const IChatAgentService = Symbol('IChatAgentService');
 
 export const ChatProxyServiceToken = Symbol('ChatProxyServiceToken');
 
+// 暴露给 Node.js 层，使其可以感知 Opensumi 注册的 MCP 能力
+export const TokenMCPServerProxyService = Symbol('TokenMCPServerProxyService');
+
+export interface ISumiMCPServerBackend {
+  initBuiltinMCPServer(): void;
+  initExternalMCPServers(servers: MCPServerDescription[]): void;
+  getAllMCPTools(): Promise<MCPTool[]>;
+}
+
+export const SumiMCPServerProxyServicePath = 'SumiMCPServerProxyServicePath';
+
 export interface IChatAgentService {
   readonly onDidChangeAgents: Event<void>;
   readonly onDidSendMessage: Event<IChatProgress>;

package/src/common/llm-context.ts

@@ -0,0 +1,41 @@
+import { Event, URI } from '@opensumi/ide-core-common/lib/utils';
+
+export interface LLMContextService {
+  startAutoCollection(): void;
+
+  stopAutoCollection(): void;
+
+  /**
+   * 添加文件到 context 中
+   */
+  addFileToContext(uri: URI, selection?: [number, number], isManual?: boolean): void;
+
+  /**
+   * 清除上下文
+   */
+  cleanFileContext(): void;
+
+  onDidContextFilesChangeEvent: Event<FileContext[]>;
+
+  /**
+   * 从 context 中移除文件
+   * @param uri URI
+   */
+  removeFileFromContext(uri: URI): void;
+
+  /** 导出为可序列化格式 */
+  serialize(): SerializedContext;
+}
+
+export interface FileContext {
+  uri: URI;
+  selection?: [number, number];
+  isManual: boolean;
+}
+
+export const LLMContextServiceToken = Symbol('LLMContextService');
+
+export interface SerializedContext {
+  recentlyViewFiles: string[];
+  attachedFiles: Array<{ content: string; lineErrors: string[]; path: string; language: string }>;
+}

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

@@ -0,0 +1,46 @@
+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[]>;
+    registerTools(serverName: string): Promise<void>;
+    addExternalMCPServers(servers: MCPServerDescription[]): 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,170 @@
+import { z } from 'zod';
+
+import { Injectable } from '@opensumi/di';
+
+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');
+
+/**
+ * 为 Agent 提供的所有可用函数调用的注册表
+ */
+export interface ToolInvocationRegistry {
+    /**
+     * 在注册表中注册一个工具
+     *
+     * @param tool - 要注册的 `ToolRequest` 对象
+     */
+    registerTool(tool: ToolRequest): void;
+
+    /**
+     * 从注册表中获取特定的 `ToolRequest`
+     *
+     * @param toolId - 要获取的工具的唯一标识符
+     * @returns 对应提供的工具 ID 的 `ToolRequest` 对象，
+     *          如果在注册表中找不到该工具，则返回 `undefined`
+     */
+    getFunction(toolId: string): ToolRequest | undefined;
+
+    /**
+     * 从注册表中获取多个 `ToolRequest`
+     *
+     * @param toolIds - 要获取的工具 ID 列表
+     * @returns 指定工具 ID 的 `ToolRequest` 对象数组
+     *          如果找不到某个工具 ID，将在返回的数组中跳过该工具
+     */
+    getFunctions(...toolIds: string[]): ToolRequest[];
+
+    /**
+     * 获取当前注册表中的所有 `ToolRequest`
+     *
+     * @returns 注册表中所有 `ToolRequest` 对象的数组
+     */
+    getAllFunctions(): ToolRequest[];
+
+    /**
+     * 注销特定工具提供者的所有工具
+     *
+     * @param providerName - 要移除其工具的工具提供者名称（在 `ToolRequest` 中指定）
+     */
+    unregisterAllTools(providerName: string): void;
+}
+
+export const ToolProvider = Symbol('ToolProvider');
+export interface ToolProvider {
+    getTool(): ToolRequest;
+}
+
+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)) {
+            // TODO: 使用适当的日志机制
+            this.tools.set(tool.id, tool);
+        } 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(`找不到 ID 为 ${toolId} 的函数`);
+            }
+        });
+        return tools;
+    }
+}
+
+/**
+ * 管理多个 ToolInvocationRegistry 实例的管理器，每个实例与一个 clientId 关联
+ */
+export interface IToolInvocationRegistryManager {
+    /**
+     * 获取或创建特定 clientId 的 ToolInvocationRegistry
+     */
+    getRegistry(clientId: string): ToolInvocationRegistry;
+
+    /**
+     * 移除特定 clientId 的 ToolInvocationRegistry
+     */
+    removeRegistry(clientId: string): void;
+
+    /**
+     * 检查特定 clientId 是否存在对应的注册表
+     */
+    hasRegistry(clientId: string): boolean;
+}
+
+export const ToolInvocationRegistryManager = Symbol('ToolInvocationRegistryManager');
+
+@Injectable()
+export class ToolInvocationRegistryManagerImpl implements IToolInvocationRegistryManager {
+    private registries: Map<string, ToolInvocationRegistry> = new Map();
+
+    getRegistry(clientId: string): ToolInvocationRegistry {
+        let registry = this.registries.get(clientId);
+        if (!registry) {
+            registry = new ToolInvocationRegistryImpl();
+            this.registries.set(clientId, registry);
+        }
+        return registry;
+    }
+
+    removeRegistry(clientId: string): void {
+        this.registries.delete(clientId);
+    }
+
+    hasRegistry(clientId: string): boolean {
+        return this.registries.has(clientId);
+    }
+}
+

package/src/common/types.ts

@@ -18,3 +18,25 @@ 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;
+  }>;
+  // 获取 browser 层注册的 MCP 工具列表 (Browser tab 维度)
+  $getMCPTools(): Promise<MCPTool[]>;
+  // 通知前端 MCP 服务注册表发生了变化
+  $updateMCPServers(): Promise<void>;
+}
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: any;
+  providerName: string;
+}

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

@@ -0,0 +1,25 @@
+import { AnthropicProvider, createAnthropic } from '@ai-sdk/anthropic';
+
+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 AnthropicModelIdentifier = Symbol('AnthropicModelIdentifier');
+
+@Injectable()
+export class AnthropicModel extends BaseLanguageModel {
+  protected initializeProvider(options: IAIBackServiceOption): AnthropicProvider {
+    const apiKey = options.apiKey;
+    if (!apiKey) {
+      throw new Error(`Please provide Anthropic API Key in preferences (${AINativeSettingSectionsId.AnthropicApiKey})`);
+    }
+
+    return createAnthropic({ apiKey });
+  }
+
+  protected getModelIdentifier(provider: AnthropicProvider) {
+    return provider('claude-3-5-sonnet-20241022');
+  }
+}

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');
+  }
+}