@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/commandLinePresenter.d.ts

@@ -0,0 +1,41 @@
+import type { MaybePromise } from "@codingame/monaco-vscode-api/vscode/vs/base/common/async";
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+export interface ICommandLinePresenter {
+    /**
+     * Attempts to create a presentation for the given command line.
+     * Command line presenters allow displaying an extracted/transformed version
+     * of a command (e.g., Python code from `python -c "..."`) with appropriate
+     * syntax highlighting, while the actual command remains unchanged.
+     *
+     * @returns The presentation result if this presenter handles the command, undefined otherwise.
+     */
+    present(options: ICommandLinePresenterOptions): MaybePromise<ICommandLinePresenterResult | undefined>;
+}
+export interface ICommandLinePresenterOptions {
+    commandLine: ICommandLinePresentationInput;
+    shell: string;
+    os: OperatingSystem;
+}
+export interface ICommandLinePresentationInput {
+    original?: string;
+    forDisplay: string;
+}
+export interface ICommandLinePresenterResult {
+    /**
+     * The extracted/transformed command to display (e.g., the Python code).
+     */
+    commandLine: string;
+    /**
+     * The language ID for syntax highlighting (e.g., 'python').
+     */
+    language?: string;
+    /**
+     * A human-readable name for the language (e.g., 'Python') used in UI labels.
+     */
+    languageDisplayName?: string;
+    /**
+     *  Whether other presenters should still process the command line.
+     * Defaults to false - once a presenter handles a command, no further processing is done.
+     */
+    processOtherPresenters?: boolean;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/nodeCommandLinePresenter.d.ts

@@ -0,0 +1,19 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for Node.js inline commands (`node -e "..."`).
+ * Extracts the JavaScript code and sets up JavaScript syntax highlighting.
+ */
+export declare class NodeCommandLinePresenter implements ICommandLinePresenter {
+    present(options: ICommandLinePresenterOptions): ICommandLinePresenterResult | undefined;
+}
+/**
+ * Extracts the JavaScript code from a `node -e "..."` or `node -e '...'` command,
+ * returning the code with properly unescaped quotes.
+ *
+ * @param commandLine The full command line to parse
+ * @param shell The shell path (to determine quote escaping style)
+ * @param os The operating system
+ * @returns The extracted JavaScript code, or undefined if not a node -e/--eval command
+ */
+export declare function extractNodeCommand(commandLine: string, shell: string, os: OperatingSystem): string | undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/nodeCommandLinePresenter.js

@@ -0,0 +1,37 @@
+
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class NodeCommandLinePresenter {
+    present(options) {
+        const commandLine = options.commandLine.forDisplay;
+        const extractedNode = extractNodeCommand(commandLine, options.shell, options.os);
+        if (extractedNode) {
+            return {
+                commandLine: extractedNode,
+                language: 'javascript',
+                languageDisplayName: 'Node.js',
+            };
+        }
+        return undefined;
+    }
+}
+function extractNodeCommand(commandLine, shell, os) {
+    const doubleQuoteMatch = commandLine.match(/^node(?:js)?\s+(?:-e|--eval)\s+"(?<code>.+)"$/s);
+    if (doubleQuoteMatch?.groups?.code) {
+        let jsCode = doubleQuoteMatch.groups.code.trim();
+        if (isPowerShell(shell, os)) {
+            jsCode = jsCode.replace(/`"/g, '"');
+        }
+        else {
+            jsCode = jsCode.replace(/\\"/g, '"');
+        }
+        return jsCode;
+    }
+    const singleQuoteMatch = commandLine.match(/^node(?:js)?\s+(?:-e|--eval)\s+'(?<code>.+)'$/s);
+    if (singleQuoteMatch?.groups?.code) {
+        return singleQuoteMatch.groups.code.trim();
+    }
+    return undefined;
+}
+
+export { NodeCommandLinePresenter, extractNodeCommand };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/pythonCommandLinePresenter.d.ts

@@ -0,0 +1,19 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for Python inline commands (`python -c "..."`).
+ * Extracts the Python code and sets up Python syntax highlighting.
+ */
+export declare class PythonCommandLinePresenter implements ICommandLinePresenter {
+    present(options: ICommandLinePresenterOptions): ICommandLinePresenterResult | undefined;
+}
+/**
+ * Extracts the Python code from a `python -c "..."` or `python -c '...'` command,
+ * returning the code with properly unescaped quotes.
+ *
+ * @param commandLine The full command line to parse
+ * @param shell The shell path (to determine quote escaping style)
+ * @param os The operating system
+ * @returns The extracted Python code, or undefined if not a python -c command
+ */
+export declare function extractPythonCommand(commandLine: string, shell: string, os: OperatingSystem): string | undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/pythonCommandLinePresenter.js

@@ -0,0 +1,37 @@
+
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class PythonCommandLinePresenter {
+    present(options) {
+        const commandLine = options.commandLine.forDisplay;
+        const extractedPython = extractPythonCommand(commandLine, options.shell, options.os);
+        if (extractedPython) {
+            return {
+                commandLine: extractedPython,
+                language: 'python',
+                languageDisplayName: 'Python',
+            };
+        }
+        return undefined;
+    }
+}
+function extractPythonCommand(commandLine, shell, os) {
+    const doubleQuoteMatch = commandLine.match(/^python(?:3)?\s+-c\s+"(?<python>.+)"$/s);
+    if (doubleQuoteMatch?.groups?.python) {
+        let pythonCode = doubleQuoteMatch.groups.python.trim();
+        if (isPowerShell(shell, os)) {
+            pythonCode = pythonCode.replace(/`"/g, '"');
+        }
+        else {
+            pythonCode = pythonCode.replace(/\\"/g, '"');
+        }
+        return pythonCode;
+    }
+    const singleQuoteMatch = commandLine.match(/^python(?:3)?\s+-c\s+'(?<python>.+)'$/s);
+    if (singleQuoteMatch?.groups?.python) {
+        return singleQuoteMatch.groups.python.trim();
+    }
+    return undefined;
+}
+
+export { PythonCommandLinePresenter, extractPythonCommand };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/rubyCommandLinePresenter.d.ts

@@ -0,0 +1,19 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for Ruby inline commands (`ruby -e "..."`).
+ * Extracts the Ruby code and sets up Ruby syntax highlighting.
+ */
+export declare class RubyCommandLinePresenter implements ICommandLinePresenter {
+    present(options: ICommandLinePresenterOptions): ICommandLinePresenterResult | undefined;
+}
+/**
+ * Extracts the Ruby code from a `ruby -e "..."` or `ruby -e '...'` command,
+ * returning the code with properly unescaped quotes.
+ *
+ * @param commandLine The full command line to parse
+ * @param shell The shell path (to determine quote escaping style)
+ * @param os The operating system
+ * @returns The extracted Ruby code, or undefined if not a ruby -e command
+ */
+export declare function extractRubyCommand(commandLine: string, shell: string, os: OperatingSystem): string | undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/rubyCommandLinePresenter.js

@@ -0,0 +1,44 @@
+
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class RubyCommandLinePresenter {
+    present(options) {
+        const commandLine = options.commandLine.forDisplay;
+        const extractedRuby = extractRubyCommand(commandLine, options.shell, options.os);
+        if (extractedRuby) {
+            return {
+                commandLine: extractedRuby,
+                language: 'ruby',
+                languageDisplayName: 'Ruby',
+            };
+        }
+        return undefined;
+    }
+}
+function extractRubyCommand(commandLine, shell, os) {
+    const doubleQuoteMatch = commandLine.match(/^ruby\s+-e\s+"(?<code>.+)"$/s);
+    if (doubleQuoteMatch?.groups?.code) {
+        let rubyCode = doubleQuoteMatch.groups.code.trim();
+        if (!rubyCode) {
+            return undefined;
+        }
+        if (isPowerShell(shell, os)) {
+            rubyCode = rubyCode.replace(/`"/g, '"');
+        }
+        else {
+            rubyCode = rubyCode.replace(/\\"/g, '"');
+        }
+        return rubyCode;
+    }
+    const singleQuoteMatch = commandLine.match(/^ruby\s+-e\s+'(?<code>.+)'$/s);
+    if (singleQuoteMatch?.groups?.code) {
+        const rubyCode = singleQuoteMatch.groups.code.trim();
+        if (!rubyCode) {
+            return undefined;
+        }
+        return rubyCode;
+    }
+    return undefined;
+}
+
+export { RubyCommandLinePresenter, extractRubyCommand };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/sandboxedCommandLinePresenter.d.ts

@@ -0,0 +1,12 @@
+import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for sandboxed commands.
+ * Extracts the original command from the sandbox wrapper for cleaner display,
+ * while the actual sandboxed command runs unchanged.
+ */
+export declare class SandboxedCommandLinePresenter implements ICommandLinePresenter {
+    private readonly _sandboxService;
+    constructor(_sandboxService: ITerminalSandboxService);
+    present(options: ICommandLinePresenterOptions): Promise<ICommandLinePresenterResult | undefined>;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLinePresenter/sandboxedCommandLinePresenter.js

@@ -0,0 +1,21 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
+
+let SandboxedCommandLinePresenter = class SandboxedCommandLinePresenter {
+    constructor(_sandboxService) {
+        this._sandboxService = _sandboxService;
+    }
+    async present(options) {
+        if (!(await this._sandboxService.isEnabled())) {
+            return undefined;
+        }
+        return {
+            commandLine: options.commandLine.original ?? options.commandLine.forDisplay,
+            processOtherPresenters: true
+        };
+    }
+};
+SandboxedCommandLinePresenter = ( __decorate([( __param(0, ITerminalSandboxService))], SandboxedCommandLinePresenter));
+
+export { SandboxedCommandLinePresenter };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineCdPrefixRewriter.js

@@ -1,32 +1,23 @@
 
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { isPowerShell } from '../../runInTerminalHelpers.js';
+import { extractCdPrefix } from '../../runInTerminalHelpers.js';
 
 class CommandLineCdPrefixRewriter extends Disposable {
     rewrite(options) {
         if (!options.cwd) {
             return undefined;
         }
-        const isPwsh = isPowerShell(options.shell, options.os);
-        const cdPrefixMatch = options.commandLine.match(isPwsh
-            ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i
-            : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/);
-        const cdDir = cdPrefixMatch?.groups?.dir;
-        const cdSuffix = cdPrefixMatch?.groups?.suffix;
-        if (cdDir && cdSuffix) {
-            let cdDirPath = cdDir;
-            if (cdDirPath.startsWith('"') && cdDirPath.endsWith('"')) {
-                cdDirPath = cdDirPath.slice(1, -1);
-            }
-            cdDirPath = cdDirPath.replace(/(?:[\\\/])$/, '');
+        const extracted = extractCdPrefix(options.commandLine, options.shell, options.os);
+        if (extracted) {
+            let cdDirPath = extracted.directory.replace(/(?:[\\\/])$/, '');
             let cwdFsPath = options.cwd.fsPath.replace(/(?:[\\\/])$/, '');
             if (options.os === OperatingSystem.Windows) {
                 cdDirPath = cdDirPath.toLowerCase();
                 cwdFsPath = cwdFsPath.toLowerCase();
             }
             if (cdDirPath === cwdFsPath) {
-                return { rewritten: cdSuffix, reasoning: 'Removed redundant cd command' };
+                return { rewritten: extracted.command, reasoning: 'Removed redundant cd command' };
             }
         }
         return undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLinePreventHistoryRewriter.js

@@ -18,14 +18,12 @@ let CommandLinePreventHistoryRewriter = class CommandLinePreventHistoryRewriter
         if (isBash(options.shell, options.os) || isZsh(options.shell, options.os)) {
             return {
                 rewritten: ` ${options.commandLine}`,
-                reasoning: 'Prepended with a space to exclude from shell history'
+                reasoning: "Prepended with a space to exclude from shell history"
             };
         }
         return undefined;
     }
 };
-CommandLinePreventHistoryRewriter = ( __decorate([
-    ( __param(0, IConfigurationService))
-], CommandLinePreventHistoryRewriter));
+CommandLinePreventHistoryRewriter = ( __decorate([( __param(0, IConfigurationService))], CommandLinePreventHistoryRewriter));
 
 export { CommandLinePreventHistoryRewriter };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineRewriter.d.ts

@@ -14,4 +14,5 @@ export interface ICommandLineRewriterOptions {
 export interface ICommandLineRewriterResult {
     rewritten: string;
     reasoning: string;
+    forDisplay?: string;
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineSandboxRewriter.d.ts

@@ -0,0 +1,8 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service";
+import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
+export declare class CommandLineSandboxRewriter extends Disposable implements ICommandLineRewriter {
+    private readonly _sandboxService;
+    constructor(_sandboxService: ITerminalSandboxService);
+    rewrite(options: ICommandLineRewriterOptions): Promise<ICommandLineRewriterResult | undefined>;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineSandboxRewriter.js

@@ -0,0 +1,29 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
+
+let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Disposable {
+    constructor(_sandboxService) {
+        super();
+        this._sandboxService = _sandboxService;
+    }
+    async rewrite(options) {
+        if (!(await this._sandboxService.isEnabled())) {
+            return undefined;
+        }
+        const sandboxConfigPath = await this._sandboxService.getSandboxConfigPath();
+        if (!sandboxConfigPath) {
+            return undefined;
+        }
+        const wrappedCommand = this._sandboxService.wrapCommand(options.commandLine);
+        return {
+            rewritten: wrappedCommand,
+            reasoning: "Wrapped command for sandbox execution",
+            forDisplay: options.commandLine
+        };
+    }
+};
+CommandLineSandboxRewriter = ( __decorate([( __param(0, ITerminalSandboxService))], CommandLineSandboxRewriter));
+
+export { CommandLineSandboxRewriter };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/getTerminalLastCommandTool.js

@@ -6,15 +6,16 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { TerminalToolId } from './toolIds.js';
 
 const GetTerminalLastCommandToolData = {
-    id: 'terminal_last_command',
-    toolReferenceName: 'terminalLastCommand',
-    legacyToolReferenceFullNames: ['runCommands/terminalLastCommand'],
-    displayName: ( localize(12036, 'Get Terminal Last Command')),
-    modelDescription: 'Get the last command run in the active terminal.',
+    id: TerminalToolId.TerminalLastCommand,
+    toolReferenceName: "terminalLastCommand",
+    legacyToolReferenceFullNames: ["runCommands/terminalLastCommand"],
+    displayName: ( localize(12367, "Get Terminal Last Command")),
+    modelDescription: "Get the last command run in the active terminal.",
     source: ToolDataSource.Internal,
-    icon: Codicon.terminal,
+    icon: Codicon.terminal
 };
 let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Disposable {
     constructor(_terminalService) {
@@ -23,8 +24,8 @@ let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Dispos
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(12037, "Getting last terminal command")),
-            pastTenseMessage: ( localize(12038, "Got last terminal command")),
+            invocationMessage: ( localize(12368, "Getting last terminal command")),
+            pastTenseMessage: ( localize(12369, "Got last terminal command"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -32,54 +33,54 @@ let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Dispos
         if (!activeInstance) {
             return {
                 content: [{
-                        kind: 'text',
-                        value: 'No active terminal instance found.'
-                    }]
+                    kind: "text",
+                    value: "No active terminal instance found."
+                }]
             };
         }
         const commandDetection = activeInstance.capabilities.get(TerminalCapability.CommandDetection);
         if (!commandDetection) {
             return {
                 content: [{
-                        kind: 'text',
-                        value: 'No command detection capability available in the active terminal.'
-                    }]
+                    kind: "text",
+                    value: "No command detection capability available in the active terminal."
+                }]
             };
         }
         const executingCommand = commandDetection.executingCommand;
         if (executingCommand) {
             const userPrompt = [];
-            userPrompt.push('The following command is currently executing in the terminal:');
+            userPrompt.push("The following command is currently executing in the terminal:");
             userPrompt.push(executingCommand);
             const cwd = commandDetection.cwd;
             if (cwd) {
-                userPrompt.push('It is running in the directory:');
+                userPrompt.push("It is running in the directory:");
                 userPrompt.push(cwd);
             }
             return {
                 content: [{
-                        kind: 'text',
-                        value: userPrompt.join('\n')
-                    }]
+                    kind: "text",
+                    value: userPrompt.join("\n")
+                }]
             };
         }
         const commands = commandDetection.commands;
         if (!commands || commands.length === 0) {
             return {
                 content: [{
-                        kind: 'text',
-                        value: 'No command has been run in the active terminal.'
-                    }]
+                    kind: "text",
+                    value: "No command has been run in the active terminal."
+                }]
             };
         }
         const lastCommand = commands[commands.length - 1];
         const userPrompt = [];
         if (lastCommand.command) {
-            userPrompt.push('The following is the last command run in the terminal:');
+            userPrompt.push("The following is the last command run in the terminal:");
             userPrompt.push(lastCommand.command);
         }
         if (lastCommand.cwd) {
-            userPrompt.push('It was run in the directory:');
+            userPrompt.push("It was run in the directory:");
             userPrompt.push(lastCommand.cwd);
         }
         if (lastCommand.exitCode !== undefined) {
@@ -88,20 +89,18 @@ let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Dispos
         if (lastCommand.hasOutput() && lastCommand.getOutput) {
             const output = lastCommand.getOutput();
             if (output && output.trim().length > 0) {
-                userPrompt.push('It has the following output:');
+                userPrompt.push("It has the following output:");
                 userPrompt.push(output);
             }
         }
         return {
             content: [{
-                    kind: 'text',
-                    value: userPrompt.join('\n')
-                }]
+                kind: "text",
+                value: userPrompt.join("\n")
+            }]
         };
     }
 };
-GetTerminalLastCommandTool = ( __decorate([
-    ( __param(0, ITerminalService))
-], GetTerminalLastCommandTool));
+GetTerminalLastCommandTool = ( __decorate([( __param(0, ITerminalService))], GetTerminalLastCommandTool));
 
 export { GetTerminalLastCommandTool, GetTerminalLastCommandToolData };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/getTerminalOutputTool.js

@@ -4,42 +4,41 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { RunInTerminalTool } from './runInTerminalTool.js';
+import { TerminalToolId } from './toolIds.js';
 
 const GetTerminalOutputToolData = {
-    id: 'get_terminal_output',
-    toolReferenceName: 'getTerminalOutput',
-    legacyToolReferenceFullNames: ['runCommands/getTerminalOutput'],
-    displayName: ( localize(12039, 'Get Terminal Output')),
-    modelDescription: 'Get the output of a terminal command previously started with run_in_terminal',
+    id: TerminalToolId.GetTerminalOutput,
+    toolReferenceName: "getTerminalOutput",
+    legacyToolReferenceFullNames: ["runCommands/getTerminalOutput"],
+    displayName: ( localize(12370, "Get Terminal Output")),
+    modelDescription: `Get the output of a terminal command previously started with ${TerminalToolId.RunInTerminal}`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
     inputSchema: {
-        type: 'object',
+        type: "object",
         properties: {
             id: {
-                type: 'string',
-                description: 'The ID of the terminal to check.'
-            },
+                type: "string",
+                description: "The ID of the terminal to check."
+            }
         },
-        required: [
-            'id',
-        ]
+        required: ["id"]
     }
 };
 class GetTerminalOutputTool extends Disposable {
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(12040, "Checking background terminal output")),
-            pastTenseMessage: ( localize(12041, "Checked background terminal output")),
+            invocationMessage: ( localize(12371, "Checking background terminal output")),
+            pastTenseMessage: ( localize(12372, "Checked background terminal output"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const args = invocation.parameters;
         return {
             content: [{
-                    kind: 'text',
-                    value: `Output of terminal ${args.id}:\n${RunInTerminalTool.getBackgroundOutput(args.id)}`
-                }]
+                kind: "text",
+                value: `Output of terminal ${args.id}:\n${RunInTerminalTool.getBackgroundOutput(args.id)}`
+            }]
         };
     }
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/getTerminalSelectionTool.js

@@ -5,15 +5,16 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { TerminalToolId } from './toolIds.js';
 
 const GetTerminalSelectionToolData = {
-    id: 'terminal_selection',
-    toolReferenceName: 'terminalSelection',
-    legacyToolReferenceFullNames: ['runCommands/terminalSelection'],
-    displayName: ( localize(12042, 'Get Terminal Selection')),
-    modelDescription: 'Get the current selection in the active terminal.',
+    id: TerminalToolId.TerminalSelection,
+    toolReferenceName: "terminalSelection",
+    legacyToolReferenceFullNames: ["runCommands/terminalSelection"],
+    displayName: ( localize(12373, "Get Terminal Selection")),
+    modelDescription: "Get the current selection in the active terminal.",
     source: ToolDataSource.Internal,
-    icon: Codicon.terminal,
+    icon: Codicon.terminal
 };
 let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable {
     constructor(_terminalService) {
@@ -22,8 +23,8 @@ let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(12043, "Reading terminal selection")),
-            pastTenseMessage: ( localize(12044, "Read terminal selection")),
+            invocationMessage: ( localize(12374, "Reading terminal selection")),
+            pastTenseMessage: ( localize(12375, "Read terminal selection"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -31,30 +32,28 @@ let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable
         if (!activeInstance) {
             return {
                 content: [{
-                        kind: 'text',
-                        value: 'No active terminal instance found.'
-                    }]
+                    kind: "text",
+                    value: "No active terminal instance found."
+                }]
             };
         }
         const selection = activeInstance.selection;
         if (!selection) {
             return {
                 content: [{
-                        kind: 'text',
-                        value: 'No text is currently selected in the active terminal.'
-                    }]
+                    kind: "text",
+                    value: "No text is currently selected in the active terminal."
+                }]
             };
         }
         return {
             content: [{
-                    kind: 'text',
-                    value: `The active terminal's selection:\n${selection}`
-                }]
+                kind: "text",
+                value: `The active terminal's selection:\n${selection}`
+            }]
         };
     }
 };
-GetTerminalSelectionTool = ( __decorate([
-    ( __param(0, ITerminalService))
-], GetTerminalSelectionTool));
+GetTerminalSelectionTool = ( __decorate([( __param(0, ITerminalService))], GetTerminalSelectionTool));
 
 export { GetTerminalSelectionTool, GetTerminalSelectionToolData };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/killTerminalTool.d.ts

@@ -0,0 +1,11 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type CountTokensCallback, type IPreparedToolInvocation, type IToolData, type IToolImpl, type IToolInvocation, type IToolInvocationPreparationContext, type IToolResult, type ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export declare const KillTerminalToolData: IToolData;
+export interface IKillTerminalInputParams {
+    id: string;
+}
+export declare class KillTerminalTool extends Disposable implements IToolImpl {
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}