@opensumi/ide-ai-native 3.8.1-next-1740475512.0 → 3.8.1-next-1740556231.0

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

@@ -1,4 +1,5 @@
 import { Injectable } from '@opensumi/di';
+import { MaybePromise } from '@opensumi/ide-core-common/lib/utils';
 
 import { SerializedContext } from '../llm-context';
 
@@ -9,36 +10,37 @@ export interface ChatAgentPromptProvider {
    * 提供上下文提示
    * @param context 上下文
    */
-  provideContextPrompt(context: SerializedContext, userMessage: string): string;
+  provideContextPrompt(context: SerializedContext, userMessage: string): MaybePromise<string>;
 }
 
 @Injectable()
 export class DefaultChatAgentPromptProvider implements ChatAgentPromptProvider {
-  provideContextPrompt(context: SerializedContext, userMessage: string): string {
+  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}`).join('\n')}
-  </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>`;
+          <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

@@ -72,7 +72,7 @@ export interface ToolInvocationRegistry {
    *
    * @param providerName - 要移除其工具的工具提供者名称（在 `ToolRequest` 中指定）
    */
-  unregisterProviderTools(providerName: string): void;
+  unregisterAllTools(providerName: string): void;
 }
 
 export const ToolProvider = Symbol('ToolProvider');
@@ -83,7 +83,7 @@ export interface ToolProvider {
 export class ToolInvocationRegistryImpl implements ToolInvocationRegistry {
   private tools: Map<string, ToolRequest> = new Map<string, ToolRequest>();
 
-  unregisterProviderTools(providerName: string): void {
+  unregisterAllTools(providerName: string): void {
     const toolsToRemove: string[] = [];
     for (const [id, tool] of this.tools.entries()) {
       if (tool.providerName === providerName) {

package/src/common/types.ts

@@ -1,3 +1,5 @@
+import { IMarker } from '@opensumi/ide-core-browser';
+
 export enum NearestCodeBlockType {
   Block = 'block',
   Line = 'line',
@@ -32,12 +34,6 @@ export interface IMCPServerProxyService {
   $getMCPTools(): Promise<MCPTool[]>;
   // 通知前端 MCP 服务注册表发生了变化
   $updateMCPServers(): Promise<void>;
-  // 获取所有 MCP 服务器列表
-  $getServers(): Promise<Array<{ name: string; isStarted: boolean }>>;
-  // 启动指定的 MCP 服务器
-  $startServer(serverName: string): Promise<void>;
-  // 停止指定的 MCP 服务器
-  $stopServer(serverName: string): Promise<void>;
 }
 
 export interface MCPTool {
@@ -46,3 +42,21 @@ export interface MCPTool {
   inputSchema: any;
   providerName: string;
 }
+
+export interface CodeBlockData {
+  toolCallId: string;
+  codeEdit: string;
+  updatedCode?: string;
+  relativePath: string;
+  status: CodeBlockStatus;
+  iterationCount: number;
+  createdAt: number;
+  version: number;
+  instructions?: string;
+  applyResult?: {
+    diff: string;
+    diagnosticInfos: IMarker[];
+  };
+}
+
+export type CodeBlockStatus = 'generating' | 'pending' | 'success' | 'rejected' | 'failed' | 'cancelled';

package/src/common/utils.ts

@@ -1,7 +1,5 @@
 import { IEditorDocumentModel } from '@opensumi/ide-editor';
 
-import { BUILTIN_MCP_SERVER_NAME } from './index';
-
 const BACK_QUOTE_3_SYMBOL = '```';
 const MIN_PROMPT_CHARS = 10;
 
@@ -51,4 +49,4 @@ export const extractCodeBlocks = (content: string): string => {
   return newContents.join('\n');
 };
 
-export const getToolName = (toolName: string, serverName = BUILTIN_MCP_SERVER_NAME) => `mcp_${serverName}_${toolName}`;
+export const getToolName = (toolName: string, serverName = 'sumi-builtin') => `mcp_${serverName}_${toolName}`;

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

@@ -57,6 +57,7 @@ export abstract class BaseLanguageModel {
       options.topP,
       options.topK,
       options.providerOptions,
+      options.trimTexts,
       cancellationToken,
     );
   }
@@ -84,6 +85,7 @@ export abstract class BaseLanguageModel {
     topP?: number,
     topK?: number,
     providerOptions?: Record<string, any>,
+    trimTexts?: [string, string],
     cancellationToken?: CancellationToken,
   ): Promise<any> {
     try {
@@ -117,9 +119,42 @@ export abstract class BaseLanguageModel {
         providerOptions,
       });
 
+      // 状态跟踪变量
+      let isFirstChunk = true;
+      let bufferedText = '';
+      const pendingLines: string[] = [];
       for await (const chunk of stream.fullStream) {
         if (chunk.type === 'text-delta') {
-          chatReadableStream.emitData({ kind: 'content', content: chunk.textDelta });
+          if (trimTexts?.length) {
+            // 将收到的文本追加到缓冲区
+            bufferedText += chunk.textDelta;
+
+            // 处理第一个文本块的前缀（只处理一次）
+            if (isFirstChunk && bufferedText.includes(trimTexts[0])) {
+              bufferedText = bufferedText.substring(bufferedText.indexOf(trimTexts[0]) + trimTexts[0].length);
+              isFirstChunk = false;
+            }
+
+            // 检查是否有完整的行，并将它们添加到待发送行队列
+            const lines = bufferedText.split('\n');
+
+            // 最后一个元素可能是不完整的行，保留在缓冲区
+            bufferedText = lines.pop() || '';
+
+            // 将完整的行添加到待发送队列
+            if (lines.length > 0) {
+              pendingLines.push(...lines);
+            }
+
+            // 发送除最后几行外的所有行（保留足够的行以处理后缀）
+            while (pendingLines.length > 3) {
+              // 保留最后3行以确保能完整识别后缀
+              const lineToSend = pendingLines.shift() + '\n';
+              chatReadableStream.emitData({ kind: 'content', content: lineToSend });
+            }
+          } else {
+            chatReadableStream.emitData({ kind: 'content', content: chunk.textDelta });
+          }
         } else if (chunk.type === 'tool-call') {
           chatReadableStream.emitData({
             kind: 'toolCall',
@@ -166,6 +201,33 @@ export abstract class BaseLanguageModel {
         }
       }
 
+      if (trimTexts?.[1]) {
+        // 完成处理所有块后，检查并发送剩余文本
+
+        // 将剩余缓冲区加入待发送行
+        if (bufferedText) {
+          pendingLines.push(bufferedText);
+        }
+
+        // 处理最后一行可能存在的后缀
+        if (pendingLines.length > 0) {
+          let lastLine = pendingLines[pendingLines.length - 1];
+
+          if (lastLine.endsWith(trimTexts[1])) {
+            // 移除后缀
+            lastLine = lastLine.substring(0, lastLine.length - trimTexts[1].length);
+            pendingLines[pendingLines.length - 1] = lastLine;
+          }
+        }
+
+        // 发送所有剩余的行
+        for (let i = 0; i < pendingLines.length; i++) {
+          const isLastLine = i === pendingLines.length - 1;
+          const lineToSend = pendingLines[i] + (isLastLine ? '' : '\n');
+          chatReadableStream.emitData({ kind: 'content', content: lineToSend });
+        }
+      }
+
       chatReadableStream.end();
     } catch (error) {
       // Use a logger service in production instead of console

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

@@ -10,11 +10,11 @@ import { RPCService } from '@opensumi/ide-connection';
 import { ILogger } from '@opensumi/ide-core-common';
 import { INodeLogger } from '@opensumi/ide-core-node';
 
-import { BUILTIN_MCP_SERVER_NAME, ISumiMCPServerBackend } from '../../common';
-import { IMCPServer, MCPServerDescription } from '../../common/mcp-server-manager';
+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 { StdioMCPServerImpl } from '../mcp-server';
+import { IMCPServer } from '../mcp-server';
 import { MCPServerManagerImpl } from '../mcp-server-manager-impl';
 
 // 每个 BrowserTab 都对应了一个 SumiMCPServerBackend 实例
@@ -55,6 +55,7 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
     }
     // 获取 MCP 工具
     const tools = await this.client.$getMCPTools();
+    this.logger.log('[Node backend] SUMI MCP tools', tools);
     return tools;
   }
 
@@ -80,10 +81,10 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
     }));
   }
 
-  public async initBuiltinMCPServer(enabled: boolean) {
+  public async initBuiltinMCPServer() {
     const builtinMCPServer = new BuiltinMCPServer(this, this.logger);
     this.mcpServerManager.setClientId(this.clientId);
-    await this.mcpServerManager.initBuiltinServer(builtinMCPServer, enabled);
+    await this.mcpServerManager.initBuiltinServer(builtinMCPServer);
     this.client?.$updateMCPServers();
   }
 
@@ -129,72 +130,12 @@ export class SumiMCPServerBackend extends RPCService<IMCPServerProxyService> imp
 
     return this.server;
   }
-
-  async getServers() {
-    const servers = Array.from(this.mcpServerManager.getServers().entries());
-    const serverInfos = await Promise.all(
-      servers.map(async ([serverName, server]) => {
-        let toolNames: string[] = [];
-        if (server.isStarted()) {
-          // 只获取正在运行的 MCP Server 的工具列表
-          const toolsResponse = await server.getTools();
-          toolNames = toolsResponse.tools.map((tool) => tool.name);
-        }
-
-        // OpenSumi 内置的 MCP Server
-        if (serverName === BUILTIN_MCP_SERVER_NAME) {
-          return {
-            name: server.getServerName(),
-            isStarted: server.isStarted(),
-            type: 'builtin rpc',
-            tools: toolNames,
-          };
-        }
-
-        // 第三方 Stdio 类型的 MCP Server
-        if (server instanceof StdioMCPServerImpl) {
-          return {
-            name: server.getServerName(),
-            isStarted: server.isStarted(),
-            type: 'stdio',
-            command: server.command + ' ' + (server.args?.join(' ') || ''),
-            tools: toolNames,
-          };
-        }
-
-        // TODO SSE 类型的 MCP Server
-
-        return {
-          name: server.getServerName(),
-          isStarted: server.isStarted(),
-          type: '[MOCK] stdio',
-          command: '[MOCK] npx sumi-ide-mcp-server',
-          tools: toolNames,
-        };
-      }),
-    );
-
-    // 将 builtin server 放在第一位
-    const builtinServer = serverInfos.find((server) => server.name === BUILTIN_MCP_SERVER_NAME);
-    const otherServers = serverInfos.filter((server) => server.name !== BUILTIN_MCP_SERVER_NAME);
-    return builtinServer ? [builtinServer, ...otherServers] : otherServers;
-  }
-
-  async startServer(serverName: string) {
-    await this.mcpServerManager.startServer(serverName);
-    this.client?.$updateMCPServers();
-  }
-
-  async stopServer(serverName: string) {
-    await this.mcpServerManager.stopServer(serverName);
-    this.client?.$updateMCPServers();
-  }
 }
 
 export const TokenBuiltinMCPServer = Symbol('TokenBuiltinMCPServer');
 
 export class BuiltinMCPServer implements IMCPServer {
-  private started: boolean = false;
+  private started: boolean = true;
 
   constructor(private readonly sumiMCPServer: SumiMCPServerBackend, private readonly logger: ILogger) {}
 
@@ -203,7 +144,7 @@ export class BuiltinMCPServer implements IMCPServer {
   }
 
   getServerName(): string {
-    return BUILTIN_MCP_SERVER_NAME;
+    return 'sumi-builtin';
   }
 
   async start(): Promise<void> {
@@ -241,6 +182,7 @@ export class BuiltinMCPServer implements IMCPServer {
       throw new Error('MCP Server not started');
     }
     const tools = await this.sumiMCPServer.getMCPTools();
+    this.logger.debug('[BuiltinMCPServer] getTools', tools);
     return { tools } as any;
   }
 

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

@@ -2,12 +2,13 @@ import { ToolExecutionOptions } from 'ai';
 
 import { ILogger } from '@opensumi/ide-core-common';
 
-import { IMCPServer, MCPServerDescription, MCPServerManager, MCPTool } from '../common/mcp-server-manager';
+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 { StdioMCPServerImpl } from './mcp-server';
+import { IMCPServer, MCPServerImpl } from './mcp-server';
+
 // 这应该是 Browser Tab 维度的，每个 Tab 对应一个 MCPServerManagerImpl
 export class MCPServerManagerImpl implements MCPServerManager {
   protected servers: Map<string, IMCPServer> = new Map();
@@ -15,10 +16,6 @@ export class MCPServerManagerImpl implements MCPServerManager {
   // 当前实例对应的 clientId
   private clientId: string;
 
-  getServers(): Map<string, IMCPServer> {
-    return this.servers;
-  }
-
   constructor(
     private readonly toolInvocationRegistryManager: IToolInvocationRegistryManager,
     private readonly logger: ILogger,
@@ -28,20 +25,13 @@ export class MCPServerManagerImpl implements MCPServerManager {
     this.clientId = clientId;
   }
 
-  private unregisterServerTools(serverName: string) {
-    const registry = this.toolInvocationRegistryManager.getRegistry(this.clientId);
-    registry.unregisterProviderTools(serverName);
-  }
-
   async stopServer(serverName: string): Promise<void> {
     const server = this.servers.get(serverName);
     if (!server) {
       throw new Error(`MCP server "${serverName}" not found.`);
     }
-    await server.stop();
-    // 停止服务器后，需要从注册表中移除该服务器的所有工具
-    this.unregisterServerTools(serverName);
-    this.logger.log(`MCP server "${serverName}" stopped and tools unregistered.`);
+    server.stop();
+    this.logger.log(`MCP server "${serverName}" stopped.`);
   }
 
   async getStartedServers(): Promise<string[]> {
@@ -73,7 +63,6 @@ export class MCPServerManagerImpl implements MCPServerManager {
       throw new Error(`MCP server "${serverName}" not found.`);
     }
     await server.start();
-    await this.registerTools(serverName);
   }
 
   async getServerNames(): Promise<string[]> {
@@ -133,7 +122,7 @@ export class MCPServerManagerImpl implements MCPServerManager {
     if (existingServer) {
       existingServer.update(command, args, env);
     } else {
-      const newServer = new StdioMCPServerImpl(name, command, args, env, this.logger);
+      const newServer = new MCPServerImpl(name, command, args, env, this.logger);
       this.servers.set(name, newServer);
     }
   }
@@ -142,23 +131,16 @@ export class MCPServerManagerImpl implements MCPServerManager {
     this.servers.set(server.getServerName(), server);
   }
 
-  // enabled 为 true 时，会自动启动内置服务器, 并注册工具
-  async initBuiltinServer(builtinMCPServer: BuiltinMCPServer, enabled: boolean = true): Promise<void> {
+  async initBuiltinServer(builtinMCPServer: BuiltinMCPServer): Promise<void> {
     this.addOrUpdateServerDirectly(builtinMCPServer);
-    if (enabled) {
-      await builtinMCPServer.start();
-      await this.registerTools(builtinMCPServer.getServerName());
-    }
+    await this.registerTools(builtinMCPServer.getServerName());
   }
 
   async addExternalMCPServers(servers: MCPServerDescription[]): Promise<void> {
     for (const server of servers) {
       this.addOrUpdateServer(server);
-      if (!server.enabled) {
-        // 如果是 enabled 为 false 的 server，则不进行启动
-        continue;
-      }
       await this.startServer(server.name);
+      await this.registerTools(server.name);
     }
   }
 
@@ -166,10 +148,7 @@ export class MCPServerManagerImpl implements MCPServerManager {
     const server = this.servers.get(name);
     if (server) {
       server.stop();
-      // 移除服务器时，也需要从注册表中移除该服务器的所有工具
-      this.unregisterServerTools(name);
       this.servers.delete(name);
-      this.logger.log(`MCP server "${name}" removed and tools unregistered.`);
     } else {
       this.logger.warn(`MCP server "${name}" not found.`);
     }

package/src/node/mcp-server.ts

@@ -4,12 +4,20 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 
 import { ILogger } from '@opensumi/ide-core-common';
 
-import { IMCPServer } from '../common/mcp-server-manager';
+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 StdioMCPServerImpl implements IMCPServer {
+export class MCPServerImpl implements IMCPServer {
   private name: string;
-  public command: string;
-  public args?: string[];
+  private command: string;
+  private args?: string[];
   private client: Client;
   private env?: { [key: string]: string };
   private started: boolean = false;
@@ -108,17 +116,12 @@ export class StdioMCPServerImpl implements IMCPServer {
     this.env = env;
   }
 
-  async stop(): Promise<void> {
+  stop(): void {
     if (!this.started || !this.client) {
       return;
     }
     this.logger?.log(`Stopping MCP server "${this.name}"`);
-    try {
-      await this.client.close();
-    } catch (error) {
-      this.logger?.error(`Failed to stop MCP server "${this.name}":`, error);
-    }
-    this.logger?.log(`MCP server "${this.name}" stopped`);
+    this.client.close();
     this.started = false;
   }
 }

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

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