@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -1,17 +1,20 @@
 
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 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';
+import { getOutput } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/outputHelpers';
+import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 const GetTerminalOutputToolData = {
     id: TerminalToolId.GetTerminalOutput,
     toolReferenceName: "getTerminalOutput",
     legacyToolReferenceFullNames: ["runCommands/getTerminalOutput"],
-    displayName: ( localize(13884, "Get Terminal Output")),
-    modelDescription: `Get the output of a background terminal command previously started with ${TerminalToolId.RunInTerminal}. The ID must be the exact opaque value returned by ${TerminalToolId.RunInTerminal} when isBackground=true; terminal names, labels, and integers are not valid IDs.`,
+    displayName: ( localize(14022, "Get Terminal Output")),
+    modelDescription: `Get output from a terminal session. This can target either a persistent terminal started with ${TerminalToolId.RunInTerminal} in async mode (using 'id') or any foreground terminal visible in the terminal panel (using 'terminalId'). For the 'id' parameter, this must be the exact opaque UUID returned by ${TerminalToolId.RunInTerminal}; terminal names, labels, and integers are not valid for 'id'.`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
     inputSchema: {
@@ -19,28 +22,61 @@ const GetTerminalOutputToolData = {
         properties: {
             id: {
                 type: "string",
-                description: `The ID of the background terminal to check (returned by ${TerminalToolId.RunInTerminal} when isBackground=true). This must be the exact opaque ID returned by that tool; terminal names, labels, or integers are invalid.`,
+                description: `The ID of a persistent terminal session to check (returned by ${TerminalToolId.RunInTerminal} in async mode). This must be the exact opaque ID returned by that tool; terminal names, labels, or integers are invalid. Provide either 'id' or 'terminalId', not both.`,
                 pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"
+            },
+            terminalId: {
+                type: "number",
+                description: "The numeric instanceId of a terminal. Use this to get output from terminals not started by the agent (e.g., user-created terminals or foreground terminals). Provide either 'id' or 'terminalId', not both."
             }
-        },
-        required: ["id"]
+        }
     }
 };
-class GetTerminalOutputTool extends Disposable {
+let GetTerminalOutputTool = class GetTerminalOutputTool extends Disposable {
+    constructor(_terminalService) {
+        super();
+        this._terminalService = _terminalService;
+    }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(13885, "Checking background terminal output")),
-            pastTenseMessage: ( localize(13886, "Checked background terminal output"))
+            invocationMessage: ( localize(14023, "Checking terminal output")),
+            pastTenseMessage: ( localize(14024, "Checked terminal output"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const args = invocation.parameters;
+        if (!args.id && args.terminalId === undefined) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: Either 'id' (persistent terminal UUID) or 'terminalId' (foreground terminal instanceId) must be provided."
+                }]
+            };
+        }
+        if (args.terminalId !== undefined && !args.id) {
+            const instance = this._terminalService.getInstanceFromId(args.terminalId);
+            if (!instance) {
+                return {
+                    content: [{
+                        kind: "text",
+                        value: `Error: No terminal found with instanceId ${args.terminalId}. The terminal may have been closed.`
+                    }]
+                };
+            }
+            const output = getOutput(instance);
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Output of terminal ${args.terminalId}:\n${output}`
+                }]
+            };
+        }
         const execution = RunInTerminalTool.getExecution(args.id);
         if (!execution) {
             return {
                 content: [{
                     kind: "text",
-                    value: `Error: No active terminal execution found with ID ${args.id}. The ID must be the exact value returned by ${TerminalToolId.RunInTerminal} for a background command.`
+                    value: `Error: No active terminal execution found with ID ${args.id}. The ID must be the exact value returned by ${TerminalToolId.RunInTerminal} in async mode.`
                 }]
             };
         }
@@ -51,6 +87,7 @@ class GetTerminalOutputTool extends Disposable {
             }]
         };
     }
-}
+};
+GetTerminalOutputTool = ( __decorate([( __param(0, ITerminalService))], GetTerminalOutputTool));
 
 export { GetTerminalOutputTool, GetTerminalOutputToolData };

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

@@ -5,13 +5,13 @@ 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';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 const GetTerminalSelectionToolData = {
     id: TerminalToolId.TerminalSelection,
     toolReferenceName: "terminalSelection",
     legacyToolReferenceFullNames: ["runCommands/terminalSelection"],
-    displayName: ( localize(13887, "Get Terminal Selection")),
+    displayName: ( localize(14025, "Get Terminal Selection")),
     modelDescription: "Get the current selection in the active terminal.",
     source: ToolDataSource.Internal,
     icon: Codicon.terminal
@@ -23,8 +23,8 @@ let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(13888, "Reading terminal selection")),
-            pastTenseMessage: ( localize(13889, "Read terminal selection"))
+            invocationMessage: ( localize(14026, "Reading terminal selection")),
+            pastTenseMessage: ( localize(14027, "Read terminal selection"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {

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

@@ -3,14 +3,14 @@ import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codi
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 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';
+import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 const KillTerminalToolData = {
     id: TerminalToolId.KillTerminal,
     toolReferenceName: "killTerminal",
-    displayName: ( localize(13890, "Kill Terminal")),
-    modelDescription: `Kill a terminal by its ID. Use this to clean up terminals that are no longer needed (e.g., after stopping a server or when a long-running task completes). The terminal ID is returned by ${TerminalToolId.RunInTerminal} when isBackground=true.`,
+    displayName: ( localize(14028, "Kill Terminal")),
+    modelDescription: `Kill a terminal by its ID. Use this to clean up terminals that are no longer needed (e.g., after stopping a server or when a long-running task completes). The terminal ID is returned by ${TerminalToolId.RunInTerminal} in async mode (legacy: isBackground=true).`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
     inputSchema: {
@@ -18,7 +18,8 @@ const KillTerminalToolData = {
         properties: {
             id: {
                 type: "string",
-                description: `The ID of the background terminal to kill (returned by ${TerminalToolId.RunInTerminal} when isBackground=true).`
+                description: `The ID of the persistent terminal to kill (returned by ${TerminalToolId.RunInTerminal} in async mode).`,
+                pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"
             }
         },
         required: ["id"]
@@ -27,8 +28,8 @@ const KillTerminalToolData = {
 class KillTerminalTool extends Disposable {
     async prepareToolInvocation(_context, _token) {
         return {
-            invocationMessage: ( localize(13891, "Killing terminal")),
-            pastTenseMessage: ( localize(13892, "Killed terminal"))
+            invocationMessage: ( localize(14029, "Killing terminal")),
+            pastTenseMessage: ( localize(14030, "Killed terminal"))
         };
     }
     async invoke(invocation, _countTokens, _progress, _token) {
@@ -49,7 +50,7 @@ class KillTerminalTool extends Disposable {
         return {
             content: [{
                 kind: "text",
-                value: `Successfully killed background terminal ${args.id}. ${outputSummary}`
+                value: `Successfully killed persistent terminal ${args.id}. ${outputSummary}`
             }]
         };
     }

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

@@ -1,9 +1,9 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
-import { RunInTerminalTool } from "./runInTerminalTool.js";
+import { RunInTerminalTool } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool";
 export declare const ConfirmTerminalCommandToolData: IToolData;
 export declare class ConfirmTerminalCommandTool extends RunInTerminalTool {
-    get _enableCommandLineSandboxRewriting(): boolean;
+    protected get _enableCommandLineSandboxRewriting(): boolean;
     prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
 }

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

@@ -2,12 +2,12 @@
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { RunInTerminalTool } from './runInTerminalTool.js';
-import { TerminalToolId } from './toolIds.js';
+import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 const ConfirmTerminalCommandToolData = {
     id: TerminalToolId.ConfirmTerminalCommand,
-    displayName: ( localize(13905, "Confirm Terminal Command")),
+    displayName: ( localize(14036, "Confirm Terminal Command")),
     modelDescription: [
         "This tool allows you to get explicit user confirmation for a terminal command without executing it.",
         "",
@@ -25,7 +25,7 @@ const ConfirmTerminalCommandToolData = {
         "",
         "After confirmation, use a tool to actually execute the command."
     ].join("\n"),
-    userDescription: ( localize(13906, "Tool for confirming terminal commands")),
+    userDescription: ( localize(14037, "Tool for confirming terminal commands")),
     source: ToolDataSource.Internal,
     icon: Codicon.shield,
     inputSchema: {
@@ -39,12 +39,17 @@ const ConfirmTerminalCommandToolData = {
                 type: "string",
                 description: "A one-sentence description of what the command does. This will be shown to the user in the confirmation dialog."
             },
-            isBackground: {
-                type: "boolean",
-                description: "Whether the command would start a background process. This provides context for the confirmation."
+            goal: {
+                type: "string",
+                description: "A short description of the goal or purpose of the command."
+            },
+            mode: {
+                type: "string",
+                enum: ["sync", "async"],
+                description: "Execution mode this command would use if run."
             }
         },
-        required: ["command", "explanation", "isBackground"]
+        required: ["command", "explanation", "goal", "mode"]
     }
 };
 class ConfirmTerminalCommandTool extends RunInTerminalTool {

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

@@ -0,0 +1,53 @@
+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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+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";
+import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+export declare const SendToTerminalToolData: IToolData;
+export interface ISendToTerminalInputParams {
+    id?: string;
+    terminalId?: number;
+    command: string;
+}
+export declare class SendToTerminalTool extends Disposable implements IToolImpl {
+    private readonly _configurationService;
+    private readonly _chatService;
+    private readonly _chatWidgetService;
+    private readonly _terminalChatService;
+    private readonly _terminalService;
+    constructor(_configurationService: IConfigurationService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _terminalChatService: ITerminalChatService, _terminalService: ITerminalService);
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    /**
+     * Returns a human-friendly label for the target terminal, using the
+     * terminal instance title (which reflects the running process) instead
+     * of the raw UUID or numeric id.
+     */
+    private _getTerminalLabel;
+    /**
+     * Returns the numeric terminal instanceId for the target terminal, used
+     * to build command URIs for the "Focus Terminal" link.
+     */
+    private _getTerminalInstanceId;
+    /**
+     * Searches the current session's responses for the most recent question
+     * carousel associated with the target terminal, then uses positional
+     * matching to return the specific question that this send_to_terminal
+     * call is answering.
+     *
+     * When a carousel contains multiple questions, the model calls
+     * send_to_terminal once per answer in order. This method counts prior
+     * send_to_terminal invocations since the carousel to determine the
+     * current question index, then verifies the command matches the answer
+     * at that position.
+     */
+    private _getQuestionContextForTerminal;
+    private _getQuestionText;
+    /**
+     * Checks whether a carousel answer value matches the command text being sent.
+     */
+    private _answerMatchesCommand;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,319 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { MarkdownString, appendEscapedMarkdownInlineCode, createCommandUri, isMarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ITerminalService, ITerminalChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { getOutput } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/outputHelpers';
+import { buildCommandDisplayText, normalizeCommandForExecution } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers';
+import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { isSessionAutoApproveLevel } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/terminalToolAutoApprove';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
+
+const SendToTerminalToolData = {
+    id: TerminalToolId.SendToTerminal,
+    toolReferenceName: "sendToTerminal",
+    displayName: ( localize(14081, "Send to Terminal")),
+    modelDescription: `Send input text to a terminal session. This can target either a persistent terminal started with ${TerminalToolId.RunInTerminal} in async mode (using 'id') or any foreground terminal visible in the terminal panel (using 'terminalId'). The 'command' field may be empty or whitespace to press Enter (useful for interactive prompts). The result includes the last few lines of terminal output captured shortly after sending.`,
+    icon: Codicon.terminal,
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: `The ID of a persistent terminal session to send a command to (returned by ${TerminalToolId.RunInTerminal} in async mode). Provide either 'id' or 'terminalId', not both.`,
+                pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"
+            },
+            terminalId: {
+                type: "number",
+                description: "The numeric instanceId of a terminal. Use this to send input to terminals not started by the agent (e.g., user-created terminals or terminals that need interactive input). Provide either 'id' or 'terminalId', not both."
+            },
+            command: {
+                type: "string",
+                description: "The input text to send to the terminal. The text is sent followed by Enter. Provide an empty or whitespace string to send just Enter (for interactive prompts)."
+            }
+        },
+        required: ["command"]
+    }
+};
+const FocusTerminalByIdCommandId = "workbench.action.terminal.chat.focusTerminalById";
+CommandsRegistry.registerCommand(FocusTerminalByIdCommandId, async (accessor, instanceId) => {
+    const terminalService = accessor.get(ITerminalService);
+    const instance = terminalService.getInstanceFromId(instanceId);
+    if (instance) {
+        terminalService.setActiveInstance(instance);
+        await terminalService.revealActiveTerminal();
+        instance.focus();
+    }
+});
+const FocusTerminalByExecutionIdCommandId = "workbench.action.terminal.chat.focusTerminalByExecutionId";
+CommandsRegistry.registerCommand(FocusTerminalByExecutionIdCommandId, async (accessor, executionId) => {
+    const execution = RunInTerminalTool.getExecution(executionId);
+    if (execution) {
+        const terminalService = accessor.get(ITerminalService);
+        terminalService.setActiveInstance(execution.instance);
+        await terminalService.revealActiveTerminal();
+        execution.instance.focus();
+    }
+});
+let SendToTerminalTool = class SendToTerminalTool extends Disposable {
+    constructor(
+        _configurationService,
+        _chatService,
+        _chatWidgetService,
+        _terminalChatService,
+        _terminalService
+    ) {
+        super();
+        this._configurationService = _configurationService;
+        this._chatService = _chatService;
+        this._chatWidgetService = _chatWidgetService;
+        this._terminalChatService = _terminalChatService;
+        this._terminalService = _terminalService;
+    }
+    async prepareToolInvocation(context, _token) {
+        const args = context.parameters;
+        const isEmptyInput = !args.command || !args.command.trim();
+        const terminalLabel = this._getTerminalLabel(args);
+        const invocationMessage = ( new MarkdownString());
+        const pastTenseMessage = ( new MarkdownString());
+        const questionText = this._getQuestionContextForTerminal(context.chatSessionResource, args);
+        if (isEmptyInput) {
+            invocationMessage.appendMarkdown(( localize(14082, "Pressing `Enter` in terminal")));
+            pastTenseMessage.appendMarkdown(( localize(14083, "Pressed `Enter` in terminal")));
+        } else {
+            const displayCommand = buildCommandDisplayText(args.command);
+            const safeInlineCode = appendEscapedMarkdownInlineCode(displayCommand);
+            invocationMessage.appendMarkdown(( localize(14084, "Sending {0} to terminal", safeInlineCode)));
+            pastTenseMessage.appendMarkdown(( localize(14085, "Sent {0} to terminal", safeInlineCode)));
+        }
+        if (questionText) {
+            const replyPrefix = ` (${( localize(14086, "replying to: "))}`;
+            invocationMessage.appendMarkdown(replyPrefix);
+            invocationMessage.appendText(questionText);
+            invocationMessage.appendMarkdown(")");
+            pastTenseMessage.appendMarkdown(replyPrefix);
+            pastTenseMessage.appendText(questionText);
+            pastTenseMessage.appendMarkdown(")");
+        }
+        const instanceId = this._getTerminalInstanceId(args);
+        const confirmationMessage = ( new MarkdownString("", {
+            isTrusted: {
+                enabledCommands: [FocusTerminalByIdCommandId]
+            }
+        }));
+        const safeTerminalLabel = appendEscapedMarkdownInlineCode(terminalLabel);
+        const baseMessage = isEmptyInput ? ( localize(14087, "Press `Enter` in terminal {0}", safeTerminalLabel)) : ( localize(
+            14088,
+            "Run {0} in terminal {1}",
+            appendEscapedMarkdownInlineCode(buildCommandDisplayText(args.command)),
+            safeTerminalLabel
+        ));
+        if (instanceId !== undefined) {
+            const focusUri = createCommandUri(FocusTerminalByIdCommandId, instanceId);
+            confirmationMessage.appendMarkdown(`${baseMessage} — [${( localize(14089, "Focus Terminal"))}](${focusUri})`);
+        } else {
+            confirmationMessage.appendMarkdown(baseMessage);
+        }
+        const chatSessionResource = context.chatSessionResource;
+        const isSessionAutoApproved = chatSessionResource && (isSessionAutoApproveLevel(
+            chatSessionResource,
+            this._configurationService,
+            this._chatWidgetService,
+            this._chatService
+        ) || this._terminalChatService.hasChatSessionAutoApproval(chatSessionResource));
+        const isAnsweringQuestion = questionText !== undefined;
+        const shouldShowConfirmation = (!isSessionAutoApproved && !isAnsweringQuestion) || context.forceConfirmationReason !== undefined;
+        const confirmationMessages = shouldShowConfirmation ? {
+            title: ( localize(14090, "Send to Terminal")),
+            message: confirmationMessage,
+            allowAutoConfirm: undefined
+        } : undefined;
+        return {
+            invocationMessage,
+            pastTenseMessage,
+            confirmationMessages
+        };
+    }
+    _getTerminalLabel(args) {
+        if (args.id) {
+            const execution = RunInTerminalTool.getExecution(args.id);
+            if (execution) {
+                return execution.instance.title;
+            }
+        }
+        if (args.terminalId !== undefined) {
+            const instance = this._terminalService.getInstanceFromId(args.terminalId);
+            if (instance) {
+                return instance.title;
+            }
+        }
+        return args.id ?? String(args.terminalId ?? "");
+    }
+    _getTerminalInstanceId(args) {
+        if (args.terminalId !== undefined) {
+            return args.terminalId;
+        }
+        if (args.id) {
+            const execution = RunInTerminalTool.getExecution(args.id);
+            if (execution) {
+                return execution.instance.instanceId;
+            }
+        }
+        return undefined;
+    }
+    _getQuestionContextForTerminal(chatSessionResource, args) {
+        if (!chatSessionResource) {
+            return undefined;
+        }
+        const model = this._chatService.getSession(chatSessionResource);
+        if (!model) {
+            return undefined;
+        }
+        if (!args.id && args.terminalId === undefined) {
+            return undefined;
+        }
+        const commandText = args.command?.trim();
+        const requests = model.getRequests();
+        for (let i = requests.length - 1; i >= 0; i--) {
+            const response = requests[i].response;
+            if (!response) {
+                continue;
+            }
+            const parts = response.response.value;
+            let carouselIndex = -1;
+            let carousel;
+            for (let j = parts.length - 1; j >= 0; j--) {
+                const part = parts[j];
+                if (part.kind === "questionCarousel") {
+                    const candidate = part;
+                    if (!candidate.terminalId || candidate.questions.length === 0) {
+                        continue;
+                    }
+                    const matchesById = !!args.id && candidate.terminalId === args.id;
+                    const matchesByInstanceId = args.terminalId !== undefined && RunInTerminalTool.getExecution(candidate.terminalId)?.instance.instanceId === args.terminalId;
+                    if (matchesById || matchesByInstanceId) {
+                        carouselIndex = j;
+                        carousel = candidate;
+                        break;
+                    }
+                }
+            }
+            if (!carousel || carouselIndex === -1) {
+                continue;
+            }
+            let sendCount = 0;
+            for (let j = carouselIndex + 1; j < parts.length; j++) {
+                if (parts[j].kind === "toolInvocation" && parts[j].toolId === TerminalToolId.SendToTerminal) {
+                    sendCount++;
+                }
+            }
+            const questionIndex = sendCount;
+            if (questionIndex >= carousel.questions.length) {
+                return undefined;
+            }
+            const question = carousel.questions[questionIndex];
+            if (carousel.data) {
+                const answer = carousel.data[question.id];
+                if (this._answerMatchesCommand(answer, commandText)) {
+                    return this._getQuestionText(question);
+                }
+            }
+            return undefined;
+        }
+        return undefined;
+    }
+    _getQuestionText(question) {
+        const text = question.message ?? question.title;
+        return isMarkdownString(text) ? text.value : text;
+    }
+    _answerMatchesCommand(answer, commandText) {
+        if (answer === undefined) {
+            return false;
+        }
+        if (typeof answer === "string") {
+            return answer.trim() === commandText;
+        }
+        if (hasKey(answer, {
+            selectedValues: true
+        })) {
+            const multi = answer;
+            if (( multi.selectedValues.some(v => v.trim() === commandText))) {
+                return true;
+            }
+            return multi.freeformValue?.trim() === commandText;
+        }
+        if (hasKey(answer, {
+            selectedValue: true
+        })) {
+            const single = answer;
+            return single.selectedValue?.trim() === commandText || single.freeformValue?.trim() === commandText;
+        }
+        return false;
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const args = invocation.parameters;
+        if (!args.id && args.terminalId === undefined) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: Either 'id' (persistent terminal UUID) or 'terminalId' (foreground terminal instanceId) must be provided."
+                }]
+            };
+        }
+        if (args.terminalId !== undefined && !args.id) {
+            const instance = this._terminalService.getInstanceFromId(args.terminalId);
+            if (!instance) {
+                return {
+                    content: [{
+                        kind: "text",
+                        value: `Error: No terminal found with instanceId ${args.terminalId}. The terminal may have been closed.`
+                    }]
+                };
+            }
+            await instance.sendText(normalizeCommandForExecution(args.command), true);
+            await timeout(100);
+            const recentOutput = getOutput(instance, undefined, {
+                lastNLines: 5
+            });
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Successfully sent command to foreground terminal ${args.terminalId}.${recentOutput ? `\n\nTerminal output (last 5 lines):\n${recentOutput}` : ""}`
+                }]
+            };
+        }
+        const execution = RunInTerminalTool.getExecution(args.id);
+        if (!execution) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Error: No active terminal execution found with ID ${args.id}. The terminal may have already been killed or the ID is invalid. The ID must be the exact value returned by ${TerminalToolId.RunInTerminal}.`
+                }]
+            };
+        }
+        await execution.instance.sendText(normalizeCommandForExecution(args.command), true);
+        await timeout(100);
+        const recentOutput = getOutput(execution.instance, undefined, {
+            lastNLines: 5
+        });
+        return {
+            content: [{
+                kind: "text",
+                value: `Successfully sent command to terminal ${args.id}.${recentOutput ? `\n\nTerminal output (last 5 lines):\n${recentOutput}` : ""}`
+            }]
+        };
+    }
+};
+SendToTerminalTool = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IChatService)), ( __param(2, IChatWidgetService)), ( __param(3, ITerminalChatService)), ( __param(4, ITerminalService))], SendToTerminalTool));
+
+export { SendToTerminalTool, SendToTerminalToolData };