@codingame/monaco-vscode-katex-common 30.0.0 → 31.0.0

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

@@ -0,0 +1,2258 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString, escapeMarkdownSyntaxTokens } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, MutableDisposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { getMediaMime } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename, win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { count } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { isNumber, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { TerminalToolConfirmationStorageKeys } from '../../../../chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
+import { ElicitationState, ChatRequestQueueKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { LanguageModelPartAudience } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ChatModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { ChatElicitationRequestPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatElicitationRequestPart';
+import { ChatQuestionCarouselData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatQuestionCarouselData';
+import { LocalChatSessionUri, chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { ITerminalChatService, ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { ITerminalProfileResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
+import { TerminalChatCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import '../../common/terminalSandboxService.js';
+import { getRecommendedToolsOverRunInTerminal } from '../alternativeRecommendation.js';
+import { BasicExecuteStrategy } from '../executeStrategy/basicExecuteStrategy.js';
+import { NoneExecuteStrategy } from '../executeStrategy/noneExecuteStrategy.js';
+import { RichExecuteStrategy } from '../executeStrategy/richExecuteStrategy.js';
+import { getOutput } from '../outputHelpers.js';
+import { isWindowsPowerShell, isPowerShell, isZsh, isFish, buildCommandDisplayText, normalizeTerminalCommandForDisplay, extractCdPrefix } from '../runInTerminalHelpers.js';
+import { RunInTerminalToolTelemetry } from '../runInTerminalToolTelemetry.js';
+import { ToolTerminalCreator, ShellIntegrationQuality } from '../toolTerminalCreator.js';
+import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../treeSitterCommandParser.js';
+import { CommandLineAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineAutoApproveAnalyzer.js';
+import { CommandLineFileWriteAnalyzer } from './commandLineAnalyzer/commandLineFileWriteAnalyzer.js';
+import { CommandLineSandboxAnalyzer } from './commandLineAnalyzer/commandLineSandboxAnalyzer.js';
+import { NodeCommandLinePresenter } from './commandLinePresenter/nodeCommandLinePresenter.js';
+import { PythonCommandLinePresenter } from './commandLinePresenter/pythonCommandLinePresenter.js';
+import { RubyCommandLinePresenter } from './commandLinePresenter/rubyCommandLinePresenter.js';
+import { SandboxedCommandLinePresenter } from './commandLinePresenter/sandboxedCommandLinePresenter.js';
+import { CommandLineBackgroundDetachRewriter } from './commandLineRewriter/commandLineBackgroundDetachRewriter.js';
+import { CommandLineCdPrefixRewriter } from './commandLineRewriter/commandLineCdPrefixRewriter.js';
+import { CommandLinePreventHistoryRewriter } from './commandLineRewriter/commandLinePreventHistoryRewriter.js';
+import { CommandLinePwshChainOperatorRewriter } from './commandLineRewriter/commandLinePwshChainOperatorRewriter.js';
+import { CommandLineSandboxRewriter } from './commandLineRewriter/commandLineSandboxRewriter.js';
+import { OutputMonitor } from './monitoring/outputMonitor.js';
+import { OutputMonitorState } from './monitoring/types.js';
+import { outputLooksSandboxBlocked, SandboxOutputAnalyzer } from './sandboxOutputAnalyzer.js';
+import { TerminalCommandArtifactCollector } from './terminalCommandArtifactCollector.js';
+import { isToolEligibleForTerminalAutoApproval, isTerminalAutoApproveAllowed, isSessionAutoApproveLevel } from './terminalToolAutoApprove.js';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
+import { TerminalSandboxPrerequisiteCheck } from '../../../../../../platform/sandbox/common/terminalSandboxService.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+
+var RunInTerminalTool_1;
+const TERMINAL_SANDBOX_DOCUMENTATION_URL = "https://aka.ms/vscode-sandboxing";
+const TOOL_REFERENCE_NAME = "runInTerminal";
+const LEGACY_TOOL_REFERENCE_FULL_NAMES = ["runCommands/runInTerminal"];
+const INPUT_NEEDED_NOTIFICATION_THROTTLE_MS = 5000;
+function createPowerShellModelDescription(shell, isSandboxEnabled, networkDomains) {
+    const isWinPwsh = isWindowsPowerShell(shell);
+    const parts = [
+        `This tool allows you to execute ${isWinPwsh ? "Windows PowerShell 5.1" : "PowerShell"} commands in a persistent terminal session, preserving environment variables, working directory, and other context across multiple commands.`,
+        "",
+        "Command Execution:",
+        isWinPwsh ? "- Use semicolons ; to chain commands on one line, NEVER use && even when asked explicitly" : "- Prefer ; when chaining commands on one line",
+        "- Prefer pipelines | for object-based data flow",
+        "- Never create a sub-shell (eg. powershell -c \"command\") unless explicitly asked",
+        "",
+        "Directory Management:",
+        "- Prefer relative paths when navigating directories, only use absolute when the path is far away or the current cwd is not expected",
+        "- By default (mode=sync), shell and cwd are reused by subsequent sync commands",
+        "- Use $PWD or Get-Location for current directory",
+        "- Use Push-Location/Pop-Location for directory stack",
+        "",
+        "Program Execution:",
+        "- Supports .NET, Python, Node.js, and other executables",
+        "- Install modules via Install-Module, Install-Package",
+        "- Use Get-Command to verify cmdlet/function availability",
+        "",
+        "Async Mode:",
+        "- For long-running tasks (e.g., servers), use mode=async",
+        "- Returns a terminal ID for checking status and runtime later",
+        "- Use Start-Job for background PowerShell jobs",
+        "",
+        `Use ${TerminalToolId.SendToTerminal} to send commands or input to a terminal session.`
+    ];
+    if (isSandboxEnabled) {
+        parts.push(...createSandboxLines(networkDomains));
+    }
+    parts.push(
+        "",
+        "Output Management:",
+        "- Output is automatically truncated if longer than 60KB to prevent context overflow",
+        "- Use Select-Object, Where-Object, Format-Table to filter output",
+        "- Use -First/-Last parameters to limit results",
+        "- For pager commands, add | Out-String or | Format-List",
+        "",
+        "Best Practices:",
+        "- Use proper cmdlet names instead of aliases in scripts",
+        "- Quote paths with spaces: \"C:\\Path With Spaces\"",
+        "- Prefer PowerShell cmdlets over external commands when available",
+        "- Prefer idiomatic PowerShell like Get-ChildItem instead of dir or ls for file listings",
+        "- Use Test-Path to check file/directory existence",
+        "- Be specific with Select-Object properties to avoid excessive output",
+        "- Avoid printing credentials unless absolutely required",
+        `- NEVER run Start-Sleep or similar wait commands. You will be automatically notified on your next turn when async terminal commands or timed-out sync commands complete or need input. Use ${TerminalToolId.GetTerminalOutput} to check output before then`,
+        "",
+        "Interactive Input Handling:",
+        "- When a terminal command is waiting for interactive input, do NOT suggest alternatives or ask the user whether to proceed. Instead, use the vscode_askQuestions tool to collect the needed values from the user, then send them.",
+        `- Send exactly one answer per prompt using ${TerminalToolId.SendToTerminal}. Never send multiple answers in a single send.`,
+        `- After each send, call ${TerminalToolId.GetTerminalOutput} to read the next prompt before sending the next answer.`,
+        "- Continue one prompt at a time until the command finishes."
+    );
+    return parts.join("\n");
+}
+function createSandboxLines(networkDomains) {
+    const lines = [
+        "",
+        "Sandboxing:",
+        "- ATTENTION: Terminal sandboxing is enabled, commands run in a sandbox by default",
+        "- When executing commands within the sandboxed environment, all operations requiring a temporary directory must utilize the $TMPDIR environment variable. The /tmp directory is not guaranteed to be accessible or writable and must be avoided",
+        "- Tools and scripts should respect the TMPDIR environment variable, which is automatically set to an appropriate path within the sandbox",
+        "- When a command fails due to sandbox restrictions, immediately re-run it with requestUnsandboxedExecution=true. Do NOT ask the user for permission — setting this flag automatically shows a confirmation prompt to the user",
+        "- Only set requestUnsandboxedExecution=true when there is evidence of failures caused by the sandbox, e.g. 'Operation not permitted' errors, network failures, or file access errors, etc",
+        "- Do NOT set requestUnsandboxedExecution=true without first executing the command in sandbox mode. Always try the command in the sandbox first, and only set requestUnsandboxedExecution=true when retrying after that sandboxed execution failed due to sandbox restrictions.",
+        "- When setting requestUnsandboxedExecution=true, also provide requestUnsandboxedExecutionReason explaining why the command needs unsandboxed access"
+    ];
+    if (networkDomains) {
+        const deniedSet = ( new Set(networkDomains.deniedDomains));
+        const effectiveAllowed = networkDomains.allowedDomains.filter(d => !( deniedSet.has(d)));
+        if (effectiveAllowed.length === 0) {
+            lines.push("- All network access is blocked in the sandbox");
+        } else {
+            lines.push(
+                `- Only the following domains are accessible in the sandbox (all other network access is blocked): ${effectiveAllowed.join(", ")}`
+            );
+        }
+        if (networkDomains.deniedDomains.length > 0) {
+            lines.push(
+                `- The following domains are explicitly blocked in the sandbox: ${networkDomains.deniedDomains.join(", ")}`
+            );
+        }
+    }
+    return lines;
+}
+function createGenericDescription(isSandboxEnabled, networkDomains) {
+    const parts = [`
+Command Execution:
+- Use && to chain simple commands on one line
+- Prefer pipelines | over temporary files for data flow
+- Never create a sub-shell (eg. bash -c "command") unless explicitly asked
+
+Directory Management:
+- Prefer relative paths when navigating directories, only use absolute when the path is far away or the current cwd is not expected
+- By default (mode=sync), shell and cwd are reused by subsequent sync commands
+- Use $PWD for current directory references
+- Consider using pushd/popd for directory stack management
+- Supports directory shortcuts like ~ and -
+
+Program Execution:
+- Supports Python, Node.js, and other executables
+- Install packages via package managers (brew, apt, etc.)
+- Use which or command -v to verify command availability
+
+Async Mode:
+- For long-running tasks (e.g., servers), use mode=async
+- Returns a terminal ID for checking status and runtime later
+
+Use ${TerminalToolId.SendToTerminal} to send commands or input to a terminal session.`];
+    if (isSandboxEnabled) {
+        parts.push(createSandboxLines(networkDomains).join("\n"));
+    }
+    parts.push(`
+
+Output Management:
+- Output is automatically truncated if longer than 60KB to prevent context overflow
+- Use head, tail, grep, awk to filter and limit output size
+- For pager commands, disable paging: git --no-pager or add | cat
+- Use wc -l to count lines before displaying large outputs
+
+Best Practices:
+- Quote variables: "$var" instead of $var to handle spaces
+- Use find with -exec or xargs for file operations
+- Be specific with commands to avoid excessive output
+- Avoid printing credentials unless absolutely required
+- NEVER run sleep or similar wait commands in a terminal. You will be automatically notified on your next turn when async terminal commands or timed-out sync commands complete or need input. Use ${TerminalToolId.GetTerminalOutput} to check output before then
+
+Interactive Input Handling:
+- When a terminal command is waiting for interactive input, do NOT suggest alternatives or ask the user whether to proceed. Instead, use the vscode_askQuestions tool to collect the needed values from the user, then send them.
+- Send exactly one answer per prompt using ${TerminalToolId.SendToTerminal}. Never send multiple answers in a single send.
+- After each send, call ${TerminalToolId.GetTerminalOutput} to read the next prompt before sending the next answer.
+- Continue one prompt at a time until the command finishes.`);
+    return parts.join("");
+}
+function createBashModelDescription(isSandboxEnabled, networkDomains) {
+    return [
+        "This tool allows you to execute shell commands in a persistent bash terminal session, preserving environment variables, working directory, and other context across multiple commands.",
+        createGenericDescription(isSandboxEnabled, networkDomains),
+        "- Use [[ ]] for conditional tests instead of [ ]",
+        "- Prefer $() over backticks for command substitution",
+        "- Use set -e at start of complex commands to exit on errors"
+    ].join("\n");
+}
+function createZshModelDescription(isSandboxEnabled, networkDomains) {
+    return [
+        "This tool allows you to execute shell commands in a persistent zsh terminal session, preserving environment variables, working directory, and other context across multiple commands.",
+        createGenericDescription(isSandboxEnabled, networkDomains),
+        "- Use type to check command type (builtin, function, alias)",
+        "- Use jobs, fg, bg for job control",
+        "- Use [[ ]] for conditional tests instead of [ ]",
+        "- Prefer $() over backticks for command substitution",
+        "- Use setopt errexit for strict error handling",
+        "- Take advantage of zsh globbing features (**, extended globs)"
+    ].join("\n");
+}
+function createFishModelDescription(isSandboxEnabled, networkDomains) {
+    return [
+        "This tool allows you to execute shell commands in a persistent fish terminal session, preserving environment variables, working directory, and other context across multiple commands.",
+        createGenericDescription(isSandboxEnabled, networkDomains),
+        "- Use type to check command type (builtin, function, alias)",
+        "- Use jobs, fg, bg for job control",
+        "- Use test expressions for conditionals (no [[ ]] syntax)",
+        "- Prefer command substitution with () syntax",
+        "- Variables are arrays by default, use $var[1] for first element",
+        "- Use set -e for strict error handling",
+        "- Take advantage of fish's autosuggestions and completions"
+    ].join("\n");
+}
+async function createRunInTerminalToolData(accessor) {
+    const instantiationService = accessor.get(IInstantiationService);
+    const terminalSandboxService = accessor.get(ITerminalSandboxService);
+    const profileFetcher = instantiationService.createInstance(TerminalProfileFetcher);
+    const [shell, os, isSandboxEnabled] = await Promise.all([
+        profileFetcher.getCopilotShell(),
+        profileFetcher.osBackend,
+        terminalSandboxService.isEnabled()
+    ]);
+    const networkDomains = isSandboxEnabled ? terminalSandboxService.getResolvedNetworkDomains() : undefined;
+    let modelDescription;
+    if (shell && os && isPowerShell(shell, os)) {
+        modelDescription = createPowerShellModelDescription(shell, isSandboxEnabled, networkDomains);
+    } else if (shell && os && isZsh(shell, os)) {
+        modelDescription = createZshModelDescription(isSandboxEnabled, networkDomains);
+    } else if (shell && os && isFish(shell, os)) {
+        modelDescription = createFishModelDescription(isSandboxEnabled, networkDomains);
+    } else {
+        modelDescription = createBashModelDescription(isSandboxEnabled, networkDomains);
+    }
+    const sharedProperties = {
+        command: {
+            type: "string",
+            description: "The command to run in the terminal."
+        },
+        explanation: {
+            type: "string",
+            description: "A one-sentence description of what the command does. This will be shown to the user before the command is run."
+        },
+        goal: {
+            type: "string",
+            description: "A short description of the goal or purpose of the command (e.g., \"Install dependencies\", \"Start development server\")."
+        }
+    };
+    const sandboxProperties = isSandboxEnabled ? {
+        requestUnsandboxedExecution: {
+            type: "boolean",
+            description: "Request that this command run outside the terminal sandbox. Only set this after first executing the command in sandbox and observing that sandboxing caused the failure. The user will be prompted before the command runs unsandboxed."
+        },
+        requestUnsandboxedExecutionReason: {
+            type: "string",
+            description: "A short explanation of the sandboxed execution failure or blocked-domain requirement that justifies retrying outside the sandbox. Only provide this when requestUnsandboxedExecution is true."
+        }
+    } : {};
+    return {
+        id: TerminalToolId.RunInTerminal,
+        toolReferenceName: TOOL_REFERENCE_NAME,
+        legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
+        displayName: ( localize(14038, "Run in Terminal")),
+        modelDescription: `${modelDescription}\n\nExecution mode:\n- mode='sync': wait for completion up to timeout; if still running, return with a terminal ID.\n- mode='async': wait for an initial idle/output signal, then return with terminal output snapshot and ID. Timeout caps how long to wait for the initial idle/output signal.\n- Prefer mode='sync' for commands that will prompt for interactive input (e.g., npm init, interactive installers, configuration wizards).\n\nTerminal notifications: When an async command finishes or a sync command times out, you will be automatically notified on your next turn with the exit code and terminal output. You will also be notified if the terminal needs input. Use ${TerminalToolId.GetTerminalOutput} to check output before then. Do NOT poll or sleep to wait for completion.`,
+        userDescription: ( localize(14039, "Run commands in the terminal")),
+        source: ToolDataSource.Internal,
+        icon: Codicon.terminal,
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...sharedProperties,
+                ...sandboxProperties,
+                mode: {
+                    type: "string",
+                    enum: ["sync", "async"],
+                    enumDescriptions: [
+                        "Wait for completion up to timeout, then return with collected output. If still running at timeout, the terminal session continues in the background.",
+                        "Wait for an initial idle/output signal, then return with a terminal ID and output snapshot while the session may continue running."
+                    ],
+                    description: "Execution mode for this command."
+                },
+                isBackground: {
+                    type: "boolean",
+                    description: "Legacy execution mode flag. Deprecated in favor of \"mode\". If true, equivalent to mode=async. If false, equivalent to mode=sync."
+                },
+                timeout: {
+                    type: "number",
+                    description: "Timeout in milliseconds that determines how long to wait before returning. Use 0 for no timeout."
+                }
+            },
+            required: ["command", "explanation", "goal", "mode", "timeout"]
+        }
+    };
+}
+var TerminalToolStorageKeysInternal;
+(function(TerminalToolStorageKeysInternal) {
+    TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
+})(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
+function shouldAutomaticallyRetryUnsandboxed(options) {
+    return options.didSandboxWrapCommand && options.requestUnsandboxedExecution !== true && !options.isPersistentSession && !options.isBackgroundExecution && !options.didTimeout && options.exitCode !== 0 && outputLooksSandboxBlocked(options.output);
+}
+const telemetryIgnoredSequences = [
+"\u001b[I",
+"\u001b[O"];
+const altBufferMessage = "\n" + ( localize(14040, "The command opened the alternate buffer."));
+let RunInTerminalTool = class RunInTerminalTool extends Disposable {
+    static {
+        RunInTerminalTool_1 = this;
+    }
+    static {
+        this._activeExecutions = ( new Map());
+    }
+    static getBackgroundOutput(id) {
+        const execution = RunInTerminalTool_1._activeExecutions.get(id);
+        if (!execution) {
+            throw ( new Error("Invalid terminal ID"));
+        }
+        return execution.getOutput();
+    }
+    static getExecution(id) {
+        return RunInTerminalTool_1._activeExecutions.get(id);
+    }
+    static removeExecution(id) {
+        const execution = RunInTerminalTool_1._activeExecutions.get(id);
+        if (!execution) {
+            return false;
+        }
+        execution.dispose();
+        RunInTerminalTool_1._activeExecutions.delete(id);
+        return true;
+    }
+    _resolveExecutionOptions(args) {
+        const mode = args.mode ?? (args.isBackground ? "async" : "sync");
+        switch (mode) {
+        case "async":
+            return {
+                mode: "async",
+                persistentSession: true,
+                waitStrategy: "idle"
+            };
+        case "sync":
+        default:
+            return {
+                mode: "sync",
+                persistentSession: false,
+                waitStrategy: "completion"
+            };
+        }
+    }
+    get _enableCommandLineSandboxRewriting() {
+        return true;
+    }
+    constructor(
+        _chatService,
+        _configurationService,
+        _fileService,
+        _historyService,
+        _instantiationService,
+        _labelService,
+        _languageModelToolsService,
+        _remoteAgentService,
+        _storageService,
+        _terminalChatService,
+        _logService,
+        _terminalService,
+        _terminalSandboxService,
+        _workspaceContextService,
+        _chatWidgetService,
+        _agentSessionsService
+    ) {
+        super();
+        this._chatService = _chatService;
+        this._configurationService = _configurationService;
+        this._fileService = _fileService;
+        this._historyService = _historyService;
+        this._instantiationService = _instantiationService;
+        this._labelService = _labelService;
+        this._languageModelToolsService = _languageModelToolsService;
+        this._remoteAgentService = _remoteAgentService;
+        this._storageService = _storageService;
+        this._terminalChatService = _terminalChatService;
+        this._logService = _logService;
+        this._terminalService = _terminalService;
+        this._terminalSandboxService = _terminalSandboxService;
+        this._workspaceContextService = _workspaceContextService;
+        this._chatWidgetService = _chatWidgetService;
+        this._agentSessionsService = _agentSessionsService;
+        this._archivedSessionListener = this._register(( new MutableDisposable()));
+        this._sessionTerminalAssociations = ( new ResourceMap());
+        this._sessionTerminalInstances = ( new ResourceMap());
+        this._terminalsBeingDisposedBySessionCleanup = ( new Set());
+        this._backgroundNotifications = this._register(( new DisposableMap()));
+        this._osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
+        this._terminalToolCreator = this._instantiationService.createInstance(ToolTerminalCreator);
+        this._treeSitterCommandParser = this._register(this._instantiationService.createInstance(TreeSitterCommandParser));
+        this._telemetry = this._instantiationService.createInstance(RunInTerminalToolTelemetry);
+        this._commandArtifactCollector = this._instantiationService.createInstance(TerminalCommandArtifactCollector);
+        this._profileFetcher = this._instantiationService.createInstance(TerminalProfileFetcher);
+        this._commandLineRewriters = [
+            this._register(this._instantiationService.createInstance(CommandLineCdPrefixRewriter)),
+            this._register(
+                this._instantiationService.createInstance(CommandLinePwshChainOperatorRewriter, this._treeSitterCommandParser)
+            )
+        ];
+        if (this._enableCommandLineSandboxRewriting) {
+            this._commandLineRewriters.push(
+                this._register(this._instantiationService.createInstance(CommandLineSandboxRewriter))
+            );
+        }
+        this._commandLineRewriters.push(this._register(
+            this._instantiationService.createInstance(CommandLineBackgroundDetachRewriter)
+        ));
+        this._commandLineRewriters.push(this._register(
+            this._instantiationService.createInstance(CommandLinePreventHistoryRewriter)
+        ));
+        this._commandLineAnalyzers = [this._register(this._instantiationService.createInstance(
+            CommandLineFileWriteAnalyzer,
+            this._treeSitterCommandParser,
+            (message, args) => this._logService.info(`RunInTerminalTool#CommandLineFileWriteAnalyzer: ${message}`, args)
+        )), this._register(this._instantiationService.createInstance(
+            CommandLineAutoApproveAnalyzer,
+            this._treeSitterCommandParser,
+            this._telemetry,
+            (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args)
+        ))];
+        if (this._enableCommandLineSandboxRewriting) {
+            this._commandLineAnalyzers.push(
+                this._register(this._instantiationService.createInstance(CommandLineSandboxAnalyzer))
+            );
+        }
+        this._commandLinePresenters = [
+            this._instantiationService.createInstance(SandboxedCommandLinePresenter),
+            ( new NodeCommandLinePresenter()),
+            ( new PythonCommandLinePresenter()),
+            ( new RubyCommandLinePresenter())
+        ];
+        this._outputAnalyzers = [
+            this._register(this._instantiationService.createInstance(SandboxOutputAnalyzer))
+        ];
+        this._register(
+            Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
+                if (!e || e.affectsConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove)) {
+                    if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) !== true) {
+                        this._storageService.remove(
+                            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
+                            StorageScope.APPLICATION
+                        );
+                    }
+                }
+            })
+        );
+        this._restoreTerminalAssociations();
+        this._register(this._terminalService.onDidDisposeInstance(e => {
+            this._removeTerminalAssociations(e);
+        }));
+        this._register(this._chatService.onDidDisposeSession(e => {
+            for (const resource of e.sessionResources) {
+                this._cleanupSessionTerminals(resource);
+            }
+        }));
+    }
+    async handleToolStream(context, _token) {
+        const partialInput = context.rawInput;
+        if (partialInput && typeof partialInput === "object" && partialInput.command) {
+            const truncatedCommand = buildCommandDisplayText(partialInput.command);
+            const invocationMessage = ( new MarkdownString(( localize(14041, "Running `{0}`", escapeMarkdownSyntaxTokens(truncatedCommand)))));
+            return {
+                invocationMessage
+            };
+        }
+        return {
+            invocationMessage: ( localize(14042, "Running command"))
+        };
+    }
+    async prepareToolInvocation(context, token) {
+        const args = context.parameters;
+        const executionOptions = this._resolveExecutionOptions(args);
+        const chatSessionResource = context.chatSessionResource;
+        let instance;
+        if (chatSessionResource) {
+            const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
+            if (toolTerminal && !toolTerminal.isBackground) {
+                instance = toolTerminal.instance;
+            }
+        }
+        const [os, shell, cwd, sandboxPrereqs] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
+            let cwd = await instance?.getCwdResource();
+            if (!cwd) {
+                const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
+                const workspaceFolder = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+                cwd = workspaceFolder?.uri;
+            }
+            return cwd;
+        })(), this._terminalSandboxService.checkForSandboxingPrereqs()]);
+        const language = os === OperatingSystem.Windows ? "pwsh" : "sh";
+        const isTerminalSandboxEnabled = sandboxPrereqs.enabled;
+        const explicitUnsandboxRequest = isTerminalSandboxEnabled && args.requestUnsandboxedExecution === true;
+        let requiresUnsandboxConfirmation = explicitUnsandboxRequest;
+        let requestUnsandboxedExecutionReason = explicitUnsandboxRequest ? args.requestUnsandboxedExecutionReason : undefined;
+        const missingDependencies = sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Dependencies && sandboxPrereqs.missingDependencies?.length ? sandboxPrereqs.missingDependencies : undefined;
+        const terminalToolSessionId = generateUuid();
+        const terminalCommandId = `tool-${generateUuid()}`;
+        const rewriteResult = await this._rewriteCommandLine(args.command, {
+            cwd,
+            shell,
+            os,
+            isBackground: executionOptions.persistentSession,
+            requestUnsandboxedExecution: requiresUnsandboxConfirmation,
+            requestUnsandboxedExecutionReason
+        });
+        const rewrittenCommand = rewriteResult.rewrittenCommand;
+        const forDisplayCommand = rewriteResult.forDisplayCommand;
+        const isSandboxWrapped = rewriteResult.isSandboxWrapped;
+        requiresUnsandboxConfirmation = rewriteResult.requiresUnsandboxConfirmation;
+        requestUnsandboxedExecutionReason = rewriteResult.requestUnsandboxedExecutionReason;
+        const blockedDomains = rewriteResult.blockedDomains;
+        const toolSpecificData = {
+            kind: "terminal",
+            terminalToolSessionId,
+            terminalCommandId,
+            commandLine: {
+                original: args.command,
+                toolEdited: rewrittenCommand === args.command ? undefined : rewrittenCommand,
+                forDisplay: forDisplayCommand ?? normalizeTerminalCommandForDisplay(rewrittenCommand ?? args.command),
+                isSandboxWrapped
+            },
+            cwd,
+            language,
+            isBackground: executionOptions.persistentSession,
+            requestUnsandboxedExecution: requiresUnsandboxConfirmation,
+            requestUnsandboxedExecutionReason,
+            missingSandboxDependencies: missingDependencies
+        };
+        let sandboxConfirmationMessageForMissingDeps = undefined;
+        if (missingDependencies) {
+            const depsList = missingDependencies.join(", ");
+            sandboxConfirmationMessageForMissingDeps = {
+                title: ( localize(14043, "Missing Sandbox Dependencies")),
+                message: ( new MarkdownString(( localize(
+                    14044,
+                    "The following dependencies required for sandboxed execution are not installed: {0}. Would you like to install them?",
+                    depsList
+                )))),
+                customButtons: [( localize(14045, "Install")), ( localize(14046, "Cancel"))]
+            };
+        }
+        const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
+        if (alternativeRecommendation) {
+            toolSpecificData.alternativeRecommendation = alternativeRecommendation;
+            return {
+                confirmationMessages: undefined,
+                presentation: ToolInvocationPresentation.Hidden,
+                toolSpecificData
+            };
+        }
+        const commandLine = forDisplayCommand ?? rewrittenCommand ?? args.command;
+        const isEligibleForAutoApproval = () => isToolEligibleForTerminalAutoApproval(
+            TOOL_REFERENCE_NAME,
+            this._configurationService,
+            LEGACY_TOOL_REFERENCE_FULL_NAMES
+        );
+        const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+        const isAutoApproveAllowed = isTerminalAutoApproveAllowed(
+            TOOL_REFERENCE_NAME,
+            this._configurationService,
+            this._storageService,
+            LEGACY_TOOL_REFERENCE_FULL_NAMES
+        );
+        const commandLineAnalyzerOptions = {
+            commandLine,
+            cwd,
+            os,
+            shell,
+            treeSitterLanguage: isPowerShell(shell, os) ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+            terminalToolSessionId,
+            chatSessionResource,
+            requiresUnsandboxConfirmation
+        };
+        const isSessionAutoApproved = chatSessionResource && isSessionAutoApproveLevel(
+            chatSessionResource,
+            this._configurationService,
+            this._chatWidgetService,
+            this._chatService
+        );
+        const commandLineAnalyzers = isSessionAutoApproved ? this._commandLineAnalyzers.filter(e => !(e instanceof CommandLineAutoApproveAnalyzer)) : this._commandLineAnalyzers;
+        const commandLineAnalyzerResults = await Promise.all(( commandLineAnalyzers.map(e => e.analyze(commandLineAnalyzerOptions))));
+        const disclaimersRaw = ( commandLineAnalyzerResults.map(e => e.disclaimers)).filter(e => !!e).flatMap(e => e);
+        let disclaimer;
+        if (disclaimersRaw.length > 0) {
+            const disclaimerTexts = ( disclaimersRaw.map(d => typeof d === "string" ? d : d.value));
+            const hasMarkdownDisclaimer = ( disclaimersRaw.some(d => typeof d !== "string"));
+            const mdOptions = hasMarkdownDisclaimer ? {
+                supportThemeIcons: true,
+                isTrusted: {
+                    enabledCommands: [TerminalChatCommandId.OpenTerminalSettingsLink]
+                }
+            } : {
+                supportThemeIcons: true
+            };
+            disclaimer = ( new MarkdownString(`$(${Codicon.info.id}) ` + disclaimerTexts.join(" "), mdOptions));
+        }
+        const analyzersIsAutoApproveAllowed = commandLineAnalyzerResults.every(e => e.isAutoApproveAllowed);
+        const customActions = isEligibleForAutoApproval() && analyzersIsAutoApproveAllowed ? ( commandLineAnalyzerResults.map(e => e.customActions ?? [])).flat() : undefined;
+        let shellType = basename(shell, ".exe");
+        if (shellType === "powershell") {
+            shellType = "pwsh";
+        }
+        const wouldBeAutoApproved =
+        (( commandLineAnalyzerResults.some(e => e.isAutoApproved)) &&
+        commandLineAnalyzerResults.every(e => e.isAutoApproved !== false) &&
+        analyzersIsAutoApproveAllowed);
+        const isAutoApprovedByRules =
+        (isAutoApproveAllowed &&
+        wouldBeAutoApproved);
+        const isFinalAutoApproved = isAutoApprovedByRules || ( commandLineAnalyzerResults.some(e => e.forceAutoApproval));
+        if (isFinalAutoApproved || (isAutoApproveEnabled && ( commandLineAnalyzerResults.some(e => e.autoApproveInfo)))) {
+            toolSpecificData.autoApproveInfo = commandLineAnalyzerResults.find(e => e.autoApproveInfo)?.autoApproveInfo;
+        }
+        const commandToDisplay = (toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original).trimStart();
+        const extractedCd = extractCdPrefix(commandToDisplay, shell, os);
+        let confirmationTitle;
+        if (extractedCd && cwd) {
+            const isAbsolutePath = os === OperatingSystem.Windows ? win32.isAbsolute(extractedCd.directory) : posix.isAbsolute(extractedCd.directory);
+            const directoryUri = isAbsolutePath ? ( URI.from({
+                scheme: cwd.scheme,
+                authority: cwd.authority,
+                path: extractedCd.directory
+            })) : URI.joinPath(cwd, extractedCd.directory);
+            const directoryLabel = this._labelService.getUriLabel(directoryUri);
+            const cdPrefix = commandToDisplay.substring(0, commandToDisplay.length - extractedCd.command.length);
+            toolSpecificData.confirmation = {
+                commandLine: extractedCd.command,
+                cwdLabel: directoryLabel,
+                cdPrefix
+            };
+            confirmationTitle = ( localize(14047, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
+        } else {
+            toolSpecificData.confirmation = {
+                commandLine: commandToDisplay
+            };
+            confirmationTitle = ( localize(14048, "Run `{0}` command?", shellType));
+        }
+        const commandForPresenter = extractedCd?.command ?? commandToDisplay;
+        let presenterInput = commandForPresenter;
+        for (const presenter of this._commandLinePresenters) {
+            const presenterResult = await presenter.present({
+                commandLine: {
+                    original: args.command,
+                    forDisplay: presenterInput
+                },
+                shell,
+                os
+            });
+            if (presenterResult) {
+                toolSpecificData.presentationOverrides = {
+                    commandLine: presenterResult.commandLine,
+                    language: presenterResult.language ?? undefined
+                };
+                if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
+                    if (presenterResult.languageDisplayName) {
+                        confirmationTitle = ( localize(
+                            14049,
+                            "Run `{0}` command in `{1}` within `{2}`?",
+                            presenterResult.languageDisplayName,
+                            shellType,
+                            toolSpecificData.confirmation.cwdLabel
+                        ));
+                    } else {
+                        confirmationTitle = ( localize(
+                            14050,
+                            "Run command in `{0}` within `{1}`?",
+                            shellType,
+                            toolSpecificData.confirmation.cwdLabel
+                        ));
+                    }
+                } else {
+                    if (presenterResult.languageDisplayName) {
+                        confirmationTitle = ( localize(
+                            14051,
+                            "Run `{0}` command in `{1}`?",
+                            presenterResult.languageDisplayName,
+                            shellType
+                        ));
+                    } else {
+                        confirmationTitle = ( localize(14052, "Run command in `{0}`?", shellType));
+                    }
+                }
+                if (!presenterResult.processOtherPresenters) {
+                    break;
+                }
+                presenterInput = presenterResult.commandLine;
+            }
+        }
+        if (requiresUnsandboxConfirmation) {
+            confirmationTitle = blockedDomains?.length ? ( localize(
+                14053,
+                "Run `{0}` command outside the [sandbox]({1}) to access {2}?",
+                shellType,
+                TERMINAL_SANDBOX_DOCUMENTATION_URL,
+                this._formatBlockedDomainsForTitle(blockedDomains)
+            )) : ( localize(
+                14054,
+                "Run `{0}` command outside the [sandbox]({1})?",
+                shellType,
+                TERMINAL_SANDBOX_DOCUMENTATION_URL
+            ));
+        }
+        const shouldShowConfirmation = (!isFinalAutoApproved && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
+        toolSpecificData.requiresConfirmationForRetry = (!isAutoApprovedByRules && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
+        const explanation = args.explanation || ( localize(14055, "No explanation provided"));
+        const goal = args.goal || ( localize(14056, "No goal provided"));
+        const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
+            14057,
+            "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
+            explanation,
+            goal,
+            requestUnsandboxedExecutionReason || ( localize(14058, "The model indicated that this command needs unsandboxed access."))
+        )))) : ( new MarkdownString(( localize(14059, "Explanation: {0}\n\nGoal: {1}", explanation, goal))));
+        const confirmationMessages = shouldShowConfirmation ? {
+            title: confirmationTitle,
+            message: confirmationMessage,
+            disclaimer,
+            allowAutoConfirm: undefined,
+            terminalCustomActions: customActions
+        } : undefined;
+        const rawDisplayCommand = toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
+        const displayCommand = rawDisplayCommand.length > 80 ? rawDisplayCommand.substring(0, 77) + "..." : rawDisplayCommand;
+        const invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? ( new MarkdownString(( localize(
+            14060,
+            "Running `{0}` in sandbox",
+            escapeMarkdownSyntaxTokens(displayCommand)
+        )))) : ( new MarkdownString(( localize(14061, "Running `{0}`", escapeMarkdownSyntaxTokens(displayCommand)))));
+        return {
+            invocationMessage,
+            icon: toolSpecificData.commandLine.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal,
+            confirmationMessages: sandboxConfirmationMessageForMissingDeps ?? confirmationMessages,
+            toolSpecificData
+        };
+    }
+    _formatBlockedDomainsForTitle(blockedDomains) {
+        if (blockedDomains.length === 1) {
+            return `\`${blockedDomains[0]}\``;
+        }
+        return localize(
+            14062,
+            "`{0}` and {1} more domains",
+            blockedDomains[0],
+            blockedDomains.length - 1
+        );
+    }
+    _getBlockedDomainReason(blockedDomains, deniedDomains = []) {
+        if (deniedDomains.length === blockedDomains.length && deniedDomains.length > 0) {
+            if (blockedDomains.length === 1) {
+                return localize(
+                    14063,
+                    "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains.",
+                    blockedDomains[0]
+                );
+            }
+            return localize(
+                14064,
+                "This command accesses {0} and {1} more domains that are blocked by chat.agent.deniedNetworkDomains.",
+                blockedDomains[0],
+                blockedDomains.length - 1
+            );
+        }
+        if (deniedDomains.length > 0) {
+            if (blockedDomains.length === 1) {
+                return localize(
+                    14065,
+                    "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
+                    blockedDomains[0]
+                );
+            }
+            return localize(
+                14066,
+                "This command accesses {0} and {1} more domains that are blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
+                blockedDomains[0],
+                blockedDomains.length - 1
+            );
+        }
+        if (blockedDomains.length === 1) {
+            return localize(
+                14067,
+                "This command accesses {0}, which is not permitted by the current chat.agent.sandbox configuration.",
+                blockedDomains[0]
+            );
+        }
+        return localize(
+            14068,
+            "This command accesses {0} and {1} more domains that are not permitted by the current chat.agent.sandbox configuration.",
+            blockedDomains[0],
+            blockedDomains.length - 1
+        );
+    }
+    async _rewriteCommandLine(commandLine, options) {
+        let rewrittenCommand = commandLine;
+        let forDisplayCommand = undefined;
+        let isSandboxWrapped = false;
+        let requiresUnsandboxConfirmation = options.requestUnsandboxedExecution;
+        let requestUnsandboxedExecutionReason = options.requestUnsandboxedExecution ? options.requestUnsandboxedExecutionReason : undefined;
+        let blockedDomains;
+        for (const rewriter of this._commandLineRewriters) {
+            const rewriteResult = await rewriter.rewrite({
+                commandLine: rewrittenCommand,
+                cwd: options.cwd,
+                shell: options.shell,
+                os: options.os,
+                isBackground: options.isBackground,
+                requestUnsandboxedExecution: requiresUnsandboxConfirmation
+            });
+            if (rewriteResult) {
+                rewrittenCommand = rewriteResult.rewritten;
+                forDisplayCommand = forDisplayCommand ?? rewriteResult.forDisplay;
+                if (rewriteResult.isSandboxWrapped) {
+                    isSandboxWrapped = true;
+                } else if (rewriteResult.isSandboxWrapped === false) {
+                    isSandboxWrapped = false;
+                }
+                if (rewriteResult.requiresUnsandboxConfirmation) {
+                    requiresUnsandboxConfirmation = true;
+                }
+                if (rewriteResult.blockedDomains?.length) {
+                    blockedDomains = rewriteResult.blockedDomains;
+                    requestUnsandboxedExecutionReason = this._getBlockedDomainReason(rewriteResult.blockedDomains, rewriteResult.deniedDomains);
+                }
+                this._logService.info(
+                    `RunInTerminalTool: Command rewritten by ${rewriter.constructor.name}: ${rewriteResult.reasoning}`
+                );
+            }
+        }
+        return {
+            rewrittenCommand,
+            forDisplayCommand,
+            isSandboxWrapped,
+            requiresUnsandboxConfirmation,
+            requestUnsandboxedExecutionReason,
+            blockedDomains
+        };
+    }
+    async _confirmAutomaticUnsandboxRetry(
+        sessionResource,
+        command,
+        shell,
+        blockedDomains,
+        requiresConfirmationForRetry,
+        token
+    ) {
+        if (requiresConfirmationForRetry === false) {
+            return true;
+        }
+        const chatModel = sessionResource && this._chatService.getSession(sessionResource);
+        if (!(chatModel instanceof ChatModel)) {
+            return false;
+        }
+        const request = chatModel.getRequests().at(-1);
+        if (!request) {
+            return false;
+        }
+        let shellType = basename(shell, ".exe");
+        if (shellType === "powershell") {
+            shellType = "pwsh";
+        }
+        const store = ( new DisposableStore());
+        return (new Promise(resolve => {
+            let resolved = false;
+            const resolveOnce = value => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                store.dispose();
+                resolve(value);
+            };
+            const part = ( new ChatElicitationRequestPart(
+                this._getAutomaticUnsandboxRetryTitle(shellType, blockedDomains),
+                ( new MarkdownString(( localize(
+                14069,
+                "`{0}`",
+                escapeMarkdownSyntaxTokens(buildCommandDisplayText(command))
+            )))),
+                "",
+                ( localize(14070, "Allow")),
+                ( localize(14071, "Skip")),
+                async () => {
+                    resolveOnce(true);
+                    part.hide();
+                    return ElicitationState.Accepted;
+                },
+                async () => {
+                    resolveOnce(false);
+                    part.hide();
+                    return ElicitationState.Rejected;
+                },
+                undefined,
+                undefined,
+                () => resolveOnce(false)
+            ));
+            chatModel.acceptResponseProgress(request, part);
+            store.add(token.onCancellationRequested(() => resolveOnce(false)));
+            store.add({
+                dispose: () => part.hide()
+            });
+        }));
+    }
+    _getAutomaticUnsandboxRetryTitle(shellType, blockedDomains) {
+        return blockedDomains?.length ? ( new MarkdownString(( localize(
+            14072,
+            "Run `{0}` command outside the sandbox to access {1}?",
+            shellType,
+            this._formatBlockedDomainsForTitle(blockedDomains)
+        )))) : ( new MarkdownString(( localize(14073, "Run `{0}` command outside the sandbox?", shellType))));
+    }
+    _acceptAutomaticUnsandboxRetryToolInvocationUpdate(
+        sessionResource,
+        toolCallId,
+        toolSpecificData,
+        isComplete,
+        toolResultMessage
+    ) {
+        const chatModel = sessionResource && this._chatService.getSession(sessionResource);
+        if (!(chatModel instanceof ChatModel)) {
+            return;
+        }
+        const request = chatModel.getRequests().at(-1);
+        if (!request) {
+            return;
+        }
+        const displayCommand = buildCommandDisplayText(
+            toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original
+        );
+        const progress = {
+            kind: "externalToolInvocationUpdate",
+            toolCallId,
+            toolName: ( localize(14038, "Run in Terminal")),
+            isComplete,
+            invocationMessage: ( new MarkdownString(( localize(
+                14074,
+                "Running `{0}` outside the sandbox",
+                escapeMarkdownSyntaxTokens(displayCommand)
+            )))),
+            pastTenseMessage: toolResultMessage,
+            toolSpecificData
+        };
+        chatModel.acceptResponseProgress(request, progress);
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const toolSpecificData = invocation.toolSpecificData;
+        if (!toolSpecificData) {
+            throw ( new Error("toolSpecificData must be provided for this tool"));
+        }
+        if (!invocation.context) {
+            throw ( new Error("Invocation context must be provided for this tool"));
+        }
+        const commandId = toolSpecificData.terminalCommandId;
+        if (toolSpecificData.alternativeRecommendation) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: toolSpecificData.alternativeRecommendation
+                }]
+            };
+        }
+        if (toolSpecificData.missingSandboxDependencies?.length) {
+            const installButton = ( localize(14045, "Install"));
+            if (invocation.selectedCustomButton === installButton) {
+                const sessionResource = invocation.context.sessionResource;
+                const {
+                    exitCode
+                } = await this._terminalSandboxService.installMissingSandboxDependencies(toolSpecificData.missingSandboxDependencies, sessionResource, token, {
+                    createTerminal: async () => this._terminalService.createTerminal({}),
+                    focusTerminal: async terminal => {
+                        this._terminalService.setActiveInstance(terminal);
+                        await this._terminalService.revealTerminal(terminal, true);
+                        terminal.focus();
+                    }
+                });
+                if (exitCode !== undefined && exitCode !== 0) {
+                    return {
+                        content: [{
+                            kind: "text",
+                            value: ( localize(
+                                14075,
+                                "Sandbox dependency installation failed (exit code {0}). The command was not executed.",
+                                exitCode
+                            ))
+                        }]
+                    };
+                }
+                if (exitCode === undefined) {
+                    return {
+                        content: [{
+                            kind: "text",
+                            value: ( localize(
+                                14076,
+                                "Could not determine whether sandbox dependency installation succeeded. The command was not executed."
+                            ))
+                        }]
+                    };
+                }
+                this._logService.info(
+                    "RunInTerminalTool: Sandbox dependency installation succeeded, proceeding with command execution"
+                );
+            } else {
+                this._logService.info("RunInTerminalTool: User cancelled sandbox dependency installation");
+                return {
+                    content: [{
+                        kind: "text",
+                        value: ( localize(14077, "Sandbox dependency installation was cancelled by the user."))
+                    }]
+                };
+            }
+        }
+        const args = invocation.parameters;
+        const executionOptions = this._resolveExecutionOptions(args);
+        this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
+        let toolResultMessage;
+        if (args.timeout !== undefined && (Number.isNaN(args.timeout) || args.timeout < 0)) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: timeout must be a non-negative number of milliseconds (use 0 for no timeout)."
+                }]
+            };
+        }
+        if (executionOptions.mode === "sync" && args.timeout === undefined) {
+            if (args.isBackground === false) {
+                args.timeout = 0;
+            } else {
+                return {
+                    content: [{
+                        kind: "text",
+                        value: "Error: timeout is required for mode=sync and must be provided in milliseconds (use 0 for no timeout)."
+                    }]
+                };
+            }
+        }
+        const chatSessionResource = invocation.context.sessionResource;
+        const shouldSendNotifications = !invocation.subAgentInvocationId;
+        const command = toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
+        const didUserEditCommand = (toolSpecificData.commandLine.userEdited !== undefined && toolSpecificData.commandLine.userEdited !== toolSpecificData.commandLine.original);
+        const didToolEditCommand = (!didUserEditCommand && toolSpecificData.commandLine.toolEdited !== undefined && toolSpecificData.commandLine.toolEdited !== toolSpecificData.commandLine.original &&
+        normalizeTerminalCommandForDisplay(toolSpecificData.commandLine.toolEdited).trim() !== normalizeTerminalCommandForDisplay(toolSpecificData.commandLine.original).trim());
+        const didSandboxWrapCommand = toolSpecificData.commandLine.isSandboxWrapped === true;
+        const isSandboxEnabled = await this._terminalSandboxService.isEnabled();
+        const commandLineForMetadata = isSandboxEnabled ? toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.original : undefined;
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        let error;
+        const automaticUnsandboxRetryReason = ( localize(
+            14078,
+            "The sandboxed execution output indicated the sandbox blocked the command."
+        ));
+        const isNewSession = !executionOptions.persistentSession && !( this._sessionTerminalAssociations.has(chatSessionResource));
+        const timingStart = Date.now();
+        const termId = generateUuid();
+        const terminalToolSessionId = toolSpecificData.terminalToolSessionId;
+        const store = ( new DisposableStore());
+        this._logService.debug(
+            `RunInTerminalTool: Creating ${executionOptions.persistentSession ? "background" : "foreground"} terminal. termId=${termId}, chatSessionResource=${chatSessionResource}`
+        );
+        const toolTerminal = await this._initTerminal(
+            chatSessionResource,
+            termId,
+            terminalToolSessionId,
+            executionOptions.persistentSession,
+            token
+        );
+        this._handleTerminalVisibility(toolTerminal, chatSessionResource);
+        const timingConnectMs = Date.now() - timingStart;
+        const xterm = await toolTerminal.instance.xtermReadyPromise;
+        if (!xterm) {
+            throw ( new Error("Instance was disposed before xterm.js was ready"));
+        }
+        const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
+        let inputUserChars = 0;
+        let inputUserSigint = false;
+        store.add(xterm.raw.onData(data => {
+            if (!telemetryIgnoredSequences.includes(data)) {
+                inputUserChars += data.length;
+            }
+            inputUserSigint ||= data === "\u0003";
+        }));
+        let terminalResult = "";
+        let outputLineCount = -1;
+        let exitCode;
+        let altBufferResult;
+        let didTimeout = false;
+        let didInputNeeded = false;
+        let isBackgroundExecution = executionOptions.persistentSession;
+        let timeoutPromise;
+        let timeoutRacePromise;
+        let outputMonitor;
+        let pollingResult;
+        const executeCancellation = store.add(( new CancellationTokenSource(token)));
+        const timeoutValue = args.timeout !== undefined ? clamp(args.timeout, 0, Number.MAX_SAFE_INTEGER) : undefined;
+        if (timeoutValue !== undefined && timeoutValue > 0) {
+            const shouldEnforceTimeout = executionOptions.waitStrategy === "idle" || this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnforceTimeoutFromModel) === true;
+            if (shouldEnforceTimeout) {
+                timeoutPromise = timeout(timeoutValue);
+                timeoutRacePromise = timeoutPromise.then(() => ({
+                    type: "timeout"
+                })).catch(() => ({
+                    type: "timeout"
+                }));
+            }
+        }
+        let continueInBackgroundResolve;
+        const continueInBackgroundPromise = ( new Promise(resolve => {
+            continueInBackgroundResolve = resolve;
+        }));
+        if (terminalToolSessionId) {
+            store.add(this._terminalChatService.onDidContinueInBackground(sessionId => {
+                if (sessionId === terminalToolSessionId) {
+                    const execution = RunInTerminalTool_1._activeExecutions.get(termId);
+                    execution?.setBackground?.();
+                    isBackgroundExecution = true;
+                    continueInBackgroundResolve?.();
+                }
+            }));
+        }
+        let executionPromise;
+        try {
+            const execution = this._instantiationService.createInstance(
+                ActiveTerminalExecution,
+                chatSessionResource,
+                termId,
+                toolTerminal,
+                commandDetection,
+                executionOptions.persistentSession
+            );
+            this._logService.info(
+                `RunInTerminalTool: Using \`${execution.strategy.type}\` execute strategy for command \`${command}\``
+            );
+            store.add(execution);
+            RunInTerminalTool_1._activeExecutions.set(termId, execution);
+            const startMarkerPromise = Event.toPromise(execution.strategy.onDidCreateStartMarker);
+            const outputMonitorPollFn = executionOptions.persistentSession ? async executionForPoll => ({
+                output: executionForPoll.getOutput(),
+                state: OutputMonitorState.Idle
+            }) : undefined;
+            store.add(execution.strategy.onDidCreateStartMarker(startMarker => {
+                if (!outputMonitor) {
+                    outputMonitor = this._instantiationService.createInstance(OutputMonitor, {
+                        instance: toolTerminal.instance,
+                        sessionResource: chatSessionResource,
+                        getOutput: marker => execution.getOutput(marker ?? startMarker)
+                    }, outputMonitorPollFn, invocation.context, token, command);
+                }
+            }));
+            executionPromise = execution.start(command, executeCancellation.token, commandId, commandLineForMetadata);
+            if (executionOptions.waitStrategy === "idle") {
+                this._logService.debug(
+                    `RunInTerminalTool: Starting persistent execution with idle wait strategy \`${command}\``
+                );
+                await startMarkerPromise;
+                let idleTimedOut = false;
+                if (outputMonitor) {
+                    if (timeoutRacePromise) {
+                        const idleRace = await Promise.race([Event.toPromise(outputMonitor.onDidFinishCommand).then(() => ({
+                            type: "idle"
+                        })), timeoutRacePromise]);
+                        if (idleRace.type === "timeout") {
+                            idleTimedOut = true;
+                            this._logService.debug(
+                                `RunInTerminalTool: Timeout reached waiting for idle signal, returning output collected so far`
+                            );
+                        } else {
+                            pollingResult = outputMonitor.pollingResult;
+                        }
+                    } else {
+                        await Event.toPromise(outputMonitor.onDidFinishCommand);
+                        pollingResult = outputMonitor.pollingResult;
+                    }
+                }
+                await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
+                if (token.isCancellationRequested) {
+                    throw ( new CancellationError());
+                }
+                const state = toolSpecificData.terminalCommandState ?? {};
+                state.timestamp = state.timestamp ?? timingStart;
+                toolSpecificData.terminalCommandState = state;
+                let resultText = (didSandboxWrapCommand ? `Command is now running in terminal with ID=${termId}` : didUserEditCommand ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : didToolEditCommand ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : `Command is running in terminal with ID=${termId}`);
+                const backgroundOutput = pollingResult?.output ?? (idleTimedOut ? execution.getOutput() : undefined);
+                const outputAnalyzerMessage = backgroundOutput ? await this._getOutputAnalyzerMessage(undefined, backgroundOutput, command, didSandboxWrapCommand) : undefined;
+                if (idleTimedOut) {
+                    resultText += `\n Timed out waiting for the command to become idle. The command is still running, with output:\n`;
+                    if (outputAnalyzerMessage) {
+                        resultText += `${outputAnalyzerMessage}\n`;
+                    }
+                    resultText += backgroundOutput ?? "";
+                } else if (pollingResult && pollingResult.state === OutputMonitorState.Idle) {
+                    resultText += `\n The command became idle with output:\n`;
+                    if (outputAnalyzerMessage) {
+                        resultText += `${outputAnalyzerMessage}\n`;
+                    }
+                    resultText += pollingResult.output;
+                    if (isSessionAutoApproveLevel(
+                        chatSessionResource,
+                        this._configurationService,
+                        this._chatWidgetService,
+                        this._chatService
+                    )) {
+                        resultText += `\nIf the command is waiting for input (not a normal shell prompt), determine the answer and call ${TerminalToolId.SendToTerminal}. Then call ${TerminalToolId.GetTerminalOutput} to read the next prompt. Repeat one prompt at a time.`;
+                    } else {
+                        resultText += `\nIf the command is waiting for input (not a normal shell prompt), call the vscode_askQuestions tool to ask the user. Then send each answer using ${TerminalToolId.SendToTerminal}, calling ${TerminalToolId.GetTerminalOutput} between each.`;
+                    }
+                } else if (pollingResult) {
+                    resultText += `\n The command is still running, with output:\n`;
+                    if (outputAnalyzerMessage) {
+                        resultText += `${outputAnalyzerMessage}\n`;
+                    }
+                    resultText += pollingResult.output;
+                }
+                const endCwd = await toolTerminal.instance.getCwdResource();
+                return {
+                    toolMetadata: {
+                        exitCode: undefined,
+                        id: termId,
+                        terminalId: toolTerminal.instance.instanceId,
+                        cwd: endCwd?.toString()
+                    },
+                    content: [{
+                        kind: "text",
+                        value: resultText
+                    }]
+                };
+            } else {
+                const raceCleanup = ( new DisposableStore());
+                const raceCandidates = [executionPromise.then(result => ({
+                    type: "completed",
+                    result
+                })), continueInBackgroundPromise.then(() => ({
+                    type: "background"
+                })), ( new Promise(resolve => {
+                    startMarkerPromise.then(() => {
+                        if (outputMonitor && !raceCleanup.isDisposed) {
+                            raceCleanup.add(outputMonitor.onDidDetectInputNeeded(() => resolve({
+                                type: "inputNeeded"
+                            })));
+                        }
+                    });
+                }))];
+                if (timeoutRacePromise) {
+                    raceCandidates.push(timeoutRacePromise);
+                }
+                const raceResult = await Promise.race(raceCandidates);
+                raceCleanup.dispose();
+                if (raceResult.type === "inputNeeded") {
+                    this._logService.debug(
+                        `RunInTerminalTool: Output monitor detected input needed in foreground terminal, returning output to agent`
+                    );
+                    error = "inputNeeded";
+                    didInputNeeded = true;
+                    const idleOutput = execution.getOutput();
+                    outputLineCount = idleOutput ? count(idleOutput.trim(), "\n") + 1 : 0;
+                    terminalResult = idleOutput ?? "";
+                } else if (raceResult.type === "background") {
+                    this._logService.debug(
+                        `RunInTerminalTool: Continue in background triggered, returning output collected so far`
+                    );
+                    error = "continueInBackground";
+                    const backgroundOutput = execution.getOutput();
+                    outputLineCount = backgroundOutput ? count(backgroundOutput.trim(), "\n") + 1 : 0;
+                    terminalResult = backgroundOutput;
+                } else if (raceResult.type === "timeout") {
+                    this._logService.debug(`RunInTerminalTool: Timeout reached, returning output collected so far`);
+                    error = "timeout";
+                    didTimeout = true;
+                    isBackgroundExecution = true;
+                    toolTerminal.isBackground = true;
+                    this._sessionTerminalAssociations.delete(chatSessionResource);
+                    await this._associateProcessIdWithSession(
+                        toolTerminal.instance,
+                        chatSessionResource,
+                        termId,
+                        toolTerminal.shellIntegrationQuality,
+                        true
+                    );
+                    const timeoutOutput = execution.getOutput();
+                    outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
+                    terminalResult = timeoutOutput ?? "";
+                } else {
+                    const executeResult = raceResult.result;
+                    toolTerminal.receivedUserInput = false;
+                    if (token.isCancellationRequested) {
+                        throw ( new CancellationError());
+                    }
+                    if (executeResult.didEnterAltBuffer) {
+                        const state = toolSpecificData.terminalCommandState ?? {};
+                        state.timestamp = state.timestamp ?? timingStart;
+                        toolSpecificData.terminalCommandState = state;
+                        toolResultMessage = altBufferMessage;
+                        outputLineCount = 0;
+                        error = executeResult.error ?? "alternateBuffer";
+                        const altBufferCwd = await toolTerminal.instance.getCwdResource();
+                        altBufferResult = {
+                            toolResultMessage,
+                            toolMetadata: {
+                                exitCode: undefined,
+                                id: termId,
+                                terminalId: toolTerminal.instance.instanceId,
+                                cwd: altBufferCwd?.toString()
+                            },
+                            content: [{
+                                kind: "text",
+                                value: altBufferMessage
+                            }]
+                        };
+                    } else {
+                        await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
+                        {
+                            const state = toolSpecificData.terminalCommandState ?? {};
+                            state.timestamp = state.timestamp ?? timingStart;
+                            if (executeResult.exitCode !== undefined) {
+                                state.exitCode = executeResult.exitCode;
+                                if (state.timestamp !== undefined) {
+                                    state.duration = state.duration ?? Math.max(0, Date.now() - state.timestamp);
+                                }
+                            }
+                            toolSpecificData.terminalCommandState = state;
+                        }
+                        this._logService.info(
+                            `RunInTerminalTool: Finished \`${execution.strategy.type}\` execute strategy with exitCode \`${executeResult.exitCode}\`, result.length \`${executeResult.output?.length}\`, error \`${executeResult.error}\``
+                        );
+                        outputLineCount = executeResult.output === undefined ? 0 : count(executeResult.output.trim(), "\n") + 1;
+                        exitCode = executeResult.exitCode;
+                        error = executeResult.error;
+                        const resultArr = [];
+                        if (executeResult.output !== undefined) {
+                            resultArr.push(executeResult.output);
+                        }
+                        if (executeResult.additionalInformation) {
+                            resultArr.push(executeResult.additionalInformation);
+                        }
+                        terminalResult = resultArr.join("\n\n");
+                    }
+                }
+            }
+        } catch (e) {
+            if (didTimeout && e instanceof CancellationError) {
+                this._logService.debug(`RunInTerminalTool: Timeout reached, returning output collected so far`);
+                error = "timeout";
+                isBackgroundExecution = true;
+                toolTerminal.isBackground = true;
+                this._sessionTerminalAssociations.delete(chatSessionResource);
+                const timeoutOutput = getOutput(toolTerminal.instance, undefined);
+                outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
+                terminalResult = timeoutOutput ?? "";
+            } else {
+                this._logService.debug(`RunInTerminalTool: Threw exception`);
+                if (e instanceof CancellationError) {
+                    await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
+                    const state = toolSpecificData.terminalCommandState ?? {};
+                    if (state.exitCode === undefined) {
+                        state.exitCode = -1;
+                        state.timestamp = state.timestamp ?? timingStart;
+                        state.duration = state.duration ?? Math.max(0, Date.now() - state.timestamp);
+                    }
+                    toolSpecificData.terminalCommandState = state;
+                }
+                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
+                RunInTerminalTool_1._activeExecutions.delete(termId);
+                toolTerminal.instance.dispose();
+                error = e instanceof CancellationError ? "canceled" : "unexpectedException";
+                throw e;
+            }
+        } finally {
+            timeoutPromise?.cancel();
+            if ((isBackgroundExecution || didInputNeeded) && executionPromise) {
+                executionPromise.catch(e => {
+                    if (!(e instanceof CancellationError)) {
+                        this._logService.error(`RunInTerminalTool: Background execution error`, e);
+                    }
+                });
+                if (shouldSendNotifications) {
+                    this._registerCompletionNotification(toolTerminal.instance, termId, chatSessionResource, command, outputMonitor);
+                } else {
+                    outputMonitor?.dispose();
+                }
+            } else {
+                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
+                RunInTerminalTool_1._activeExecutions.delete(termId);
+                outputMonitor?.dispose();
+            }
+            store.dispose();
+            const timingExecuteMs = Date.now() - timingStart;
+            this._telemetry.logInvoke(toolTerminal.instance, {
+                terminalToolSessionId: toolSpecificData.terminalToolSessionId,
+                didUserEditCommand,
+                didToolEditCommand,
+                isBackground: executionOptions.persistentSession,
+                isSandboxWrapped: toolSpecificData.commandLine.isSandboxWrapped === true,
+                requestUnsandboxedExecutionReason: args.requestUnsandboxedExecutionReason,
+                shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
+                error,
+                isNewSession,
+                outputLineCount,
+                exitCode,
+                timingExecuteMs,
+                timingConnectMs,
+                inputUserChars,
+                inputUserSigint,
+                terminalExecutionIdleBeforeTimeout: pollingResult?.state === OutputMonitorState.Idle,
+                pollDurationMs: pollingResult?.pollDurationMs,
+                inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualAcceptCount,
+                inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualRejectCount,
+                inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualChars,
+                inputToolAutoAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoAcceptCount,
+                inputToolAutoChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoChars,
+                inputToolManualShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualShownCount,
+                inputToolFreeFormInputCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputCount,
+                inputToolFreeFormInputShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputShownCount
+            });
+        }
+        if (altBufferResult) {
+            return altBufferResult;
+        }
+        const shouldAutoRetryUnsandboxed = shouldAutomaticallyRetryUnsandboxed({
+            didSandboxWrapCommand,
+            requestUnsandboxedExecution: args.requestUnsandboxedExecution === true,
+            isPersistentSession: executionOptions.persistentSession,
+            isBackgroundExecution: isBackgroundExecution || didInputNeeded,
+            didTimeout,
+            exitCode,
+            output: terminalResult
+        });
+        if (shouldAutoRetryUnsandboxed) {
+            const [os, shell] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell()]);
+            const retryReason = automaticUnsandboxRetryReason;
+            const retryRewriteResult = await this._rewriteCommandLine(args.command, {
+                cwd: toolSpecificData.cwd ? URI.revive(toolSpecificData.cwd) : undefined,
+                shell,
+                os,
+                isBackground: executionOptions.persistentSession,
+                requestUnsandboxedExecution: true,
+                requestUnsandboxedExecutionReason: retryReason
+            });
+            const rewrittenRetryReason = retryRewriteResult.requestUnsandboxedExecutionReason ?? retryReason;
+            const retryConfirmationCommand = toolSpecificData.presentationOverrides?.commandLine ?? command;
+            const shouldRetry = await this._confirmAutomaticUnsandboxRetry(
+                invocation.context.sessionResource,
+                retryConfirmationCommand,
+                shell,
+                retryRewriteResult.blockedDomains,
+                toolSpecificData.requiresConfirmationForRetry,
+                token
+            );
+            if (shouldRetry) {
+                const retryToolSpecificData = {
+                    ...toolSpecificData,
+                    terminalCommandId: `tool-${generateUuid()}`,
+                    commandLine: {
+                        original: args.command,
+                        toolEdited: retryRewriteResult.rewrittenCommand === args.command ? undefined : retryRewriteResult.rewrittenCommand,
+                        forDisplay: retryRewriteResult.forDisplayCommand ?? normalizeTerminalCommandForDisplay(retryRewriteResult.rewrittenCommand ?? args.command),
+                        isSandboxWrapped: retryRewriteResult.isSandboxWrapped
+                    },
+                    requestUnsandboxedExecution: true,
+                    requestUnsandboxedExecutionReason: rewrittenRetryReason,
+                    terminalCommandUri: undefined,
+                    terminalCommandOutput: undefined,
+                    terminalTheme: undefined,
+                    terminalCommandState: undefined,
+                    didContinueInBackground: undefined
+                };
+                const retryToolCallId = `automatic-unsandbox-retry-${generateUuid()}`;
+                this._acceptAutomaticUnsandboxRetryToolInvocationUpdate(
+                    invocation.context.sessionResource,
+                    retryToolCallId,
+                    retryToolSpecificData,
+                    false
+                );
+                return await this.invoke({
+                    ...invocation,
+                    parameters: {
+                        ...args,
+                        command: args.command,
+                        requestUnsandboxedExecution: true,
+                        requestUnsandboxedExecutionReason: rewrittenRetryReason
+                    },
+                    toolSpecificData: retryToolSpecificData
+                }, _countTokens, _progress, token);
+            }
+        }
+        this._terminalToolCreator.refreshShellIntegrationQuality(toolTerminal);
+        this._logService.info(
+            `RunInTerminalTool: shellIntegrationQuality=${toolTerminal.shellIntegrationQuality} at banner decision time`
+        );
+        if (!toolResultMessage && toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None) {
+            toolResultMessage = "$(info) Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection";
+        }
+        const resultText = [];
+        if (!didSandboxWrapCommand) {
+            if (didUserEditCommand) {
+                resultText.push(
+                    `Note: The user manually edited the command to \`${command}\`, and this is the output of running that command instead:\n`
+                );
+            } else if (didToolEditCommand) {
+                resultText.push(
+                    `Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`
+                );
+            }
+            if (isBackgroundExecution && !executionOptions.persistentSession) {
+                resultText.push(
+                    `Note: This terminal execution was moved to the background using the ID ${termId}\n`
+                );
+            }
+        }
+        const isAutoApproved = isSessionAutoApproveLevel(
+            chatSessionResource,
+            this._configurationService,
+            this._chatWidgetService,
+            this._chatService
+        );
+        if (didInputNeeded) {
+            if (isAutoApproved) {
+                resultText.push(
+                    `Note: The command is running in terminal ID ${termId} and may be waiting for input. If it IS waiting for input (not a normal shell prompt), determine the answer and call ${TerminalToolId.SendToTerminal}. Then call ${TerminalToolId.GetTerminalOutput} to read the next prompt. Repeat one prompt at a time.\n\n`
+                );
+            } else {
+                resultText.push(
+                    `Note: The command is running in terminal ID ${termId} and may be waiting for input. If it IS waiting for input (not a normal shell prompt), call the vscode_askQuestions tool to ask the user. Then send each answer using ${TerminalToolId.SendToTerminal}, calling ${TerminalToolId.GetTerminalOutput} between each.\n\n`
+                );
+            }
+        } else if (didTimeout && timeoutValue !== undefined && timeoutValue > 0) {
+            const notificationHint = shouldSendNotifications ? " You will be automatically notified on your next turn when it completes." : "";
+            const inputAction = isAutoApproved ? `If it IS waiting for input (not a normal shell prompt), determine the answer and call ${TerminalToolId.SendToTerminal}. Then call ${TerminalToolId.GetTerminalOutput} to read the next prompt. Repeat one prompt at a time.` : `If it IS waiting for input (not a normal shell prompt), call the vscode_askQuestions tool to ask the user. Then send each answer using ${TerminalToolId.SendToTerminal}, calling ${TerminalToolId.GetTerminalOutput} between each.`;
+            resultText.push(
+                `Note: Command timed out after ${timeoutValue}ms. The command may still be running in terminal ID ${termId}.${notificationHint} Use ${TerminalToolId.GetTerminalOutput} to check output, ${TerminalToolId.SendToTerminal} to send input, or ${TerminalToolId.KillTerminal} to stop it. ${inputAction}\n\n`
+            );
+        }
+        const outputAnalyzerMessage = await this._getOutputAnalyzerMessage(exitCode, terminalResult, command, didSandboxWrapCommand);
+        if (outputAnalyzerMessage) {
+            resultText.push(`${outputAnalyzerMessage}\n`);
+        }
+        resultText.push(terminalResult);
+        const isError = exitCode !== undefined && exitCode !== 0;
+        const endCwd = await toolTerminal.instance.getCwdResource();
+        const imageContent = await this._extractImagesFromOutput(terminalResult, endCwd);
+        return {
+            toolResultMessage,
+            toolMetadata: {
+                exitCode: exitCode,
+                id: termId,
+                terminalId: toolTerminal.instance.instanceId,
+                cwd: endCwd?.toString(),
+                timedOut: didTimeout || undefined,
+                timeoutMs: didTimeout ? timeoutValue : undefined
+            },
+            toolResultDetails: isError ? {
+                input: command,
+                output: [{
+                    type: "embed",
+                    isText: true,
+                    value: terminalResult
+                }],
+                isError: true
+            } : undefined,
+            content: [{
+                kind: "text",
+                value: resultText.join("")
+            }, ...imageContent]
+        };
+    }
+    async _getOutputAnalyzerMessage(exitCode, exitResult, commandLine, isSandboxWrapped) {
+        for (const analyzer of this._outputAnalyzers) {
+            const message = await analyzer.analyze({
+                exitCode,
+                exitResult,
+                commandLine,
+                isSandboxWrapped
+            });
+            if (message) {
+                return message;
+            }
+        }
+        return undefined;
+    }
+    static {
+        this._maxImageFileSize = 5 * 1024 * 1024;
+    }
+    async _extractImagesFromOutput(output, cwd) {
+        const pathPattern = /[^\s/\\]*(?:[/\\][^\s/\\]*)+\.(?:png|jpe?g|gif|webp|bmp)/gi;
+        const matches = ( new Set());
+        for (const line of output.split(/\r?\n/)) {
+            if (line.length > 10_000) {
+                continue;
+            }
+            for (const match of line.matchAll(pathPattern)) {
+                matches.add(match[0]);
+            }
+        }
+        if (matches.size === 0) {
+            return [];
+        }
+        const results = [];
+        for (const filePath of matches) {
+            try {
+                const mimeType = getMediaMime(filePath);
+                if (!mimeType || !mimeType.startsWith("image/")) {
+                    continue;
+                }
+                let fileUri;
+                if (/^\/|^[A-Za-z]:[\\\/]/.test(filePath)) {
+                    fileUri = URI.file(filePath);
+                } else if (cwd) {
+                    fileUri = URI.joinPath(cwd, filePath);
+                } else {
+                    continue;
+                }
+                const stat = await this._fileService.stat(fileUri).catch(() => undefined);
+                if (!stat || stat.isDirectory || stat.size > RunInTerminalTool_1._maxImageFileSize) {
+                    continue;
+                }
+                const fileContent = await this._fileService.readFile(fileUri);
+                results.push({
+                    kind: "data",
+                    value: {
+                        mimeType,
+                        data: fileContent.value
+                    },
+                    audience: [LanguageModelPartAudience.User]
+                });
+            } catch {}
+        }
+        return results;
+    }
+    _handleTerminalVisibility(toolTerminal, chatSessionResource) {
+        const chatSessionOpenInWidget = !!this._chatWidgetService.getWidgetBySessionResource(chatSessionResource);
+        if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === "terminal" && chatSessionOpenInWidget) {
+            this._terminalService.setActiveInstance(toolTerminal.instance);
+            this._terminalService.revealTerminal(toolTerminal.instance, true);
+        }
+    }
+    async _initTerminal(chatSessionResource, termId, terminalToolSessionId, isBackground, token) {
+        if (!isBackground) {
+            const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
+            if (cachedTerminal && !cachedTerminal.isBackground && !cachedTerminal.instance.isDisposed) {
+                this._logService.debug(
+                    `RunInTerminalTool: Using cached terminal with session resource \`${chatSessionResource}\``
+                );
+                this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
+                this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, cachedTerminal.instance);
+                return cachedTerminal;
+            }
+        }
+        this._logService.debug(
+            `RunInTerminalTool: Creating ${isBackground ? "background" : "foreground"} terminal with ID=${termId}`
+        );
+        const profile = await this._profileFetcher.getCopilotProfile();
+        const os = await this._osBackend;
+        const toolTerminal = await this._terminalToolCreator.createTerminal(profile, os, token);
+        toolTerminal.isBackground = isBackground;
+        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
+        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, toolTerminal.instance);
+        this._registerInputListener(toolTerminal);
+        this._addSessionTerminalAssociation(chatSessionResource, toolTerminal);
+        if (token.isCancellationRequested) {
+            toolTerminal.instance.dispose();
+            throw ( new CancellationError());
+        }
+        await this._setupProcessIdAssociation(toolTerminal, chatSessionResource, termId, isBackground);
+        return toolTerminal;
+    }
+    _registerInputListener(toolTerminal) {
+        const disposable = toolTerminal.instance.onData(data => {
+            if (!telemetryIgnoredSequences.includes(data)) {
+                toolTerminal.receivedUserInput = data.length > 0;
+            }
+        });
+        Event.once(toolTerminal.instance.onDisposed)(() => disposable.dispose());
+    }
+    _restoreTerminalAssociations() {
+        const storedAssociations = this._storageService.get(
+            TerminalToolStorageKeysInternal.TerminalSession,
+            StorageScope.WORKSPACE,
+            "{}"
+        );
+        try {
+            const associations = JSON.parse(storedAssociations);
+            for (const instance of this._terminalService.instances) {
+                if (instance.processId) {
+                    const association = associations[instance.processId];
+                    if (association) {
+                        const chatSessionResource = LocalChatSessionUri.forSession(association.sessionId);
+                        this._logService.debug(
+                            `RunInTerminalTool: Restored terminal association for PID ${instance.processId}, session ${association.sessionId}`
+                        );
+                        const toolTerminal = {
+                            instance,
+                            shellIntegrationQuality: association.shellIntegrationQuality,
+                            isBackground: association.isBackground
+                        };
+                        this._addSessionTerminalAssociation(chatSessionResource, toolTerminal);
+                        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, instance);
+                        if (association.id) {
+                            RunInTerminalTool_1._activeExecutions.set(association.id, this._register(( new RestoredTerminalExecution(instance))));
+                        }
+                        Event.once(instance.onDisposed)(() => {
+                            this._removeProcessIdAssociation(instance.processId);
+                            this._removeExecutionAssociations(instance);
+                        });
+                    }
+                }
+            }
+        } catch (error) {
+            this._logService.debug(`RunInTerminalTool: Failed to restore terminal associations: ${error}`);
+        }
+    }
+    async _setupProcessIdAssociation(toolTerminal, chatSessionResource, termId, isBackground) {
+        await this._associateProcessIdWithSession(
+            toolTerminal.instance,
+            chatSessionResource,
+            termId,
+            toolTerminal.shellIntegrationQuality,
+            isBackground
+        );
+        Event.once(toolTerminal.instance.onDisposed)(() => {
+            if (toolTerminal.instance.processId) {
+                this._removeProcessIdAssociation(toolTerminal.instance.processId);
+            }
+        });
+    }
+    async _associateProcessIdWithSession(terminal, chatSessionResource, id, shellIntegrationQuality, isBackground) {
+        try {
+            const pid = await Promise.race([
+                terminal.processReady.then(() => terminal.processId),
+                timeout(5000).then(() => {
+                    throw ( new Error("Timeout"));
+                })
+            ]);
+            if (isNumber(pid)) {
+                const storedAssociations = this._storageService.get(
+                    TerminalToolStorageKeysInternal.TerminalSession,
+                    StorageScope.WORKSPACE,
+                    "{}"
+                );
+                const associations = JSON.parse(storedAssociations);
+                const sessionId = chatSessionResourceToId(chatSessionResource);
+                const existingAssociation = associations[pid] || {};
+                associations[pid] = {
+                    ...existingAssociation,
+                    sessionId,
+                    shellIntegrationQuality,
+                    id,
+                    isBackground
+                };
+                this._storageService.store(
+                    TerminalToolStorageKeysInternal.TerminalSession,
+                    JSON.stringify(associations),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.USER
+                );
+                this._logService.debug(
+                    `RunInTerminalTool: Associated terminal PID ${pid} with session ${sessionId}`
+                );
+            }
+        } catch (error) {
+            this._logService.debug(`RunInTerminalTool: Failed to associate terminal with session: ${error}`);
+        }
+    }
+    async _removeProcessIdAssociation(pid) {
+        try {
+            const storedAssociations = this._storageService.get(
+                TerminalToolStorageKeysInternal.TerminalSession,
+                StorageScope.WORKSPACE,
+                "{}"
+            );
+            const associations = JSON.parse(storedAssociations);
+            if (associations[pid]) {
+                delete associations[pid];
+                this._storageService.store(
+                    TerminalToolStorageKeysInternal.TerminalSession,
+                    JSON.stringify(associations),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.USER
+                );
+                this._logService.debug(`RunInTerminalTool: Removed terminal association for PID ${pid}`);
+            }
+        } catch (error) {
+            this._logService.debug(`RunInTerminalTool: Failed to remove terminal association: ${error}`);
+        }
+    }
+    _cleanupSessionTerminals(chatSessionResource) {
+        const sessionTerminals = this._sessionTerminalInstances.get(chatSessionResource);
+        const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
+        const terminalsToDispose = sessionTerminals ?? (toolTerminal ? ( new Set([toolTerminal.instance])) : undefined);
+        if (!terminalsToDispose || terminalsToDispose.size === 0) {
+            return;
+        }
+        this._logService.debug(
+            `RunInTerminalTool: Cleaning up ${terminalsToDispose.size} terminal(s) for ended chat session ${chatSessionResource}`
+        );
+        this._sessionTerminalAssociations.delete(chatSessionResource);
+        this._sessionTerminalInstances.delete(chatSessionResource);
+        for (const terminal of terminalsToDispose) {
+            this._terminalsBeingDisposedBySessionCleanup.add(terminal);
+            terminal.dispose();
+        }
+        const terminalToRemove = [];
+        for (const [termId, execution] of RunInTerminalTool_1._activeExecutions.entries()) {
+            if (( terminalsToDispose.has(execution.instance))) {
+                execution.dispose();
+                terminalToRemove.push(termId);
+            }
+        }
+        for (const termId of terminalToRemove) {
+            RunInTerminalTool_1._activeExecutions.delete(termId);
+        }
+    }
+    _addSessionTerminalAssociation(chatSessionResource, toolTerminal) {
+        this._ensureArchivedSessionListener();
+        let sessionTerminals = this._sessionTerminalInstances.get(chatSessionResource);
+        if (!sessionTerminals) {
+            sessionTerminals = ( new Set());
+            this._sessionTerminalInstances.set(chatSessionResource, sessionTerminals);
+        }
+        sessionTerminals.add(toolTerminal.instance);
+        if (!toolTerminal.isBackground) {
+            this._sessionTerminalAssociations.set(chatSessionResource, toolTerminal);
+        }
+    }
+    _ensureArchivedSessionListener() {
+        if (this._archivedSessionListener.value) {
+            return;
+        }
+        this._archivedSessionListener.value = this._agentSessionsService.onDidChangeSessionArchivedState(session => {
+            if (session.isArchived()) {
+                this._cleanupSessionTerminals(session.resource);
+            }
+        });
+    }
+    _removeTerminalAssociations(terminal) {
+        if (this._terminalsBeingDisposedBySessionCleanup.delete(terminal)) {
+            this._removeExecutionAssociations(terminal);
+            return;
+        }
+        for (const [sessionResource, toolTerminal] of this._sessionTerminalAssociations.entries()) {
+            if (terminal === toolTerminal.instance) {
+                this._sessionTerminalAssociations.delete(sessionResource);
+            }
+        }
+        for (const [sessionResource, sessionTerminals] of this._sessionTerminalInstances.entries()) {
+            if (!sessionTerminals.delete(terminal)) {
+                continue;
+            }
+            if (sessionTerminals.size === 0) {
+                this._sessionTerminalInstances.delete(sessionResource);
+            }
+        }
+        this._removeExecutionAssociations(terminal);
+    }
+    _removeExecutionAssociations(terminal) {
+        const executionIdsToRemove = [];
+        for (const [termId, execution] of RunInTerminalTool_1._activeExecutions.entries()) {
+            if (execution.instance === terminal) {
+                execution.dispose();
+                executionIdsToRemove.push(termId);
+            }
+        }
+        for (const termId of executionIdsToRemove) {
+            RunInTerminalTool_1._activeExecutions.delete(termId);
+        }
+    }
+    _registerCompletionNotification(terminalInstance, termId, chatSessionResource, commandName, outputMonitor) {
+        this._backgroundNotifications.deleteAndDispose(termId);
+        const commandDetection = terminalInstance.capabilities.get(TerminalCapability.CommandDetection);
+        if (!commandDetection) {
+            outputMonitor?.dispose();
+            return;
+        }
+        const sessionRef = this._chatService.acquireExistingSession(chatSessionResource, "RunInTerminalTool#completionNotification");
+        if (!sessionRef) {
+            this._logService.warn(
+                `RunInTerminalTool: Cannot register completion notification for terminal ${termId} - session already disposed`
+            );
+            outputMonitor?.dispose();
+            return;
+        }
+        const lastRequest = sessionRef.object.lastRequest;
+        const sendOptions = {};
+        if (lastRequest) {
+            sendOptions.userSelectedModelId = lastRequest.modelId;
+            sendOptions.modeInfo = lastRequest.modeInfo;
+            if (lastRequest.userSelectedTools) {
+                sendOptions.userSelectedTools = constObservable(lastRequest.userSelectedTools);
+            }
+        }
+        const store = ( new DisposableStore());
+        let userIsReplyingDirectly = false;
+        const disposeNotification = () => this._backgroundNotifications.deleteAndDispose(termId);
+        const handleSessionCancelled = () => {
+            if (sessionRef.object.lastRequest?.response?.isCanceled) {
+                disposeNotification();
+                return true;
+            }
+            return false;
+        };
+        store.add(autorun(reader => {
+            const request = sessionRef.object.lastRequestObs.read(reader);
+            if (!request?.response) {
+                return;
+            }
+            reader.store.add(request.response.onDidChange(ev => {
+                if (ev.reason === "completedRequest" && request.response.isCanceled) {
+                    disposeNotification();
+                }
+            }));
+        }));
+        if (outputMonitor) {
+            let lastInputNeededOutput = "";
+            let lastInputNeededNotificationTime = 0;
+            const bgCts = ( new CancellationTokenSource());
+            store.add(toDisposable(() => {
+                bgCts.cancel();
+                bgCts.dispose();
+            }));
+            store.add(outputMonitor);
+            outputMonitor.continueMonitoringAsync(bgCts.token);
+            store.add(outputMonitor.onDidDetectInputNeeded(() => {
+                if (userIsReplyingDirectly) {
+                    this._logService.debug(
+                        `RunInTerminalTool: Suppressing input-needed notification for terminal ${termId} because user is replying directly`
+                    );
+                    return;
+                }
+                if (handleSessionCancelled()) {
+                    return;
+                }
+                const execution = RunInTerminalTool_1._activeExecutions.get(termId);
+                if (!execution) {
+                    return;
+                }
+                const currentOutput = execution.getOutput();
+                const now = Date.now();
+                const isDuplicate = currentOutput === lastInputNeededOutput && now - lastInputNeededNotificationTime < INPUT_NEEDED_NOTIFICATION_THROTTLE_MS;
+                if (isDuplicate) {
+                    return;
+                }
+                lastInputNeededOutput = currentOutput;
+                lastInputNeededNotificationTime = now;
+                const isAutoApproved = isSessionAutoApproveLevel(
+                    chatSessionResource,
+                    this._configurationService,
+                    this._chatWidgetService,
+                    this._chatService
+                );
+                const inputAction = isAutoApproved ? `Determine the answer and call ${TerminalToolId.SendToTerminal}. Then call ${TerminalToolId.GetTerminalOutput} to read the next prompt. Repeat one prompt at a time. A normal shell prompt does NOT count as waiting for input.` : `Call the vscode_askQuestions tool to ask the user. Then send each answer using ${TerminalToolId.SendToTerminal}, calling ${TerminalToolId.GetTerminalOutput} between each. A normal shell prompt does NOT count as waiting for input.`;
+                const message = `[Terminal ${termId} notification: command is waiting for input. ${inputAction}]\nTerminal output:\n${currentOutput}`;
+                this._logService.debug(
+                    `RunInTerminalTool: Input needed in background terminal ${termId}, notifying chat session`
+                );
+                this._chatService.sendRequest(chatSessionResource, message, {
+                    ...sendOptions,
+                    queue: ChatRequestQueueKind.Steering,
+                    isSystemInitiated: true,
+                    systemInitiatedLabel: ( localize(14079, "`{0}` needs input", commandName)),
+                    terminalExecutionId: termId
+                }).catch(e => {
+                    this._logService.warn(
+                        `RunInTerminalTool: Failed to send input-needed notification for terminal ${termId}`,
+                        e
+                    );
+                });
+            }));
+        }
+        store.add(terminalInstance.onDidInputData(() => {
+            if (userIsReplyingDirectly) {
+                return;
+            }
+            userIsReplyingDirectly = true;
+            this._dismissPendingCarouselsForTerminal(chatSessionResource, termId);
+        }));
+        store.add(sessionRef);
+        store.add(commandDetection.onCommandFinished(command => {
+            const execution = RunInTerminalTool_1._activeExecutions.get(termId);
+            if (!execution) {
+                disposeNotification();
+                return;
+            }
+            if (handleSessionCancelled()) {
+                return;
+            }
+            disposeNotification();
+            const exitCode = command.exitCode;
+            const exitCodeText = exitCode !== undefined ? ` with exit code ${exitCode}` : "";
+            const currentOutput = execution.getOutput();
+            const message = `[Terminal ${termId} notification: command completed${exitCodeText}. Use send_to_terminal to send another command or kill_terminal to stop it.]\nTerminal output:\n${currentOutput}`;
+            this._logService.debug(
+                `RunInTerminalTool: Command completed in background terminal ${termId}, notifying chat session`
+            );
+            this._chatService.sendRequest(chatSessionResource, message, {
+                ...sendOptions,
+                queue: ChatRequestQueueKind.Steering,
+                isSystemInitiated: true,
+                systemInitiatedLabel: ( localize(14080, "`{0}` completed", commandName)),
+                terminalExecutionId: termId
+            }).catch(e => {
+                this._logService.warn(
+                    `RunInTerminalTool: Failed to send completion notification for terminal ${termId}`,
+                    e
+                );
+            });
+        }));
+        store.add(terminalInstance.onDisposed(() => {
+            disposeNotification();
+        }));
+        store.add(sessionRef.object.onDidChange(e => {
+            if (e.kind === "removeRequest") {
+                this._logService.debug(
+                    `RunInTerminalTool: Request removed from session, cleaning up background terminal ${termId}`
+                );
+                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
+                RunInTerminalTool_1._activeExecutions.delete(termId);
+                disposeNotification();
+                terminalInstance.dispose();
+            }
+        }));
+        this._backgroundNotifications.set(termId, store);
+    }
+    _dismissPendingCarouselsForTerminal(chatSessionResource, termId) {
+        const model = this._chatService.getSession(chatSessionResource);
+        if (!model) {
+            return;
+        }
+        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;
+            for (let j = parts.length - 1; j >= 0; j--) {
+                const part = parts[j];
+                if (part instanceof ChatQuestionCarouselData && part.terminalId === termId && !part.isUsed) {
+                    this._logService.debug(
+                        `RunInTerminalTool: Dismissing pending carousel for terminal ${termId} because user typed directly in terminal`
+                    );
+                    part.data = {};
+                    part.isUsed = true;
+                    part.dismissedByTerminalInput = true;
+                    part.completion.complete({
+                        answers: undefined
+                    });
+                    return;
+                }
+            }
+        }
+    }
+};
+RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([( __param(0, IChatService)), ( __param(1, IConfigurationService)), ( __param(2, IFileService)), ( __param(3, IHistoryService)), ( __param(4, IInstantiationService)), ( __param(5, ILabelService)), ( __param(6, ILanguageModelToolsService)), ( __param(7, IRemoteAgentService)), ( __param(8, IStorageService)), ( __param(9, ITerminalChatService)), ( __param(10, ITerminalLogService)), ( __param(11, ITerminalService)), ( __param(12, ITerminalSandboxService)), ( __param(13, IWorkspaceContextService)), ( __param(14, IChatWidgetService)), ( __param(15, IAgentSessionsService))], RunInTerminalTool));
+let ActiveTerminalExecution = class ActiveTerminalExecution extends Disposable {
+    get completionPromise() {
+        return this._completionDeferred.p;
+    }
+    get isBackground() {
+        return this._isBackground;
+    }
+    get startMarker() {
+        return this._startMarker;
+    }
+    get instance() {
+        return this._toolTerminal.instance;
+    }
+    constructor(
+        sessionResource,
+        termId,
+        toolTerminal,
+        commandDetection,
+        isBackground,
+        _instantiationService
+    ) {
+        super();
+        this.sessionResource = sessionResource;
+        this.termId = termId;
+        this._instantiationService = _instantiationService;
+        this._toolTerminal = toolTerminal;
+        this._isBackground = isBackground;
+        this._completionDeferred = ( new DeferredPromise());
+        this.strategy = this._register(this._createStrategy(commandDetection));
+        this._register(this.strategy.onDidCreateStartMarker(marker => {
+            if (marker) {
+                this._startMarker = marker;
+            }
+        }));
+    }
+    _createStrategy(commandDetection) {
+        switch (this._toolTerminal.shellIntegrationQuality) {
+        case ShellIntegrationQuality.None:
+            return this._instantiationService.createInstance(
+                NoneExecuteStrategy,
+                this._toolTerminal.instance,
+                () => this._toolTerminal.receivedUserInput ?? false
+            );
+        case ShellIntegrationQuality.Basic:
+            return this._instantiationService.createInstance(
+                BasicExecuteStrategy,
+                this._toolTerminal.instance,
+                () => this._toolTerminal.receivedUserInput ?? false,
+                commandDetection
+            );
+        case ShellIntegrationQuality.Rich:
+            return this._instantiationService.createInstance(RichExecuteStrategy, this._toolTerminal.instance, commandDetection);
+        }
+    }
+    async start(commandLine, token, commandId, commandLineForMetadata) {
+        try {
+            const result = await this.strategy.execute(commandLine, token, commandId, commandLineForMetadata);
+            this._completionDeferred.complete(result);
+            return result;
+        } catch (e) {
+            this._completionDeferred.error(e);
+            throw e;
+        }
+    }
+    setForeground() {
+        this._isBackground = false;
+    }
+    setBackground() {
+        this._isBackground = true;
+    }
+    getOutput(marker) {
+        return getOutput(this.instance, marker ?? this._startMarker);
+    }
+};
+ActiveTerminalExecution = ( __decorate([( __param(5, IInstantiationService))], ActiveTerminalExecution));
+class RestoredTerminalExecution extends Disposable {
+    constructor(instance) {
+        super();
+        this.instance = instance;
+        this.completionPromise = Promise.resolve({
+            output: undefined,
+            error: "restoredTerminalExecutionNotAwaitable"
+        });
+    }
+    getOutput(marker) {
+        return getOutput(this.instance, marker);
+    }
+}
+let TerminalProfileFetcher = class TerminalProfileFetcher {
+    constructor(
+        _configurationService,
+        _terminalProfileResolverService,
+        _remoteAgentService
+    ) {
+        this._configurationService = _configurationService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._remoteAgentService = _remoteAgentService;
+        this.osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
+    }
+    async getCopilotProfile() {
+        const os = await this.osBackend;
+        const customChatAgentProfile = this._getChatTerminalProfile(os);
+        if (customChatAgentProfile) {
+            return customChatAgentProfile;
+        }
+        const defaultProfile = await this._terminalProfileResolverService.getDefaultProfile({
+            os,
+            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
+        });
+        if (basename(defaultProfile.path) === "cmd.exe") {
+            return {
+                ...defaultProfile,
+                path: "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+                profileName: "PowerShell"
+            };
+        }
+        if (defaultProfile.path === "/bin/sh") {
+            return {
+                ...defaultProfile,
+                path: "/bin/bash",
+                profileName: "bash"
+            };
+        }
+        return {
+            ...defaultProfile,
+            icon: undefined
+        };
+    }
+    async getCopilotShell() {
+        return (await this.getCopilotProfile()).path;
+    }
+    _getChatTerminalProfile(os) {
+        let profileSetting;
+        switch (os) {
+        case OperatingSystem.Windows:
+            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileWindows;
+            break;
+        case OperatingSystem.Macintosh:
+            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileMacOs;
+            break;
+        case OperatingSystem.Linux:
+        default:
+            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileLinux;
+            break;
+        }
+        const profile = this._configurationService.getValue(profileSetting);
+        if (this._isValidChatAgentTerminalProfile(profile)) {
+            return profile;
+        }
+        return undefined;
+    }
+    _isValidChatAgentTerminalProfile(profile) {
+        if (profile === null || profile === undefined || typeof profile !== "object") {
+            return false;
+        }
+        if ("path" in profile && isString(profile.path)) {
+            return true;
+        }
+        return false;
+    }
+};
+TerminalProfileFetcher = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalProfileResolverService)), ( __param(2, IRemoteAgentService))], TerminalProfileFetcher));
+
+export { RunInTerminalTool, TerminalProfileFetcher, createRunInTerminalToolData, shouldAutomaticallyRetryUnsandboxed };