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

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

@@ -0,0 +1,161 @@
+// 想要通过 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 { MCPServerManager } from '../../common/mcp-server-manager';
+import { IMCPServerProxyService } 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> {
+
+  // 这里需要考虑不同的 BrowserTab 的区分问题，目前的 POC 所有的 Tab 都会注册到 tools 中
+  // 后续需要区分不同的 Tab 对应的实例
+  @Autowired(MCPServerManager)
+  private readonly mcpServerManager: MCPServerManagerImpl;
+
+  private server: Server | undefined;
+
+  async getMCPTools() {
+    if (!this.client) {
+      throw new Error('SUMI MCP RPC Client not initialized');
+    }
+    // 获取 MCP 工具
+    const tools =  await this.client.$getMCPTools();
+    console.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;
+  }
+
+  initBuiltinMCPServer() {
+    const builtinMCPServer = new BuiltinMCPServer(this);
+    this.mcpServerManager.initBuiltinServer(builtinMCPServer);
+  }
+
+  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 {
+
+  constructor(
+    private readonly sumiMCPServer: SumiMCPServerBackend,
+  ) {}
+
+  private started: boolean = true;
+
+  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) {
+      console.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();
+    return { tools };
+  }
+
+  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,130 @@
+import { Autowired, Injectable } from '@opensumi/di';
+
+import { MCPServerDescription, MCPServerManager, MCPTool } from '../common/mcp-server-manager';
+import { ToolInvocationRegistry, ToolInvocationRegistryImpl, ToolRequest } from '../common/tool-invocation-registry';
+
+import { BuiltinMCPServer } from './mcp/sumi-mcp-server';
+import { IMCPServer, MCPServerImpl } from './mcp-server';
+
+@Injectable()
+export class MCPServerManagerImpl implements MCPServerManager {
+  @Autowired(ToolInvocationRegistry)
+  private readonly toolInvocationRegistry: ToolInvocationRegistryImpl;
+
+  protected servers: Map<string, IMCPServer> = new Map();
+
+  async stopServer(serverName: string): Promise<void> {
+    const server = this.servers.get(serverName);
+    if (!server) {
+      throw new Error(`MCP server "${serverName}" not found.`);
+    }
+    server.stop();
+    console.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: `mcp_${serverName}`,
+      parameters: tool.inputSchema,
+      description: tool.description,
+      handler: async (arg_string: string) => {
+        try {
+          const res = await this.callTool(serverName, tool.name, arg_string);
+          console.log(`[MCP: ${serverName}] ${tool.name} called with ${arg_string}`);
+          console.log(res);
+          return JSON.stringify(res);
+        } catch (error) {
+          console.error(`Error in tool handler for ${tool.name} on MCP server ${serverName}:`, error);
+          throw error;
+        }
+      },
+    };
+  }
+
+  public async collectTools(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));
+
+    for (const toolRequest of toolRequests) {
+      this.toolInvocationRegistry.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.servers.set(name, newServer);
+    }
+  }
+
+  addOrUpdateServerDirectly(server: IMCPServer): void {
+    this.servers.set(server.getServerName(), server);
+  }
+
+  initBuiltinServer(builtinMCPServer: BuiltinMCPServer): void {
+    this.addOrUpdateServerDirectly(builtinMCPServer);
+    this.collectTools(builtinMCPServer.getServerName());
+  }
+
+  removeServer(name: string): void {
+    const server = this.servers.get(name);
+    if (server) {
+      server.stop();
+      this.servers.delete(name);
+    } else {
+      console.warn(`MCP server "${name}" not found.`);
+    }
+  }
+}

package/src/node/mcp-server.ts

@@ -0,0 +1,118 @@
+// 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';
+
+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>) {
+    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;
+    }
+    console.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) => {
+      console.error('Error: ' + error);
+    };
+
+    this.client = new Client(
+      {
+        name: 'opensumi-mcp-client',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {},
+      },
+    );
+    this.client.onerror = (error) => {
+      console.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) {
+      console.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;
+    }
+    console.log(`Stopping MCP server "${this.name}"`);
+    this.client.close();
+    this.started = false;
+  }
+}

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

@@ -0,0 +1,152 @@
+import OpenAI from 'openai';
+import { RunnableToolFunctionWithoutParse } from 'openai/lib/RunnableFunction';
+
+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 OpenAiModelIdentifier = Symbol('OpenAiModelIdentifier');
+
+const apiKey = '';
+
+@Injectable()
+export class OpenAIModel {
+  @Autowired(ToolInvocationRegistry)
+  private readonly toolInvocationRegistry: ToolInvocationRegistryImpl;
+
+  protected initializeOpenAi(): OpenAI {
+    if (!apiKey) {
+      throw new Error('Please provide ANTHROPIC_API_KEY in preferences or via environment variable');
+    }
+
+    return new OpenAI({ apiKey: apiKey ?? 'no-key', baseURL: 'https://api.deepseek.com' });
+  }
+
+  async request(request: string, cancellationToken?: CancellationToken): Promise<any> {
+    return this.handleStreamingRequest(request, cancellationToken);
+  }
+
+  private createTool(tools: ToolRequest[]): RunnableToolFunctionWithoutParse[] {
+    return tools?.map(
+      (tool) =>
+        ({
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            function: (args_string: string) => tool.handler(args_string),
+          },
+        } as RunnableToolFunctionWithoutParse),
+    );
+  }
+
+  private getCompletionContent(message: OpenAI.Chat.Completions.ChatCompletionToolMessageParam): string {
+    if (Array.isArray(message.content)) {
+      return message.content.join('');
+    }
+    return message.content;
+  }
+
+  protected async handleStreamingRequest(request: string, cancellationToken?: CancellationToken): Promise<any> {
+    const chatReadableStream = new ChatReadableStream();
+
+    const openai = this.initializeOpenAi();
+
+    const allFunctions = this.toolInvocationRegistry.getAllFunctions();
+
+    const tools = this.createTool(allFunctions);
+
+    const params = {
+      model: 'deepseek-chat',
+      messages: [{ role: 'user', content: request }],
+      stream: true,
+      tools,
+      tool_choice: 'auto',
+    } as any;
+    console.log('🚀 ~ OpenAIModel ~ params:', JSON.stringify(params, null, 2));
+
+    const runner = openai.beta.chat.completions.runTools(params) as any;
+
+    cancellationToken?.onCancellationRequested(() => {
+      runner.abort();
+    });
+
+    const runnerEnd = false;
+
+    // runner.on('error', error => {
+    //   console.error('Error in OpenAI chat completion stream:', error);
+    //   runnerEnd = true;
+    //   resolve({ content: error.message });
+    // });
+    // // we need to also listen for the emitted errors, as otherwise any error actually thrown by the API will not be caught
+    // runner.emitted('error').then(error => {
+    //   console.error('Error in OpenAI chat completion stream:', error);
+    //   runnerEnd = true;
+    //   resolve({ content: error.message });
+    // });
+    // runner.emitted('abort').then(() => {
+    //   // do nothing, as the abort event is only emitted when the runner is aborted by us
+    // });
+    // runner.on('message', message => {
+    //   if (message.tool_calls) {
+    //     resolve({
+    //       tool_calls: message.tool_calls.map((tool) => (
+    //         {
+    //           id: tool.id,
+    //           type: tool.type,
+    //           function: tool.function
+    //         }
+    //       ))
+    //     });
+    //   }
+    // });
+    runner.once('end', () => {
+      // runnerEnd = true;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      // resolve(runner.finalChatCompletion as any);
+      chatReadableStream.end();
+    });
+
+    runner.on('chunk', (chunk) => {
+      if (chunk.choices[0]?.delta) {
+        const chunkData = { ...chunk.choices[0]?.delta };
+        // resolve(chunkData);
+
+        console.log('🚀 ~ OpenAIModel ~ chunkData:', chunkData);
+        if (chunkData.tool_calls) {
+          chatReadableStream.emitData({ kind: 'toolCall', content: chunkData.tool_calls[0] });
+        } else if (chunkData.content) {
+          chatReadableStream.emitData({ kind: 'content', content: chunkData.content });
+        }
+      }
+    });
+
+    // const asyncIterator = {
+    //   async *[Symbol.asyncIterator](): AsyncIterator<any> {
+    //     runner.on('chunk', chunk => {
+    //       if (chunk.choices[0]?.delta) {
+    //         const chunkData = { ...chunk.choices[0]?.delta };
+    //         resolve(chunkData);
+
+    //         if (chunkData.tool_calls) {
+    //           chatReadableStream.emitData({ kind: 'toolCall', content: chunkData.tool_calls[0] });
+    //         } else if (chunkData.content) {
+    //           chatReadableStream.emitData({ kind: 'content', content: chunkData.content });
+    //         }
+    //       }
+    //     });
+    //     while (!runnerEnd) {
+    //       const promise = new Promise<any>((res, rej) => {
+    //         resolve = res;
+    //       });
+    //       yield promise;
+    //     }
+    //   }
+    // };
+    // return { stream: asyncIterator };
+    return chatReadableStream;
+  }
+}

package/lib/browser/contrib/intelligent-completions/source/typing.source.d.ts

@@ -1,9 +0,0 @@
-import { IDisposable } from '@opensumi/ide-core-common';
-import { IModelContentChangedEvent, Position } from '@opensumi/ide-monaco';
-import { BaseCodeEditsSource } from './base';
-export declare class TypingCodeEditsSource extends BaseCodeEditsSource {
-    priority: number;
-    mount(): IDisposable;
-    protected doTrigger(position: Position, data: IModelContentChangedEvent): Promise<void>;
-}
-//# sourceMappingURL=typing.source.d.ts.map

package/lib/browser/contrib/intelligent-completions/source/typing.source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typing.source.d.ts","sourceRoot":"","sources":["../../../../../src/browser/contrib/intelligent-completions/source/typing.source.ts"],"names":[],"mappings":"AACA,OAAO,EAAqD,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC3G,OAAO,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAE7C,qBACa,qBAAsB,SAAQ,mBAAmB;IACrD,QAAQ,SAAK;IAEb,KAAK,IAAI,WAAW;cAYX,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,yBAAyB;CAa9E"}

package/lib/browser/contrib/intelligent-completions/source/typing.source.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypingCodeEditsSource = void 0;
-const tslib_1 = require("tslib");
-const di_1 = require("@opensumi/di");
-const ide_core_common_1 = require("@opensumi/ide-core-common");
-const base_1 = require("./base");
-let TypingCodeEditsSource = class TypingCodeEditsSource extends base_1.BaseCodeEditsSource {
-    constructor() {
-        super(...arguments);
-        this.priority = 0;
-    }
-    mount() {
-        this.addDispose(this.monacoEditor.onDidChangeModelContent((event) => {
-            const position = this.monacoEditor.getPosition();
-            if (position) {
-                this.doTrigger(position, event);
-            }
-        }));
-        return this;
-    }
-    async doTrigger(position, data) {
-        const isTypingEnabled = this.preferenceService.getValid(ide_core_common_1.AINativeSettingSectionsId.CodeEditsTyping, false);
-        if (!isTypingEnabled || !this.model) {
-            return;
-        }
-        this.setBean({
-            typing: ide_core_common_1.ECodeEditsSourceTyping.Typing,
-            position,
-            data,
-        });
-    }
-};
-exports.TypingCodeEditsSource = TypingCodeEditsSource;
-exports.TypingCodeEditsSource = TypingCodeEditsSource = tslib_1.__decorate([
-    (0, di_1.Injectable)({ multiple: true })
-], TypingCodeEditsSource);
-//# sourceMappingURL=typing.source.js.map

package/lib/browser/contrib/intelligent-completions/source/typing.source.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typing.source.js","sourceRoot":"","sources":["../../../../../src/browser/contrib/intelligent-completions/source/typing.source.ts"],"names":[],"mappings":";;;;AAAA,qCAA0C;AAC1C,+DAA2G;AAG3G,iCAA6C;AAGtC,IAAM,qBAAqB,GAA3B,MAAM,qBAAsB,SAAQ,0BAAmB;IAAvD;;QACE,aAAQ,GAAG,CAAC,CAAC;IA2BtB,CAAC;IAzBQ,KAAK;QACV,IAAI,CAAC,UAAU,CACb,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,KAAgC,EAAE,EAAE;YAC7E,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;YACjD,IAAI,QAAQ,EAAE,CAAC;gBACb,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAClC,CAAC;QACH,CAAC,CAAC,CACH,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IAES,KAAK,CAAC,SAAS,CAAC,QAAkB,EAAE,IAA+B;QAC3E,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,2CAAyB,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;QAE1G,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YACpC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,CAAC;YACX,MAAM,EAAE,wCAAsB,CAAC,MAAM;YACrC,QAAQ;YACR,IAAI;SACL,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AA5BY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,eAAU,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;GAClB,qBAAqB,CA4BjC"}

package/src/browser/contrib/intelligent-completions/source/typing.source.ts

@@ -1,36 +0,0 @@
-import { Injectable } from '@opensumi/di';
-import { AINativeSettingSectionsId, ECodeEditsSourceTyping, IDisposable } from '@opensumi/ide-core-common';
-import { IModelContentChangedEvent, Position } from '@opensumi/ide-monaco';
-
-import { BaseCodeEditsSource } from './base';
-
-@Injectable({ multiple: true })
-export class TypingCodeEditsSource extends BaseCodeEditsSource {
-  public priority = 0;
-
-  public mount(): IDisposable {
-    this.addDispose(
-      this.monacoEditor.onDidChangeModelContent((event: IModelContentChangedEvent) => {
-        const position = this.monacoEditor.getPosition();
-        if (position) {
-          this.doTrigger(position, event);
-        }
-      }),
-    );
-    return this;
-  }
-
-  protected async doTrigger(position: Position, data: IModelContentChangedEvent) {
-    const isTypingEnabled = this.preferenceService.getValid(AINativeSettingSectionsId.CodeEditsTyping, false);
-
-    if (!isTypingEnabled || !this.model) {
-      return;
-    }
-
-    this.setBean({
-      typing: ECodeEditsSourceTyping.Typing,
-      position,
-      data,
-    });
-  }
-}