@opensumi/ide-ai-native 3.7.2-next-1740066619.0 → 3.7.2-next-1740323956.0

package/src/browser/model/msg-history-manager.ts

@@ -8,10 +8,14 @@ type IExcludeMessage = Omit<IHistoryChatMessage, 'id' | 'order'>;
 @Injectable({ multiple: false })
 export class MsgHistoryManager extends Disposable {
   private messageMap: Map<string, IHistoryChatMessage> = new Map();
+  private messageAdditionalMap: Map<string, Record<string, any>> = new Map();
 
   private readonly _onMessageChange = new Emitter<IHistoryChatMessage[]>();
   public readonly onMessageChange: Event<IHistoryChatMessage[]> = this._onMessageChange.event;
 
+  private readonly _onMessageAdditionalChange = new Emitter<Record<string, any>>();
+  public readonly onMessageAdditionalChange: Event<Record<string, any>> = this._onMessageAdditionalChange.event;
+
   override dispose(): void {
     this.clearMessages();
     super.dispose();
@@ -19,6 +23,7 @@ export class MsgHistoryManager extends Disposable {
 
   public clearMessages() {
     this.messageMap.clear();
+    this.messageAdditionalMap.clear();
   }
 
   private doAddMessage(message: IExcludeMessage): string {
@@ -70,4 +75,18 @@ export class MsgHistoryManager extends Disposable {
       content: message.content,
     });
   }
+
+  public setMessageAdditional(id: string, additional: Record<string, any>) {
+    if (!this.messageMap.has(id)) {
+      return;
+    }
+
+    this.messageAdditionalMap.set(id, additional);
+
+    this._onMessageAdditionalChange.fire(additional);
+  }
+
+  public getMessageAdditional(id: string): Record<string, any> {
+    return this.messageAdditionalMap.get(id) || {};
+  }
 }

package/src/browser/preferences/schema.ts

@@ -122,5 +122,10 @@ export const aiNativePreferenceSchema: PreferenceSchema = {
       type: 'boolean',
       default: false,
     },
+    [AINativeSettingSectionsId.SystemPrompt]: {
+      type: 'string',
+      default: '',
+      description: localize('preference.ai.native.chat.system.prompt.description'),
+    },
   },
 };

package/src/browser/types.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { ZodSchema } from 'zod';
 
 import { AIActionItem } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
 import {
@@ -349,8 +350,9 @@ export interface MCPLogger {
 
 export interface MCPToolDefinition {
   name: string;
+  label?: string;
   description: string;
-  inputSchema: any; // JSON Schema
+  inputSchema: ZodSchema<any>; // JSON Schema
   handler: (
     args: any,
     logger: MCPLogger,
@@ -360,9 +362,21 @@ export interface MCPToolDefinition {
   }>;
 }
 
+export interface IMCPServerToolComponentProps {
+  state?: 'streaming-start' | 'streaming' | 'complete' | 'result';
+  args?: Record<string, any>;
+  result?: any;
+  index?: number;
+  messageId?: string;
+  toolCallId?: string;
+}
+
 export interface IMCPServerRegistry {
   registerMCPTool(tool: MCPToolDefinition): void;
   getMCPTools(): MCPToolDefinition[];
+  getMCPTool(name: string): MCPToolDefinition | undefined;
+  registerToolComponent(name: string, component: React.FC<IMCPServerToolComponentProps>): void;
+  getToolComponent(name: string): React.FC<IMCPServerToolComponentProps> | undefined;
   callMCPTool(
     name: string,
     args: any,
@@ -405,13 +419,3 @@ 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-stream-diff/inline-stream-diff.handler.tsx

@@ -69,6 +69,10 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
 
   public livePreviewDiffDecorationModel: LivePreviewDiffDecorationModel;
 
+  public get uri() {
+    return this.originalModel.uri;
+  }
+
   constructor(private readonly monacoEditor: ICodeEditor) {
     super();
 

package/src/browser/widget/inline-stream-diff/live-preview.component.tsx

@@ -65,6 +65,10 @@ export interface IPartialEditEvent {
    * 已添加行数
    */
   totalAddedLinesCount: number;
+  /**
+   * 已采纳的个数
+   */
+  acceptPartialEditCount: number;
   /**
    * 已删除行数
    */

package/src/browser/widget/inline-stream-diff/live-preview.decoration.tsx

@@ -426,6 +426,7 @@ export class LivePreviewDiffDecorationModel extends Disposable {
       uri: this.model.uri,
       totalPartialEditCount: this.partialEditWidgetList.length,
       resolvedPartialEditCount: this.partialEditWidgetList.filter((w) => w.isHidden).length,
+      acceptPartialEditCount: this.partialEditWidgetList.filter((w) => w.isAccepted).length,
       currentPartialEdit: {
         addedLinesCount,
         deletedLinesCount,

package/src/common/index.ts

@@ -179,6 +179,7 @@ export interface IChatAgentMetadata {
   fullName?: string;
   icon?: Uri;
   iconDark?: Uri;
+  systemPrompt?: string;
 }
 
 export interface IChatAgentRequest {

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

@@ -1,19 +1,24 @@
 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;
+  callTool(
+    serverName: string,
+    toolName: string,
+    toolCallId: 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];

package/src/common/prompts/context-prompt-provider.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@opensumi/di';
+import { MaybePromise } from '@opensumi/ide-core-common/lib/utils';
+
+import { SerializedContext } from '../llm-context';
+
+export const ChatAgentPromptProvider = Symbol('ChatAgentPromptProvider');
+
+export interface ChatAgentPromptProvider {
+  /**
+   * 提供上下文提示
+   * @param context 上下文
+   */
+  provideContextPrompt(context: SerializedContext, userMessage: string): MaybePromise<string>;
+}
+
+@Injectable()
+export class DefaultChatAgentPromptProvider implements ChatAgentPromptProvider {
+  provideContextPrompt(context: SerializedContext, userMessage: string): MaybePromise<string> {
+    return `
+          <additional_data>
+          Below are some potentially helpful/relevant pieces of information for figuring out to respond
+          <recently_viewed_files>
+          ${context.recentlyViewFiles.map((file, idx) => `${idx + 1} : ${file}`)}
+          </recently_viewed_files>
+          <attached_files>
+          ${context.attachedFiles.map(
+            (file) =>
+              `
+          <file_contents>
+          \`\`\`${file.language} ${file.path}
+          ${file.content}
+          \`\`\`
+          </file_contents>
+          <linter_errors>
+          ${file.lineErrors.join('\n')}
+          </linter_errors>
+          `,
+          )}
+          
+          </attached_files>
+          </additional_data>
+          <user_query>
+          ${userMessage}
+          </user_query>`;
+  }
+}

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

@@ -1,33 +1,32 @@
+import { ToolExecutionOptions } from 'ai';
 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(),
+  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;
+  id: string;
+  name: string;
+  parameters?: any;
+  description?: string;
+  handler: (arg_string: string, options?: ToolExecutionOptions) => Promise<any>;
+  providerName?: string;
 }
 
 export namespace ToolRequest {
-    export function isToolParameter(obj: unknown): obj is ToolParameter {
-        return ToolParameterSchema.safeParse(obj).success;
-    }
+  export function isToolParameter(obj: unknown): obj is ToolParameter {
+    return ToolParameterSchema.safeParse(obj).success;
+  }
 }
 
 export const ToolInvocationRegistry = Symbol('ToolInvocationRegistry');
@@ -36,135 +35,134 @@ 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;
+  /**
+   * 在注册表中注册一个工具
+   *
+   * @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;
+  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());
+  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);
+      }
     }
-
-    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;
+    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;
+  /**
+   * 获取或创建特定 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;
-    }
+  private registries: Map<string, ToolInvocationRegistry> = new Map();
 
-    removeRegistry(clientId: string): void {
-        this.registries.delete(clientId);
+  getRegistry(clientId: string): ToolInvocationRegistry {
+    let registry = this.registries.get(clientId);
+    if (!registry) {
+      registry = new ToolInvocationRegistryImpl();
+      this.registries.set(clientId, registry);
     }
+    return registry;
+  }
 
-    hasRegistry(clientId: string): boolean {
-        return this.registries.has(clientId);
-    }
-}
+  removeRegistry(clientId: string): void {
+    this.registries.delete(clientId);
+  }
 
+  hasRegistry(clientId: string): boolean {
+    return this.registries.has(clientId);
+  }
+}

package/src/common/utils.ts

@@ -48,3 +48,5 @@ export const extractCodeBlocks = (content: string): string => {
 
   return newContents.join('\n');
 };
+
+export const getToolName = (toolName: string, serverName = 'sumi-builtin') => `mcp_${serverName}_${toolName}`;

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

@@ -1,4 +1,4 @@
-import { CoreMessage, jsonSchema, streamText, tool } from 'ai';
+import { CoreMessage, ToolExecutionOptions, jsonSchema, streamText, tool } from 'ai';
 
 import { Autowired, Injectable } from '@opensumi/di';
 import { ChatMessageRole, IAIBackServiceOption, IChatMessage } from '@opensumi/ide-core-common';
@@ -52,6 +52,11 @@ export abstract class BaseLanguageModel {
       allFunctions,
       chatReadableStream,
       options.history || [],
+      options.modelId,
+      options.temperature,
+      options.topP,
+      options.topK,
+      options.providerOptions,
       cancellationToken,
     );
   }
@@ -61,11 +66,12 @@ export abstract class BaseLanguageModel {
       description: toolRequest.description || '',
       // TODO 这里应该是 z.object 而不是 JSON Schema
       parameters: jsonSchema(toolRequest.parameters),
-      execute: async (args: any) => await toolRequest.handler(JSON.stringify(args)),
+      execute: async (args: any, options: ToolExecutionOptions) =>
+        await toolRequest.handler(JSON.stringify(args), options),
     });
   }
 
-  protected abstract getModelIdentifier(provider: any): any;
+  protected abstract getModelIdentifier(provider: any, modelId?: string): any;
 
   protected async handleStreamingRequest(
     provider: any,
@@ -73,6 +79,11 @@ export abstract class BaseLanguageModel {
     tools: ToolRequest[],
     chatReadableStream: ChatReadableStream,
     history: IChatMessage[] = [],
+    modelId?: string,
+    temperature?: number,
+    topP?: number,
+    topK?: number,
+    providerOptions?: Record<string, any>,
     cancellationToken?: CancellationToken,
   ): Promise<any> {
     try {
@@ -92,15 +103,18 @@ export abstract class BaseLanguageModel {
         })),
         { role: 'user', content: request },
       ];
-
-      const stream = await streamText({
-        model: this.getModelIdentifier(provider),
+      const stream = streamText({
+        model: this.getModelIdentifier(provider, modelId),
         maxTokens: 4096,
         tools: aiTools,
         messages,
         abortSignal: abortController.signal,
         experimental_toolCallStreaming: true,
         maxSteps: 12,
+        temperature,
+        topP: topP || 0.8,
+        topK: topK || 1,
+        providerOptions,
       });
 
       for await (const chunk of stream.fullStream) {

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

@@ -156,7 +156,7 @@ export class BuiltinMCPServer implements IMCPServer {
     this.started = true;
   }
 
-  async callTool(toolName: string, arg_string: string): Promise<any> {
+  async callTool(toolName: string, toolCallId: string, arg_string: string): Promise<any> {
     if (!this.started) {
       throw new Error('MCP Server not started');
     }
@@ -171,7 +171,10 @@ export class BuiltinMCPServer implements IMCPServer {
       );
       throw error;
     }
-    return this.sumiMCPServer.callMCPTool(toolName, args);
+    return this.sumiMCPServer.callMCPTool(toolName, {
+      ...args,
+      toolCallId,
+    });
   }
 
   async getTools(): ReturnType<Client['listTools']> {

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

@@ -1,7 +1,10 @@
+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';
@@ -41,12 +44,17 @@ export class MCPServerManagerImpl implements MCPServerManager {
     return startedServers;
   }
 
-  callTool(serverName: string, toolName: string, arg_string: string): ReturnType<IMCPServer['callTool']> {
+  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, arg_string);
+    return server.callTool(toolName, toolCallId, arg_string);
   }
 
   async startServer(serverName: string): Promise<void> {
@@ -62,7 +70,7 @@ export class MCPServerManagerImpl implements MCPServerManager {
   }
 
   private convertToToolRequest(tool: MCPTool, serverName: string): ToolRequest {
-    const id = `mcp_${serverName}_${tool.name}`;
+    const id = getToolName(tool.name, serverName);
 
     return {
       id,
@@ -70,9 +78,9 @@ export class MCPServerManagerImpl implements MCPServerManager {
       providerName: serverName,
       parameters: tool.inputSchema,
       description: tool.description,
-      handler: async (arg_string: string) => {
+      handler: async (arg_string: string, options?: ToolExecutionOptions) => {
         try {
-          const res = await this.callTool(serverName, tool.name, arg_string);
+          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);