@codingame/monaco-vscode-katex-common 33.0.9 → 34.0.0

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

@@ -1,2623 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { timeout, DeferredPromise, RunOnceScheduler } 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 { ConfirmationOptionKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state';
-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 { AgentSandboxSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
-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 { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.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, allowToRunUnsandboxedCommands, 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:",
-        "- Use mode=async ONLY for processes that should keep running while you do other work (servers, watchers, dev daemons)",
-        "- For one-shot long-running commands where you have nothing to do until they finish (package installs, builds, downloads, test suites), use mode=sync with a generous timeout (e.g. 600000 / 10 min for installs, longer for big builds) so the command can complete before your turn ends",
-        "- 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(allowToRunUnsandboxedCommands, 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. Do NOT poll for completion.`,
-        "",
-        "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.",
-        `- NEVER use vscode_askQuestions to request sensitive input such as passwords, passphrases, API keys, tokens, or other secrets — answers to that tool are sent through the model. If the prompt requires a secret, tell the user to type it directly into the terminal and stop; do not call vscode_askQuestions or ${TerminalToolId.SendToTerminal} for that prompt.`,
-        `- 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(allowToRunUnsandboxedCommands, 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"
-    ];
-    if (allowToRunUnsandboxedCommands) {
-        lines.push(
-            "- 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",
-            "- When setting requestUnsandboxedExecution=true, also provide requestUnsandboxedExecutionReason explaining why the command needs unsandboxed access"
-        );
-    } else {
-        lines.push(
-            "- Running commands outside the sandbox is disabled by the current chat.agent.sandbox.allowUnsandboxedCommands setting. Do not set requestUnsandboxedExecution=true."
-        );
-    }
-    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, allowToRunUnsandboxedCommands, 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:
-- Use mode=async ONLY for processes that should keep running while you do other work (servers, watchers, dev daemons)
-- For one-shot long-running commands where you have nothing to do until they finish (package installs, builds, downloads, test suites), use mode=sync with a generous timeout (e.g. 600000 / 10 min for installs, longer for big builds) so the command can complete before your turn ends
-- 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(allowToRunUnsandboxedCommands, 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. Do NOT poll for completion.
-
-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.
-- NEVER use vscode_askQuestions to request sensitive input such as passwords, passphrases, API keys, tokens, or other secrets — answers to that tool are sent through the model. If the prompt requires a secret, tell the user to type it directly into the terminal and stop; do not call vscode_askQuestions or send_to_terminal for that prompt.
-- 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, allowToRunUnsandboxedCommands, 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, allowToRunUnsandboxedCommands, networkDomains),
-        "- Use [[ ]] for conditional tests instead of [ ]",
-        "- Prefer $() over backticks for command substitution"
-    ].join("\n");
-}
-function createZshModelDescription(isSandboxEnabled, allowToRunUnsandboxedCommands, 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, allowToRunUnsandboxedCommands, 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",
-        "- Take advantage of zsh globbing features (**, extended globs). Note: unmatched globs fail by default (zsh: no matches found) — use a glob qualifier like *(N) or quote the glob if it should be literal",
-        "",
-        "zsh pitfalls — these WILL cause errors or hangs:",
-        "- NEVER use bare == or === as separators (e.g. echo === triggers zsh equals expansion). Quote them: echo '==='",
-        "- NEVER use status as a variable name (it is read-only in zsh). Use exit_code or ret instead"
-    ].join("\n");
-}
-function createFishModelDescription(isSandboxEnabled, allowToRunUnsandboxedCommands, 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, allowToRunUnsandboxedCommands, 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",
-        "- 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 configurationService = accessor.get(IConfigurationService);
-    const allowToRunUnsandboxedCommands = configurationService.getValue(AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands) === true;
-    const profileFetcher = instantiationService.createInstance(TerminalProfileFetcher);
-    const [shell, os, isSandboxEnabled, isSandboxAllowNetworkEnabled] = await Promise.all([
-        profileFetcher.getCopilotShell(),
-        profileFetcher.osBackend,
-        terminalSandboxService.isEnabled(),
-        terminalSandboxService.isSandboxAllowNetworkEnabled()
-    ]);
-    const networkDomains = isSandboxEnabled && !isSandboxAllowNetworkEnabled ? terminalSandboxService.getResolvedNetworkDomains() : undefined;
-    let modelDescription;
-    if (shell && os && isPowerShell(shell, os)) {
-        modelDescription = createPowerShellModelDescription(shell, isSandboxEnabled, allowToRunUnsandboxedCommands, networkDomains);
-    } else if (shell && os && isZsh(shell, os)) {
-        modelDescription = createZshModelDescription(isSandboxEnabled, allowToRunUnsandboxedCommands, networkDomains);
-    } else if (shell && os && isFish(shell, os)) {
-        modelDescription = createFishModelDescription(isSandboxEnabled, allowToRunUnsandboxedCommands, networkDomains);
-    } else {
-        modelDescription = createBashModelDescription(isSandboxEnabled, allowToRunUnsandboxedCommands, 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 ? {
-        allowToRunUnsandboxedCommands: {
-            type: "boolean",
-            const: allowToRunUnsandboxedCommands,
-            default: allowToRunUnsandboxedCommands,
-            description: "Whether this tool invocation is allowed to run commands outside the terminal sandbox. This value is set by VS Code based on chat.agent.sandbox.allowUnsandboxedCommands."
-        },
-        requestUnsandboxedExecution: {
-            type: "boolean",
-            description: "Request that this command run outside the terminal sandbox. Only set this when the command clearly needs unsandboxed access. The user will be prompted before the command runs unsandboxed."
-        },
-        requestUnsandboxedExecutionReason: {
-            type: "string",
-            description: "A short explanation of why this command must run outside the terminal sandbox. Only provide this when requestUnsandboxedExecution is true."
-        }
-    } : {};
-    return {
-        id: TerminalToolId.RunInTerminal,
-        toolReferenceName: TOOL_REFERENCE_NAME,
-        legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(14482, "Run in Terminal")),
-        modelDescription: `${modelDescription}\n\nExecution mode:\n- mode='sync': wait for completion (optionally capped by timeout); if still running when timeout elapses, 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\nTimeout parameter: For one-shot long-running commands, set a generous timeout as a safety net (e.g. 600000 for installs, longer for big builds). Omit timeout only for processes that should run indefinitely (servers, daemons). If the timeout elapses, you get a terminal ID and can check output later.\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. Do NOT poll or sleep to wait for completion.`,
-        userDescription: ( localize(14483, "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: "Optional hard cap in milliseconds on how long the tool tracks the command before returning. Omit to let the command run to completion (recommended for package installs, builds, and long-running scripts). Use 0 to explicitly indicate no timeout."
-                }
-            },
-            required: ["command", "explanation", "goal", "mode"]
-        }
-    };
-}
-var TerminalToolStorageKeysInternal;
-(function(TerminalToolStorageKeysInternal) {
-    TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
-})(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
-function shouldAutomaticallyRetryUnsandboxed(options) {
-    return options.allowUnsandboxedCommands && 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(14484, "The command opened the alternate buffer."));
-let RunInTerminalTool = class RunInTerminalTool extends Disposable {
-    static {
-        RunInTerminalTool_1 = this;
-    }
-    static {
-        this._activeExecutions = ( new Map());
-    }
-    static {
-        this._killedByTool = ( new Set());
-    }
-    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;
-    }
-    static markKilledByTool(id) {
-        RunInTerminalTool_1._killedByTool.add(id);
-    }
-    _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 _allowUnsandboxedCommands() {
-        return this._configurationService.getValue(AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands) === true;
-    }
-    get _autoApproveUnsandboxedCommands() {
-        return this._allowUnsandboxedCommands && this._configurationService.getValue(AgentSandboxSettingId.AgentSandboxAutoApproveUnsandboxedCommands) === true;
-    }
-    get _allowSandboxAutoApprove() {
-        return this._configurationService.getValue(AgentSandboxSettingId.AgentSandboxAllowAutoApprove) === true;
-    }
-    _getAllowToRunUnsandboxedCommands(args) {
-        return (args.allowToRunUnsandboxedCommands ?? this._allowUnsandboxedCommands) === true && this._allowUnsandboxedCommands;
-    }
-    _shouldRejectUnsandboxedExecutionRequest(isSandboxEnabled, allowUnsandboxedCommands, args) {
-        return isSandboxEnabled && args.requestUnsandboxedExecution === true && !allowUnsandboxedCommands;
-    }
-    _getUnsandboxedExecutionDisabledMessage() {
-        return localize(
-            14485,
-            "The command was not executed because it requested to run outside the terminal sandbox, but running commands outside the sandbox is disabled by chat.agent.sandbox.allowUnsandboxedCommands. Run the command in the sandbox instead, or enable the setting to allow unsandboxed execution."
-        );
-    }
-    get _enableCommandLineSandboxRewriting() {
-        return true;
-    }
-    constructor(
-        _chatService,
-        _configurationService,
-        _fileService,
-        _historyService,
-        _instantiationService,
-        _labelService,
-        _languageModelToolsService,
-        _remoteAgentService,
-        _storageService,
-        _terminalChatService,
-        _logService,
-        _terminalService,
-        _terminalSandboxService,
-        _workspaceContextService,
-        _chatWidgetService,
-        _agentSessionsService,
-        lifecycleService
-    ) {
-        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._isShuttingDown = false;
-        this._register(lifecycleService.onWillShutdown(() => {
-            this._isShuttingDown = true;
-        }));
-        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._treeSitterCommandParser)
-            ));
-        }
-        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(14486, "Running `{0}`", escapeMarkdownSyntaxTokens(truncatedCommand)))));
-            return {
-                invocationMessage
-            };
-        }
-        return {
-            invocationMessage: ( localize(14487, "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 sessionModel = chatSessionResource ? this._chatService.getSession(chatSessionResource) : undefined;
-                if (sessionModel?.workingDirectory) {
-                    cwd = sessionModel.workingDirectory;
-                } else {
-                    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 isSandboxEnabled = sandboxPrereqs.enabled;
-        const allowUnsandboxedCommands = this._getAllowToRunUnsandboxedCommands(args);
-        const explicitUnsandboxRequest = isSandboxEnabled && allowUnsandboxedCommands && 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()}`;
-        if (this._shouldRejectUnsandboxedExecutionRequest(isSandboxEnabled, allowUnsandboxedCommands, args)) {
-            const commandToDisplay = normalizeTerminalCommandForDisplay(args.command);
-            return {
-                invocationMessage: ( new MarkdownString(( localize(
-                    14488,
-                    "Not running `{0}` because unsandboxed execution is disabled",
-                    escapeMarkdownSyntaxTokens(buildCommandDisplayText(commandToDisplay))
-                )))),
-                icon: Codicon.error,
-                confirmationMessages: undefined,
-                toolSpecificData: {
-                    kind: "terminal",
-                    terminalToolSessionId,
-                    terminalCommandId,
-                    commandLine: {
-                        original: args.command,
-                        forDisplay: commandToDisplay
-                    },
-                    cwd,
-                    language,
-                    isBackground: executionOptions.persistentSession,
-                    requestUnsandboxedExecution: false,
-                    requestUnsandboxedExecutionReason: undefined
-                }
-            };
-        }
-        const rewriteResult = await this._rewriteCommandLine(args.command, {
-            cwd,
-            shell,
-            os,
-            isBackground: executionOptions.persistentSession,
-            requestUnsandboxedExecution: allowUnsandboxedCommands ? requiresUnsandboxConfirmation : false,
-            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(14489, "Missing Sandbox Dependencies")),
-                message: ( new MarkdownString(( localize(
-                    14490,
-                    "The following dependencies required for sandboxed execution are not installed: {0}. Would you like to install them?",
-                    depsList
-                )))),
-                customOptions: [{
-                    id: "install",
-                    label: ( localize(14491, "Install")),
-                    kind: ConfirmationOptionKind.Approve
-                }, {
-                    id: "cancel",
-                    label: ( localize(14492, "Cancel")),
-                    kind: ConfirmationOptionKind.Deny
-                }]
-            };
-        }
-        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,
-            hasSessionAutoApproval: !!chatSessionResource && this._terminalChatService.hasChatSessionAutoApproval(chatSessionResource)
-        };
-        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 isUnsandboxedAutoApproved = isSandboxEnabled && requiresUnsandboxConfirmation === true && this._autoApproveUnsandboxedCommands;
-        const isSandboxAutoApproved = isSandboxEnabled && toolSpecificData.commandLine.isSandboxWrapped === true && this._allowSandboxAutoApprove;
-        const isFinalAutoApproved = isUnsandboxedAutoApproved || isSandboxAutoApproved || 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(14493, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
-        } else {
-            toolSpecificData.confirmation = {
-                commandLine: commandToDisplay
-            };
-            confirmationTitle = ( localize(14494, "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(
-                            14495,
-                            "Run `{0}` command in `{1}` within `{2}`?",
-                            presenterResult.languageDisplayName,
-                            shellType,
-                            toolSpecificData.confirmation.cwdLabel
-                        ));
-                    } else {
-                        confirmationTitle = ( localize(
-                            14496,
-                            "Run command in `{0}` within `{1}`?",
-                            shellType,
-                            toolSpecificData.confirmation.cwdLabel
-                        ));
-                    }
-                } else {
-                    if (presenterResult.languageDisplayName) {
-                        confirmationTitle = ( localize(
-                            14497,
-                            "Run `{0}` command in `{1}`?",
-                            presenterResult.languageDisplayName,
-                            shellType
-                        ));
-                    } else {
-                        confirmationTitle = ( localize(14498, "Run command in `{0}`?", shellType));
-                    }
-                }
-                if (!presenterResult.processOtherPresenters) {
-                    break;
-                }
-                presenterInput = presenterResult.commandLine;
-            }
-        }
-        if (requiresUnsandboxConfirmation) {
-            confirmationTitle = blockedDomains?.length ? ( localize(
-                14499,
-                "Run `{0}` command outside the [sandbox]({1}) to access {2}?",
-                shellType,
-                TERMINAL_SANDBOX_DOCUMENTATION_URL,
-                this._formatBlockedDomainsForTitle(blockedDomains)
-            )) : ( localize(
-                14500,
-                "Run `{0}` command outside the [sandbox]({1})?",
-                shellType,
-                TERMINAL_SANDBOX_DOCUMENTATION_URL
-            ));
-        }
-        const shouldShowConfirmation = (!isFinalAutoApproved && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
-        const explanation = args.explanation || ( localize(14501, "No explanation provided"));
-        const goal = args.goal || ( localize(14502, "No goal provided"));
-        const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
-            14503,
-            "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
-            explanation,
-            goal,
-            requestUnsandboxedExecutionReason || ( localize(14504, "The model indicated that this command needs unsandboxed access."))
-        )))) : ( new MarkdownString(( localize(14505, "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(
-            14506,
-            "Running `{0}` in sandbox",
-            escapeMarkdownSyntaxTokens(displayCommand)
-        )))) : ( new MarkdownString(( localize(14507, "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(
-            14508,
-            "`{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(
-                    14509,
-                    "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains.",
-                    blockedDomains[0]
-                );
-            }
-            return localize(
-                14510,
-                "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(
-                    14511,
-                    "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
-                    blockedDomains[0]
-                );
-            }
-            return localize(
-                14512,
-                "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(
-                14513,
-                "This command accesses {0}, which is not permitted by the current chat.agent.sandbox configuration.",
-                blockedDomains[0]
-            );
-        }
-        return localize(
-            14514,
-            "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, riskAssessment, token) {
-        if (this._autoApproveUnsandboxedCommands) {
-            return true;
-        }
-        const chatModel = sessionResource && this._chatService.getSession(sessionResource);
-        if (!(chatModel instanceof ChatModel)) {
-            return false;
-        }
-        if (sessionResource && isSessionAutoApproveLevel(
-            sessionResource,
-            this._configurationService,
-            this._chatWidgetService,
-            this._chatService
-        )) {
-            return true;
-        }
-        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(
-                14515,
-                "`{0}`",
-                escapeMarkdownSyntaxTokens(buildCommandDisplayText(command))
-            )))),
-                "",
-                ( localize(14516, "Allow")),
-                ( localize(14517, "Skip")),
-                async () => {
-                    resolveOnce(true);
-                    part.hide();
-                    return ElicitationState.Accepted;
-                },
-                async () => {
-                    resolveOnce(false);
-                    part.hide();
-                    return ElicitationState.Rejected;
-                },
-                undefined,
-                undefined,
-                () => resolveOnce(false),
-                riskAssessment
-            ));
-            chatModel.acceptResponseProgress(request, part);
-            store.add(token.onCancellationRequested(() => resolveOnce(false)));
-            store.add({
-                dispose: () => part.hide()
-            });
-        }));
-    }
-    _getAutomaticUnsandboxRetryTitle(shellType, blockedDomains) {
-        return blockedDomains?.length ? ( new MarkdownString(( localize(
-            14518,
-            "Run `{0}` command outside the sandbox to access {1}?",
-            shellType,
-            this._formatBlockedDomainsForTitle(blockedDomains)
-        )))) : ( new MarkdownString(( localize(14519, "Run `{0}` command outside the sandbox?", shellType))));
-    }
-    _registerSensitiveInputElicitation(
-        chatSessionResource,
-        terminalInstance,
-        outputMonitor,
-        cancelExecution,
-        onAutoCancelled
-    ) {
-        const store = ( new DisposableStore());
-        let pending;
-        let autoCancelled = false;
-        store.add(outputMonitor.onDidDetectSensitiveInputNeeded(() => {
-            if (pending || autoCancelled) {
-                return;
-            }
-            const isAutoApproved = chatSessionResource && isSessionAutoApproveLevel(
-                chatSessionResource,
-                this._configurationService,
-                this._chatWidgetService,
-                this._chatService
-            );
-            const chatModel = chatSessionResource && this._chatService.getSession(chatSessionResource);
-            if (isAutoApproved) {
-                autoCancelled = true;
-                if (chatModel instanceof ChatModel) {
-                    const request = chatModel.getRequests().at(-1);
-                    if (request) {
-                        const infoPart = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14520, "Terminal command cancelled — sensitive input required")))), ( new MarkdownString(( localize(
-                            14521,
-                            "The terminal command was prompting for a password or other secret. Auto-approve / autopilot mode cannot safely supply secrets, so the command was cancelled. Run the command interactively if you want to provide the secret."
-                        )))), "", ( localize(14522, "Dismiss")), "", async () => {
-                            infoPart.hide();
-                            return ElicitationState.Accepted;
-                        }, async () => {
-                            infoPart.hide();
-                            return ElicitationState.Rejected;
-                        }, undefined, undefined, undefined, undefined));
-                        chatModel.acceptResponseProgress(request, infoPart);
-                    }
-                }
-                onAutoCancelled?.();
-                cancelExecution();
-                return;
-            }
-            if (!(chatModel instanceof ChatModel)) {
-                this._terminalService.setActiveInstance(terminalInstance);
-                this._terminalService.revealTerminal(terminalInstance, true).catch(() => {});
-                terminalInstance.focus();
-                return;
-            }
-            const request = chatModel.getRequests().at(-1);
-            if (!request) {
-                return;
-            }
-            const part = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14523, "Terminal is waiting for sensitive input")))), ( new MarkdownString(( localize(
-                14524,
-                "The terminal command appears to be prompting for a password or other sensitive value. Focus the terminal to type it directly — secrets must not be sent through chat."
-            )))), "", ( localize(14525, "Focus Terminal")), ( localize(14526, "Cancel Command")), async () => {
-                pending = undefined;
-                part.hide();
-                try {
-                    this._terminalService.setActiveInstance(terminalInstance);
-                    await this._terminalService.revealTerminal(terminalInstance, true);
-                    terminalInstance.focus();
-                } catch (err) {
-                    this._logService.warn(`RunInTerminalTool: failed to reveal terminal for sensitive input`, err);
-                }
-                return ElicitationState.Accepted;
-            }, async () => {
-                pending = undefined;
-                part.hide();
-                cancelExecution();
-                return ElicitationState.Rejected;
-            }, undefined, undefined, () => {
-                pending = undefined;
-            }, undefined));
-            pending = part;
-            chatModel.acceptResponseProgress(request, part);
-        }));
-        return store;
-    }
-    _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(14482, "Run in Terminal")),
-            isComplete,
-            invocationMessage: ( new MarkdownString(( localize(
-                14527,
-                "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
-                }]
-            };
-        }
-        const args = invocation.parameters;
-        const allowUnsandboxedCommands = this._getAllowToRunUnsandboxedCommands(args);
-        const isSandboxEnabled = await this._terminalSandboxService.isEnabled();
-        if (this._shouldRejectUnsandboxedExecutionRequest(isSandboxEnabled, allowUnsandboxedCommands, args)) {
-            const message = this._getUnsandboxedExecutionDisabledMessage();
-            return {
-                toolResultError: message,
-                toolResultDetails: {
-                    input: args.command,
-                    output: [{
-                        type: "embed",
-                        isText: true,
-                        value: message
-                    }],
-                    isError: true
-                },
-                content: [{
-                    kind: "text",
-                    value: message
-                }]
-            };
-        }
-        if (toolSpecificData.missingSandboxDependencies?.length) {
-            if (invocation.selectedCustomButton === "install") {
-                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(
-                                14528,
-                                "Sandbox dependency installation failed (exit code {0}). The command was not executed.",
-                                exitCode
-                            ))
-                        }]
-                    };
-                }
-                if (exitCode === undefined) {
-                    return {
-                        content: [{
-                            kind: "text",
-                            value: ( localize(
-                                14529,
-                                "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(14530, "Sandbox dependency installation was cancelled by the user."))
-                    }]
-                };
-            }
-        }
-        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) {
-            args.timeout = 0;
-        }
-        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 commandLineForMetadata = isSandboxEnabled ? toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.original : undefined;
-        if (token.isCancellationRequested) {
-            throw ( new CancellationError());
-        }
-        let error;
-        const automaticUnsandboxRetryReason = ( localize(
-            14531,
-            "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 didIdleSilence = false;
-        let didInputNeeded = false;
-        let didSensitiveAutoCancelled = 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;
-                    resultText += `\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "none")}`;
-                } 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());
-                startMarkerPromise.then(() => {
-                    if (outputMonitor && !raceCleanup.isDisposed) {
-                        raceCleanup.add(this._registerSensitiveInputElicitation(
-                            chatSessionResource,
-                            toolTerminal.instance,
-                            outputMonitor,
-                            () => executeCancellation.cancel(),
-                            () => {
-                                didSensitiveAutoCancelled = true;
-                            }
-                        ));
-                    }
-                });
-                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 idleSilenceMs = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdleSilenceTimeoutMs) ?? 60000;
-                if (idleSilenceMs > 0) {
-                    const idleSilenceDeferred = ( new DeferredPromise());
-                    const idleSilenceScheduler = raceCleanup.add(( new RunOnceScheduler(() => idleSilenceDeferred.complete({
-                        type: "idleSilence"
-                    }), idleSilenceMs)));
-                    raceCleanup.add(toolTerminal.instance.onData(() => idleSilenceScheduler.schedule()));
-                    idleSilenceScheduler.schedule();
-                    raceCandidates.push(idleSilenceDeferred.p);
-                }
-                let raceResult;
-                try {
-                    raceResult = await Promise.race(raceCandidates);
-                } finally {
-                    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;
-                    toolSpecificData.didContinueInBackground = 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 if (raceResult.type === "idleSilence") {
-                    this._logService.debug(
-                        `RunInTerminalTool: Idle silence reached (${idleSilenceMs}ms), promoting to background`
-                    );
-                    error = "idleSilence";
-                    didIdleSilence = true;
-                    isBackgroundExecution = true;
-                    toolTerminal.isBackground = true;
-                    toolSpecificData.didContinueInBackground = true;
-                    this._sessionTerminalAssociations.delete(chatSessionResource);
-                    await this._associateProcessIdWithSession(
-                        toolTerminal.instance,
-                        chatSessionResource,
-                        termId,
-                        toolTerminal.shellIntegrationQuality,
-                        true
-                    );
-                    const idleSilenceOutput = execution.getOutput();
-                    outputLineCount = idleSilenceOutput ? count(idleSilenceOutput.trim(), "\n") + 1 : 0;
-                    terminalResult = idleSilenceOutput ?? "";
-                } 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;
-                toolSpecificData.didContinueInBackground = 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) {
-                    const alreadyNotifiedInputNeededOutput = didInputNeeded ? terminalResult : undefined;
-                    this._registerCompletionNotification(
-                        toolTerminal.instance,
-                        termId,
-                        chatSessionResource,
-                        command,
-                        toolSpecificData,
-                        outputMonitor,
-                        alreadyNotifiedInputNeededOutput
-                    );
-                } 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({
-            allowUnsandboxedCommands,
-            didSandboxWrapCommand,
-            requestUnsandboxedExecution: args.requestUnsandboxedExecution === true,
-            isPersistentSession: executionOptions.persistentSession,
-            isBackgroundExecution: isBackgroundExecution || didInputNeeded,
-            didTimeout,
-            exitCode,
-            output: terminalResult
-        });
-        if (shouldAutoRetryUnsandboxed) {
-            const requestUnsandboxedExecution = allowUnsandboxedCommands;
-            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,
-                requestUnsandboxedExecutionReason: retryReason
-            });
-            const rewrittenRetryReason = retryRewriteResult.requestUnsandboxedExecutionReason ?? retryReason;
-            const retryConfirmationCommand = toolSpecificData.presentationOverrides?.commandLine ?? command;
-            const retryRiskAssessment = {
-                toolId: TerminalToolId.RunInTerminal,
-                parameters: {
-                    ...args,
-                    command: retryRewriteResult.rewrittenCommand,
-                    allowToRunUnsandboxedCommands: allowUnsandboxedCommands,
-                    requestUnsandboxedExecution
-                }
-            };
-            const shouldRetry = await this._confirmAutomaticUnsandboxRetry(
-                invocation.context.sessionResource,
-                retryConfirmationCommand,
-                shell,
-                retryRewriteResult.blockedDomains,
-                retryRiskAssessment,
-                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,
-                    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,
-                        allowToRunUnsandboxedCommands: allowUnsandboxedCommands,
-                        requestUnsandboxedExecution,
-                        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}\` (terminal ID=${termId}), and this is the output of running that command instead:\n`
-                );
-            } else if (didToolEditCommand) {
-                const wasDetachedToBackground = /(^|\s)nohup\s|Start-Process\b/.test(command);
-                const stdinHint = wasDetachedToBackground ? " Note that stdin is closed for detached background processes; do not try to send input via send_to_terminal — re-run with mode=\"sync\" instead if interactive input is required." : "";
-                resultText.push(
-                    `Note: The tool simplified the command to \`${command}\` (terminal ID=${termId}).${stdinHint} 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`
-                );
-            }
-        }
-        if (didSensitiveAutoCancelled) {
-            resultText.push(
-                `Note: The command in terminal ID ${termId} was prompting for a password, passphrase, or other secret. The user is unavailable (auto-approve / autopilot mode is on, so no human can focus the terminal to type a secret) and the command has been cancelled. Stop, do NOT retry the command, do NOT call ${TerminalToolId.SendToTerminal}, and do NOT call vscode_askQuestions for the secret. Tell the user to run the command interactively when they are available.\n\n`
-            );
-        } else if (didInputNeeded) {
-            resultText.push(
-                `Note: The command is running in terminal ID ${termId} and may be waiting for input.\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "none")}\n\n`
-            );
-        } else if (didTimeout && timeoutValue !== undefined && timeoutValue > 0) {
-            const notificationHint = shouldSendNotifications ? " You will be automatically notified on your next turn when it completes." : "";
-            resultText.push(
-                `Note: Command timed out after ${timeoutValue}ms. The command may still be running in terminal ID ${termId}.${notificationHint}\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "timeout")}\n\n`
-            );
-        } else if (didIdleSilence) {
-            const notificationHint = shouldSendNotifications ? " You will be automatically notified on your next turn when it completes." : "";
-            resultText.push(
-                `Note: The command produced no new output for an extended period and was moved to background terminal ID ${termId}; the process is still running and has not been killed.${notificationHint}\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "idleSilence")}\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,
-                inputNeeded: didInputNeeded || undefined
-            },
-            toolResultDetails: isError ? {
-                input: command,
-                output: [{
-                    type: "embed",
-                    isText: true,
-                    value: terminalResult
-                }],
-                isError: true
-            } : undefined,
-            content: [{
-                kind: "text",
-                value: resultText.join("")
-            }, ...imageContent]
-        };
-    }
-    _buildInputNeededSteeringText(chatSessionResource, termId, hungHint) {
-        const isAutoApproved = isSessionAutoApproveLevel(
-            chatSessionResource,
-            this._configurationService,
-            this._chatWidgetService,
-            this._chatService
-        );
-        const lines = [];
-        lines.push(
-            `This note is not a signal to end the turn — pick one of the actions below and continue.`
-        );
-        if (isAutoApproved) {
-            lines.push(
-                `  1. If the output clearly ends with a non-secret input prompt (Continue? (y/n), Enter selection, etc. — a normal shell prompt like \`$\` or \`#\` does NOT count), determine the answer and immediately call ${TerminalToolId.SendToTerminal} with id="${termId}" (which returns the next few lines of output). Repeat one prompt at a time. Never guess passwords, passphrases, tokens, or other secrets — if the prompt requires a secret you do not have, inform the user and stop.`
-            );
-            lines.push(
-                `  2. If the command may still be producing output or the shell prompt has not returned, call ${TerminalToolId.GetTerminalOutput} with id="${termId}" to continue polling.`
-            );
-        } else {
-            lines.push(
-                `  1. If the command may still be producing output or the shell prompt has not returned, call ${TerminalToolId.GetTerminalOutput} with id="${termId}" to continue polling. This is the default and safest action when unsure.`
-            );
-            lines.push(
-                `  2. Only if the output clearly ends with a real non-secret input prompt (Continue? (y/n), Enter selection, etc. — a normal shell prompt like \`$\` or \`#\` does NOT count), call the vscode_askQuestions tool to ask the user, then send each answer using ${TerminalToolId.SendToTerminal} with id="${termId}" (which returns the next few lines of output). Repeat one prompt at a time. NEVER route secret prompts (passwords, passphrases, tokens, API keys, etc.) through vscode_askQuestions — answers to that tool are sent through the model. For secret prompts, tell the user to type the value directly into the terminal and stop.`
-            );
-        }
-        if (hungHint === "timeout") {
-            lines.push(
-                `  3. A timeout does not mean the command failed — call ${TerminalToolId.GetTerminalOutput} with id="${termId}" to continue polling. Only call ${TerminalToolId.KillTerminal} if the command is genuinely hung and you need to retry with a different approach.`
-            );
-        } else if (hungHint === "idleSilence") {
-            lines.push(
-                `  3. Producing no output for an extended period does not mean the command failed — call ${TerminalToolId.GetTerminalOutput} with id="${termId}" to continue polling. Only call ${TerminalToolId.KillTerminal} if the command is genuinely hung and you need to retry with a different approach.`
-            );
-        }
-        return lines.join("\n");
-    }
-    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) {
-                if (cachedTerminal.instance.exitCode !== undefined) {
-                    this._logService.info(
-                        `RunInTerminalTool: Cached terminal shell has exited (code=${cachedTerminal.instance.exitCode}), creating a new terminal`
-                    );
-                    this._sessionTerminalAssociations.delete(chatSessionResource);
-                } else {
-                    this._logService.debug(
-                        `RunInTerminalTool: Using cached terminal with session resource \`${chatSessionResource}\``
-                    );
-                    this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
-                    this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, cachedTerminal.instance);
-                    this._backgroundNotifications.deleteAndDispose(cachedTerminal.instance.instanceId);
-                    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,
-        toolSpecificData,
-        outputMonitor,
-        alreadyNotifiedInputNeededOutput
-    ) {
-        const notificationKey = terminalInstance.instanceId;
-        this._backgroundNotifications.deleteAndDispose(notificationKey);
-        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(notificationKey);
-        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 = alreadyNotifiedInputNeededOutput ?? "";
-            let lastInputNeededNotificationTime = alreadyNotifiedInputNeededOutput !== undefined ? Date.now() : 0;
-            const bgCts = ( new CancellationTokenSource());
-            store.add(toDisposable(() => {
-                bgCts.cancel();
-                bgCts.dispose();
-            }));
-            store.add(outputMonitor);
-            outputMonitor.continueMonitoringAsync(bgCts.token);
-            store.add(
-                this._registerSensitiveInputElicitation(chatSessionResource, terminalInstance, outputMonitor, () => {
-                    const execution = RunInTerminalTool_1._activeExecutions.get(termId);
-                    execution?.dispose();
-                })
-            );
-            store.add(outputMonitor.onDidDetectInputNeeded(() => {
-                if (userIsReplyingDirectly) {
-                    this._logService.debug(
-                        `RunInTerminalTool: Suppressing input-needed notification for terminal ${termId} because user is replying directly`
-                    );
-                    return;
-                }
-                if (terminalInstance.isDisposed) {
-                    this._logService.debug(
-                        `RunInTerminalTool: Suppressing input-needed notification for terminal ${termId} because the terminal is disposed`
-                    );
-                    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 inputAction = this._buildInputNeededSteeringText(chatSessionResource, termId, "none");
-                const message = `[Terminal ${termId} notification: command may be waiting for input — assess the output below.]\n${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(14532, "`{0}` may need 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 isUserVisible = this._terminalService.foregroundInstances.includes(terminalInstance);
-            const message = isUserVisible ? `[Terminal ${termId} notification: command completed${exitCodeText}. Use send_to_terminal to send another command or kill_terminal to stop it.]\nTerminal output:\n${currentOutput}` : `[Terminal ${termId} notification: command completed${exitCodeText}. The terminal has been cleaned up.]\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(14533, "`{0}` completed", commandName)),
-                terminalExecutionId: termId
-            }).catch(e => {
-                this._logService.warn(
-                    `RunInTerminalTool: Failed to send completion notification for terminal ${termId}`,
-                    e
-                );
-            });
-            this._commandArtifactCollector.capture(toolSpecificData, terminalInstance, command.id).then(() => {
-                if (this._terminalService.foregroundInstances.includes(terminalInstance)) {
-                    this._logService.debug(
-                        `RunInTerminalTool: Background terminal ${termId} was revealed by user, skipping disposal`
-                    );
-                    return;
-                }
-                this._logService.debug(`RunInTerminalTool: Disposing finished background terminal ${termId}`);
-                RunInTerminalTool_1._killedByTool.add(termId);
-                execution.dispose();
-                RunInTerminalTool_1._activeExecutions.delete(termId);
-                terminalInstance.dispose();
-            });
-        }));
-        const executionForDisposal = RunInTerminalTool_1._activeExecutions.get(termId);
-        store.add(terminalInstance.onDisposed(() => {
-            if (( RunInTerminalTool_1._killedByTool.has(termId))) {
-                disposeNotification();
-                return;
-            }
-            if (this._isShuttingDown) {
-                disposeNotification();
-                return;
-            }
-            if (handleSessionCancelled()) {
-                return;
-            }
-            const currentOutput = executionForDisposal?.getOutput() ?? "";
-            const exitCode = terminalInstance.exitCode;
-            const exitCodeText = exitCode !== undefined ? ` with exit code ${exitCode}` : "";
-            disposeNotification();
-            const message = `[Terminal ${termId} notification: terminal exited${exitCodeText}. The terminal process ended before the command could complete normally; further commands cannot be sent to this terminal ID.]\nTerminal output:\n${currentOutput}`;
-            this._logService.debug(
-                `RunInTerminalTool: Background terminal ${termId} disposed${exitCodeText}, notifying chat session`
-            );
-            this._chatService.sendRequest(chatSessionResource, message, {
-                ...sendOptions,
-                queue: ChatRequestQueueKind.Steering,
-                isSystemInitiated: true,
-                systemInitiatedLabel: ( localize(14534, "`{0}` terminal exited", commandName)),
-                terminalExecutionId: termId
-            }).catch(e => {
-                this._logService.warn(
-                    `RunInTerminalTool: Failed to send terminal-exited notification for terminal ${termId}`,
-                    e
-                );
-            });
-        }));
-        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(notificationKey, 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)), ( __param(16, ILifecycleService))], 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) {
-        const isSyncMode = !this._isBackground;
-        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,
-                isSyncMode
-            );
-        }
-    }
-    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 };