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

package/src/browser/mcp/tools/handlers/ReadFile.ts

@@ -0,0 +1,174 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { FileSearchQuickCommandHandler } from '@opensumi/ide-addons/lib/browser/file-search.contribution';
+import { AppConfig } from '@opensumi/ide-core-browser';
+import { CancellationToken, URI } from '@opensumi/ide-core-common';
+import { IEditorDocumentModelRef, IEditorDocumentModelService } from '@opensumi/ide-editor/lib/browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+@Injectable()
+export class FileHandler {
+  private static readonly MAX_FILE_SIZE_BYTES = 2e6;
+  private static readonly MAX_LINES = 250;
+  private static readonly MAX_CHARS = 1e5;
+  private static readonly NEWLINE = '\n';
+
+  @Autowired(IEditorDocumentModelService)
+  protected modelService: IEditorDocumentModelService;
+
+  @Autowired(FileSearchQuickCommandHandler)
+  protected fileSearchQuickCommandHandler: FileSearchQuickCommandHandler;
+
+  @Autowired(AppConfig)
+  protected appConfig: AppConfig;
+
+  @Autowired(IFileServiceClient)
+  protected fileSystemService: IFileServiceClient;
+
+  async findSimilarFiles(filePath: string, maxResults: number): Promise<string[]> {
+    const items = await this.fileSearchQuickCommandHandler.getQueryFiles(filePath, new Set(), CancellationToken.None);
+    return items
+      .slice(0, maxResults)
+      .map((item) => item.getUri()?.codeUri.fsPath)
+      .filter(Boolean) as string[];
+  }
+  // TODO: 错误应该给模型？
+  private createFileNotFoundError(filePath: string, similarFiles: string[]): Error {
+    const errorMessage =
+      similarFiles.length > 0
+        ? `Could not find file '${filePath}'. Did you mean one of:\n${similarFiles
+            .map((file) => `- ${file}`)
+            .join('\n')}`
+        : `Could not find file '${filePath}' in the workspace.`;
+
+    return new Error(
+      JSON.stringify({
+        clientVisibleErrorMessage: errorMessage,
+        modelVisibleErrorMessage: errorMessage,
+        actualErrorMessage: `File not found: ${filePath}`,
+      }),
+    );
+  }
+
+  private createFileTooLargeError(fileSizeMB: string, fileStatsSize: number): Error {
+    return new Error(
+      JSON.stringify({
+        clientVisibleErrorMessage: `File is too large, >${fileSizeMB}MB`,
+        modelVisibleErrorMessage: `The file is too large to read, was >${fileSizeMB}MB`,
+        actualErrorMessage: `File is too large to read, was >${fileSizeMB}MB, size: ${fileStatsSize} bytes`,
+      }),
+    );
+  }
+
+  private trimContent(content: string, maxChars: number): string {
+    return content.slice(0, maxChars).split(FileHandler.NEWLINE).slice(0, -1).join(FileHandler.NEWLINE);
+  }
+
+  private getLineRange(
+    fileParams: {
+      startLineOneIndexed?: number;
+      endLineOneIndexedInclusive?: number;
+    },
+    forceLimit: boolean,
+  ): { start: number; end: number; didShorten: boolean; didSetDefault: boolean } {
+    let start = fileParams.startLineOneIndexed ?? 1;
+    let end = fileParams.endLineOneIndexedInclusive ?? start + FileHandler.MAX_LINES - 1;
+    let didShorten = false;
+    let didSetDefault = false;
+
+    if (forceLimit) {
+      return { start, end, didShorten, didSetDefault };
+    }
+
+    if (fileParams.endLineOneIndexedInclusive === undefined || fileParams.startLineOneIndexed === undefined) {
+      start = 1;
+      end = FileHandler.MAX_LINES;
+      didSetDefault = true;
+    } else if (fileParams.endLineOneIndexedInclusive - fileParams.startLineOneIndexed > FileHandler.MAX_LINES) {
+      end = fileParams.startLineOneIndexed + FileHandler.MAX_LINES;
+      didShorten = true;
+    }
+
+    return { start, end, didShorten, didSetDefault };
+  }
+
+  async readFile(fileParams: {
+    relativeWorkspacePath: string;
+    readEntireFile: boolean;
+    fileIsAllowedToBeReadEntirely?: boolean;
+    startLineOneIndexed?: number;
+    endLineOneIndexedInclusive?: number;
+  }) {
+    if (!fileParams) {
+      throw new Error('No read file parameters provided. Need to give at least the path.');
+    }
+
+    const uri = new URI(`${this.appConfig.workspaceDir}/${fileParams.relativeWorkspacePath}`);
+    if (!uri) {
+      const similarFiles = await this.findSimilarFiles(fileParams.relativeWorkspacePath, 3);
+      throw this.createFileNotFoundError(fileParams.relativeWorkspacePath, similarFiles);
+    }
+
+    const fileSizeMB = (FileHandler.MAX_FILE_SIZE_BYTES / 1e6).toFixed(2);
+    const fileStats = await this.fileSystemService.getFileStat(uri.toString());
+
+    if (fileStats?.size && fileStats.size > FileHandler.MAX_FILE_SIZE_BYTES) {
+      throw this.createFileTooLargeError(fileSizeMB, fileStats.size);
+    }
+
+    let modelReference: IEditorDocumentModelRef | undefined;
+    try {
+      modelReference = await this.modelService.createModelReference(uri);
+      const fileContent = modelReference.instance.getMonacoModel().getValue();
+      const fileLines = fileContent.split(FileHandler.NEWLINE);
+
+      const shouldLimitLines = !(fileParams.readEntireFile && fileParams.fileIsAllowedToBeReadEntirely);
+      const shouldForceLimitLines = fileParams.readEntireFile && !fileParams.fileIsAllowedToBeReadEntirely;
+      let didShortenCharRange = false;
+
+      if (shouldLimitLines) {
+        const {
+          start,
+          end,
+          didShorten: didShortenLineRange,
+          didSetDefault: didSetDefaultLineRange,
+        } = this.getLineRange(fileParams, shouldForceLimitLines);
+
+        const adjustedStart = Math.max(start, 1);
+        const adjustedEnd = Math.min(end, fileLines.length);
+        let selectedContent = fileLines.slice(adjustedStart - 1, adjustedEnd).join(FileHandler.NEWLINE);
+
+        if (selectedContent.length > FileHandler.MAX_CHARS) {
+          didShortenCharRange = true;
+          selectedContent = this.trimContent(selectedContent, FileHandler.MAX_CHARS);
+        }
+
+        return {
+          contents: selectedContent,
+          didDowngradeToLineRange: shouldForceLimitLines,
+          didShortenLineRange,
+          didShortenCharRange,
+          didSetDefaultLineRange,
+          fullFileContents: fileContent,
+          startLineOneIndexed: adjustedStart,
+          endLineOneIndexedInclusive: adjustedEnd,
+          relativeWorkspacePath: fileParams.relativeWorkspacePath,
+        };
+      }
+
+      let fullContent = fileContent;
+      if (fullContent.length > FileHandler.MAX_CHARS) {
+        didShortenCharRange = true;
+        fullContent = this.trimContent(fullContent, FileHandler.MAX_CHARS);
+      }
+
+      return {
+        contents: fullContent,
+        fullFileContents: fileContent,
+        didDowngradeToLineRange: false,
+        didShortenCharRange,
+      };
+    } finally {
+      modelReference?.dispose();
+    }
+  }
+}

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+import { ListDirHandler } from './handlers/ListDir';
+
+const inputSchema = z
+  .object({
+    relative_workspace_path: z
+      .string()
+      .describe("Path to list contents of, relative to the workspace root. Ex: './' is the root of the workspace"),
+    explanation: z
+      .string()
+      .describe('One sentence explanation as to why this tool is being used, and how it contributes to the goal.'),
+  })
+  .transform((data) => ({
+    relativeWorkspacePath: data.relative_workspace_path,
+  }));
+
+@Domain(MCPServerContribution)
+export class ListDirTool implements MCPServerContribution {
+  @Autowired(ListDirHandler)
+  private readonly listDirHandler: ListDirHandler;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'list_dir',
+      description:
+        'List the contents of a directory. The quick tool to use for discovery, before using more targeted tools like semantic search or file reading. Useful to try to understand the file structure before diving deeper into specific files. Can be used to explore the codebase.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    // TODO: 应该添加统一的 validate 逻辑
+    args = inputSchema.parse(args);
+    const result = await this.listDirHandler.handler(args);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Contents of directory:
+
+
+          ${result.files
+            .map(
+              (file) =>
+                `[${file.isDirectory ? 'dir' : 'file'}] ${file.name} ${
+                  file.isDirectory ? `(${file.numChildren ?? '?'} items)` : `(${file.size}KB, ${file.numLines} lines)`
+                } - ${new Date(file.lastModified).toLocaleString()}`,
+            )
+            .join('\n')}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+import { FileHandler } from './handlers/ReadFile';
+
+const inputSchema = z
+  .object({
+    relative_workspace_path: z.string().describe('The path of the file to read, relative to the workspace root.'),
+    should_read_entire_file: z.boolean().describe('Whether to read the entire file. Defaults to false.'),
+    start_line_one_indexed: z.number().describe('The one-indexed line number to start reading from (inclusive).'),
+    end_line_one_indexed_inclusive: z.number().describe('The one-indexed line number to end reading at (inclusive).'),
+    explanation: z
+      .string()
+      .describe('One sentence explanation as to why this tool is being used, and how it contributes to the goal.'),
+  })
+  .transform((data) => ({
+    relativeWorkspacePath: data.relative_workspace_path,
+    readEntireFile: data.should_read_entire_file,
+    startLineOneIndexed: data.start_line_one_indexed,
+    endLineOneIndexedInclusive: data.end_line_one_indexed_inclusive,
+  }));
+
+@Domain(MCPServerContribution)
+export class ReadFileTool implements MCPServerContribution {
+  @Autowired(FileHandler)
+  private readonly fileHandler: FileHandler;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'read_file',
+      description: `Read the contents of a file (and the outline).
+
+When using this tool to gather information, it's your responsibility to ensure you have the COMPLETE context. Each time you call this command you should:
+1) Assess if contents viewed are sufficient to proceed with the task.
+2) Take note of lines not shown.
+3) If file contents viewed are insufficient, and you suspect they may be in lines not shown, proactively call the tool again to view those lines.
+4) When in doubt, call this tool again to gather more information. Partial file views may miss critical dependencies, imports, or functionality.
+
+If reading a range of lines is not enough, you may choose to read the entire file.
+Reading entire files is often wasteful and slow, especially for large files (i.e. more than a few hundred lines). So you should use this option sparingly.
+Reading the entire file is not allowed in most cases. You are only allowed to read the entire file if it has been edited or manually attached to the conversation by the user.`,
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    // TODO: 应该添加统一的 validate 逻辑
+    args = inputSchema.parse(args);
+    const result = await this.fileHandler.readFile(args);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.didShortenLineRange
+            ? `Contents of ${result.relativeWorkspacePath}, from line ${args.startLineOneIndexed}-${
+                args.endLineOneIndexedInclusive
+              }:
+
+\`\`\`
+// ${result.relativeWorkspacePath!.split('/').pop()}
+${result.contents}
+\`\`\``
+            : `Full contents of ${args.relativeWorkspacePath}:
+
+\`\`\`
+${result.contents}
+\`\`\``,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,80 @@
+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({
+  text: z.string().describe('The new content to replace the entire file with'),
+});
+
+@Domain(MCPServerContribution)
+export class ReplaceOpenEditorFileTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'replace_open_in_editor_file_text',
+      description:
+        'Replaces the entire content of the currently active file in the IDE editor with specified new text. ' +
+        'Use this tool when you need to completely overwrite the current file\'s content. ' +
+        'Requires a text parameter containing the new content. ' +
+        'Returns one of three possible responses: ' +
+        '"ok" if the file content was successfully replaced, ' +
+        '"no file open" if no editor is active, ' +
+        '"unknown error" if the operation fails.',
+      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.monacoEditor) {
+        logger.appendLine('Error: No active text editor found');
+        return {
+          content: [{ type: 'text', text: 'no file open' }],
+          isError: true,
+        };
+      }
+
+      // Get the model and its full range
+      const model = editor.monacoEditor.getModel();
+      if (!model) {
+        logger.appendLine('Error: No model found for current editor');
+        return {
+          content: [{ type: 'text', text: 'unknown error' }],
+          isError: true,
+        };
+      }
+
+      const fullRange = model.getFullModelRange();
+
+      // Execute the replacement
+      editor.monacoEditor.executeEdits('mcp.tool.replace-file', [{
+        range: fullRange,
+        text: args.text,
+      }]);
+
+      logger.appendLine('Successfully replaced file content');
+      return {
+        content: [{ type: 'text', text: 'ok' }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error during file content replacement: ${error}`);
+      return {
+        content: [{ type: 'text', text: 'unknown error' }],
+        isError: true,
+      };
+    }
+  }
+}

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

@@ -0,0 +1,91 @@
+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 { Selection, SelectionDirection } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/selection';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+import { LiveInlineDiffPreviewer } from '../../widget/inline-diff/inline-diff-previewer';
+import { InlineDiffController } from '../../widget/inline-diff/inline-diff.controller';
+
+const inputSchema = z.object({
+  text: z.string().describe('The new content to replace the entire file with'),
+});
+
+@Domain(MCPServerContribution)
+export class ReplaceOpenEditorFileByDiffPreviewerTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'replace_open_in_editor_file_text',
+      description:
+        'Replaces the entire content of the currently active file in the IDE editor with specified new text using diff previewer. ' +
+        "Use this tool when you need to completely overwrite the current file's content with diff preview. " +
+        'Requires a text parameter containing the new content. ' +
+        'Returns one of three possible responses: ' +
+        '"ok" if the file content was successfully replaced, ' +
+        '"no file open" if no editor is active, ' +
+        '"unknown error" if the operation fails.',
+      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.monacoEditor) {
+        logger.appendLine('Error: No active text editor found');
+        return {
+          content: [{ type: 'text', text: 'no file open' }],
+          isError: true,
+        };
+      }
+
+      // Get the model and its full range
+      const model = editor.monacoEditor.getModel();
+      if (!model) {
+        logger.appendLine('Error: No model found for current editor');
+        return {
+          content: [{ type: 'text', text: 'unknown error' }],
+          isError: true,
+        };
+      }
+
+      const fullRange = model.getFullModelRange();
+      const inlineDiffHandler = InlineDiffController.get(editor.monacoEditor)!;
+
+      // Create diff previewer
+      const previewer = inlineDiffHandler.createDiffPreviewer(
+        editor.monacoEditor,
+        Selection.fromRange(fullRange, SelectionDirection.LTR),
+        {
+          disposeWhenEditorClosed: false,
+          renderRemovedWidgetImmediately: true,
+        },
+      ) as LiveInlineDiffPreviewer;
+
+      // Set the new content
+      previewer.setValue(args.text);
+
+      logger.appendLine('Successfully created diff preview with new content');
+      return {
+        content: [{ type: 'text', text: 'ok' }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error during file content replacement: ${error}`);
+      return {
+        content: [{ type: 'text', text: 'unknown error' }],
+        isError: true,
+      };
+    }
+  }
+}

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

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired } from '@opensumi/di';
+import { AppConfig } from '@opensumi/ide-core-browser';
+import { Deferred, Domain } from '@opensumi/ide-core-common';
+import { ITerminalController, ITerminalGroupViewService } from '@opensumi/ide-terminal-next/lib/common/controller';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const color = {
+  italic: '\x1b[3m',
+  reset: '\x1b[0m',
+};
+
+const inputSchema = z.object({
+  command: z.string().describe('The terminal command to execute'),
+  is_background: z.boolean().describe('Whether the command should be run in the background'),
+  explanation: z
+    .string()
+    .describe('One sentence explanation as to why this command needs to be run and how it contributes to the goal.'),
+  require_user_approval: z
+    .boolean()
+    .describe(
+      "Whether the user must approve the command before it is executed. Only set this to false if the command is safe and if it matches the user's requirements for commands that should be executed automatically.",
+    ),
+});
+
+@Domain(MCPServerContribution)
+export class RunTerminalCommandTool implements MCPServerContribution {
+  @Autowired(ITerminalController)
+  protected readonly terminalController: ITerminalController;
+
+  @Autowired(AppConfig)
+  protected readonly appConfig: AppConfig;
+
+  @Autowired(ITerminalGroupViewService)
+  protected readonly terminalView: ITerminalGroupViewService;
+
+  private terminalId = 0;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'run_terminal_cmd',
+      description:
+        "PROPOSE a command to run on behalf of the user.\nIf you have this tool, note that you DO have the ability to run commands directly on the USER's system.\n\nAdhere to these rules:\n1. Based on the contents of the conversation, you will be told if you are in the same shell as a previous step or a new shell.\n2. If in a new shell, you should `cd` to the right directory and do necessary setup in addition to running the command.\n3. If in the same shell, the state will persist, no need to do things like `cd` to the same directory.\n4. For ANY commands that would use a pager, you should append ` | cat` to the command (or whatever is appropriate). You MUST do this for: git, less, head, tail, more, etc.\n5. For commands that are long running/expected to run indefinitely until interruption, please run them in the background. To run jobs in the background, set `is_background` to true rather than changing the details of the command.\n6. Dont include any newlines in the command.",
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  getShellLaunchConfig(command: string) {
+    return {
+      name: `MCP:Terminal_${this.terminalId++}`,
+      cwd: this.appConfig.workspaceDir,
+      args: ['-c', command],
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    if (args.require_user_approval) {
+      // FIXME: support approval
+    }
+
+    const terminalClient = await this.terminalController.createTerminalWithWidget({
+      config: this.getShellLaunchConfig(args.command),
+      closeWhenExited: false,
+    });
+
+    this.terminalController.showTerminalPanel();
+
+    const result: { type: string; text: string }[] = [];
+    const def = new Deferred<{ isError?: boolean; content: { type: string; text: string }[] }>();
+
+    terminalClient.onOutput((e) => {
+      result.push({
+        type: 'output',
+        text: e.data.toString(),
+      });
+    });
+
+    terminalClient.onExit((e) => {
+      const isError = e.code !== 0;
+      def.resolve({
+        isError,
+        content: result,
+      });
+
+      terminalClient.term.writeln(
+        `\n${color.italic}> Command ${args.command} executed successfully. Terminal will close in ${
+          3000 / 1000
+        } seconds.${color.reset}\n`,
+      );
+
+      setTimeout(() => {
+        terminalClient.dispose();
+        this.terminalView.removeWidget(terminalClient.id);
+      }, 3000);
+    });
+
+    return def.promise;
+  }
+}

package/src/browser/preferences/schema.ts

@@ -58,6 +58,66 @@ export const aiNativePreferenceSchema: PreferenceSchema = {
       type: 'boolean',
       default: false,
     },
+    [AINativeSettingSectionsId.LLMModelSelection]: {
+      type: 'string',
+      default: 'deepseek',
+      enum: ['deepseek', 'anthropic', 'openai'],
+      description: localize('preference.ai.native.llm.model.selection.description'),
+    },
+    [AINativeSettingSectionsId.DeepseekApiKey]: {
+      type: 'string',
+      default: '',
+      description: localize('preference.ai.native.deepseek.apiKey.description'),
+    },
+    [AINativeSettingSectionsId.AnthropicApiKey]: {
+      type: 'string',
+      default: '',
+      description: localize('preference.ai.native.anthropic.apiKey.description'),
+    },
+    [AINativeSettingSectionsId.OpenaiApiKey]: {
+      type: 'string',
+      default: '',
+      description: localize('preference.ai.native.openai.apiKey.description'),
+    },
+    [AINativeSettingSectionsId.OpenaiBaseURL]: {
+      type: 'string',
+      default: '',
+      description: localize('preference.ai.native.openai.baseURL.description'),
+    },
+    [AINativeSettingSectionsId.MCPServers]: {
+      type: 'array',
+      default: [],
+      description: localize('preference.ai.native.mcp.servers.description'),
+      items: {
+        type: 'object',
+        required: ['name', 'command', 'args'],
+        properties: {
+          name: {
+            type: 'string',
+            description: localize('preference.ai.native.mcp.servers.name.description'),
+          },
+          command: {
+            type: 'string',
+            description: localize('preference.ai.native.mcp.servers.command.description'),
+          },
+          args: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            description: localize('preference.ai.native.mcp.servers.args.description'),
+          },
+          env: {
+            type: 'object',
+            additionalProperties: {
+              type: 'string',
+            },
+            description: localize('preference.ai.native.mcp.servers.env.description'),
+            default: {},
+          },
+        },
+      },
+    },
     [AINativeSettingSectionsId.CodeEditsTyping]: {
       type: 'boolean',
       default: false,