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

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

@@ -10,8 +10,8 @@ const GetTerminalOutputToolData = {
     id: TerminalToolId.GetTerminalOutput,
     toolReferenceName: "getTerminalOutput",
     legacyToolReferenceFullNames: ["runCommands/getTerminalOutput"],
-    displayName: ( localize(13820, "Get Terminal Output")),
-    modelDescription: `Get the output of a terminal command previously started with ${TerminalToolId.RunInTerminal}`,
+    displayName: ( localize(13884, "Get Terminal Output")),
+    modelDescription: `Get the output of a background terminal command previously started with ${TerminalToolId.RunInTerminal}. The ID must be the exact opaque value returned by ${TerminalToolId.RunInTerminal} when isBackground=true; terminal names, labels, and integers are not valid IDs.`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
     inputSchema: {
@@ -19,7 +19,8 @@ const GetTerminalOutputToolData = {
         properties: {
             id: {
                 type: "string",
-                description: "The ID of the terminal to check."
+                description: `The ID of the background terminal to check (returned by ${TerminalToolId.RunInTerminal} when isBackground=true). This must be the exact opaque ID returned by that tool; terminal names, labels, or integers are invalid.`,
+                pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"
             }
         },
         required: ["id"]
@@ -28,16 +29,25 @@ const GetTerminalOutputToolData = {
 class GetTerminalOutputTool extends Disposable {
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(13821, "Checking background terminal output")),
-            pastTenseMessage: ( localize(13822, "Checked background terminal output"))
+            invocationMessage: ( localize(13885, "Checking background terminal output")),
+            pastTenseMessage: ( localize(13886, "Checked background terminal output"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const args = invocation.parameters;
+        const execution = RunInTerminalTool.getExecution(args.id);
+        if (!execution) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Error: No active terminal execution found with ID ${args.id}. The ID must be the exact value returned by ${TerminalToolId.RunInTerminal} for a background command.`
+                }]
+            };
+        }
         return {
             content: [{
                 kind: "text",
-                value: `Output of terminal ${args.id}:\n${RunInTerminalTool.getBackgroundOutput(args.id)}`
+                value: `Output of terminal ${args.id}:\n${execution.getOutput()}`
             }]
         };
     }

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

@@ -11,7 +11,7 @@ const GetTerminalSelectionToolData = {
     id: TerminalToolId.TerminalSelection,
     toolReferenceName: "terminalSelection",
     legacyToolReferenceFullNames: ["runCommands/terminalSelection"],
-    displayName: ( localize(13823, "Get Terminal Selection")),
+    displayName: ( localize(13887, "Get Terminal Selection")),
     modelDescription: "Get the current selection in the active terminal.",
     source: ToolDataSource.Internal,
     icon: Codicon.terminal
@@ -23,8 +23,8 @@ let GetTerminalSelectionTool = class GetTerminalSelectionTool extends Disposable
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(13824, "Reading terminal selection")),
-            pastTenseMessage: ( localize(13825, "Read terminal selection"))
+            invocationMessage: ( localize(13888, "Reading terminal selection")),
+            pastTenseMessage: ( localize(13889, "Read terminal selection"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {

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

@@ -9,7 +9,7 @@ import { TerminalToolId } from './toolIds.js';
 const KillTerminalToolData = {
     id: TerminalToolId.KillTerminal,
     toolReferenceName: "killTerminal",
-    displayName: ( localize(13826, "Kill Terminal")),
+    displayName: ( localize(13890, "Kill Terminal")),
     modelDescription: `Kill a terminal by its ID. Use this to clean up terminals that are no longer needed (e.g., after stopping a server or when a long-running task completes). The terminal ID is returned by ${TerminalToolId.RunInTerminal} when isBackground=true.`,
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
@@ -27,8 +27,8 @@ const KillTerminalToolData = {
 class KillTerminalTool extends Disposable {
     async prepareToolInvocation(_context, _token) {
         return {
-            invocationMessage: ( localize(13827, "Killing terminal")),
-            pastTenseMessage: ( localize(13828, "Killed terminal"))
+            invocationMessage: ( localize(13891, "Killing terminal")),
+            pastTenseMessage: ( localize(13892, "Killed terminal"))
         };
     }
     async invoke(invocation, _countTokens, _progress, _token) {

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

@@ -683,11 +683,11 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         const {
             promise: userPrompt,
             part
-        } = this._createElicitationPart(token, execution.sessionResource, ( new MarkdownString(( localize(13829, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
-            13830,
+        } = this._createElicitationPart(token, execution.sessionResource, ( new MarkdownString(( localize(13893, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
+            13894,
             "{0}\nPlease provide the required input to the terminal.\n\n",
             confirmationPrompt.prompt
-        )))), "", ( localize(13831, "Focus terminal")), undefined, () => {
+        )))), "", ( localize(13895, "Focus terminal")), undefined, () => {
             this._showInstance(execution.instance.instanceId);
             return focusTerminalSelection;
         });
@@ -740,13 +740,13 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         const {
             promise: userPrompt,
             part
-        } = this._createElicitationPart(token, execution.sessionResource, ( new MarkdownString(( localize(13832, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
-            13833,
+        } = this._createElicitationPart(token, execution.sessionResource, ( new MarkdownString(( localize(13896, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
+            13897,
             "{0}\n Do you want to send `{1}`{2} followed by `Enter` to the terminal?",
             confirmationPrompt.prompt,
             suggestedOptionValue,
             isString(suggestedOption) ? "" : suggestedOption.description ? " (" + suggestedOption.description + ")" : ""
-        )))), "", ( localize(13834, "Allow")), ( localize(13835, "Focus Terminal")), async value => {
+        )))), "", ( localize(13898, "Allow")), ( localize(13899, "Focus Terminal")), async value => {
             let option = undefined;
             if (value === true) {
                 option = suggestedOptionValue;
@@ -1001,9 +1001,9 @@ function detectsNonInteractiveHelpPattern(cursorLine) {
     ].some(e => e.test(cursorLine)));
 }
 const taskFinishMessages = [(
-localize(13836, "Terminal will be reused by tasks, press any key to close it.")), ( localize(13837, "Terminal will be reused by tasks, press any key to close it.")), (
-localize(13838, "Press any key to close the terminal.")), ( localize(13839, "Press any key to close the terminal.")), (
-localize(13840, "The terminal will be reused by tasks. Press any key to close."))];
+localize(13900, "Terminal will be reused by tasks, press any key to close it.")), ( localize(13901, "Terminal will be reused by tasks, press any key to close it.")), (
+localize(13902, "Press any key to close the terminal.")), ( localize(13903, "Press any key to close the terminal.")), (
+localize(13904, "The terminal will be reused by tasks. Press any key to close."))];
 const normalizedTaskFinishMessages = ( taskFinishMessages.map(msg => msg.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase()));
 function detectsVSCodeTaskFinishMessage(cursorLine) {
     const compact = cursorLine.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase();

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

@@ -7,7 +7,7 @@ import { TerminalToolId } from './toolIds.js';
 
 const ConfirmTerminalCommandToolData = {
     id: TerminalToolId.ConfirmTerminalCommand,
-    displayName: ( localize(13841, "Confirm Terminal Command")),
+    displayName: ( localize(13905, "Confirm Terminal Command")),
     modelDescription: [
         "This tool allows you to get explicit user confirmation for a terminal command without executing it.",
         "",
@@ -25,7 +25,7 @@ const ConfirmTerminalCommandToolData = {
         "",
         "After confirmation, use a tool to actually execute the command."
     ].join("\n"),
-    userDescription: ( localize(13842, "Tool for confirming terminal commands")),
+    userDescription: ( localize(13906, "Tool for confirming terminal commands")),
     source: ToolDataSource.Internal,
     icon: Codicon.shield,
     inputSchema: {

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

@@ -5,7 +5,7 @@ import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/
 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 { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Disposable, MutableDisposable, DisposableStore } 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';
@@ -65,9 +65,12 @@ import { TerminalChatCommandId } from '@codingame/monaco-vscode-xterm-common/vsc
 import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
 import { SandboxOutputAnalyzer } from './sandboxOutputAnalyzer.js';
 import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { TerminalSandboxPrerequisiteCheck } from '../../common/terminalSandboxService.js';
 import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
+import { LanguageModelPartAudience } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 
 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"];
 function createPowerShellModelDescription(shell, isSandboxEnabled, networkDomains) {
@@ -114,7 +117,8 @@ function createPowerShellModelDescription(shell, isSandboxEnabled, networkDomain
         "- 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"
+        "- Avoid printing credentials unless absolutely required",
+        `- NEVER run Start-Sleep or similar wait commands. If you need to wait for a background process, use ${TerminalToolId.AwaitTerminal} or ${TerminalToolId.GetTerminalOutput} instead`
     );
     return parts.join("\n");
 }
@@ -184,7 +188,8 @@ 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`);
+- Avoid printing credentials unless absolutely required
+- NEVER run sleep or similar wait commands in a terminal. If you need to wait for a background process, use ${TerminalToolId.AwaitTerminal} or ${TerminalToolId.GetTerminalOutput} instead`);
     return parts.join("");
 }
 function createBashModelDescription(isSandboxEnabled, networkDomains) {
@@ -245,9 +250,9 @@ async function createRunInTerminalToolData(accessor) {
         id: TerminalToolId.RunInTerminal,
         toolReferenceName: TOOL_REFERENCE_NAME,
         legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(13843, "Run in Terminal")),
+        displayName: ( localize(13907, "Run in Terminal")),
         modelDescription,
-        userDescription: ( localize(13844, "Run commands in the terminal")),
+        userDescription: ( localize(13908, "Run commands in the terminal")),
         source: ToolDataSource.Internal,
         icon: Codicon.terminal,
         inputSchema: {
@@ -267,7 +272,7 @@ async function createRunInTerminalToolData(accessor) {
                 },
                 isBackground: {
                     type: "boolean",
-                    description: `Whether the command starts a background process.\n\n- If true, a new shell will be spawned where the cwd is the workspace directory and will run asynchronously in the background and you will not see the output.\n\n- If false, a single shell is shared between all non-background terminals where the cwd starts at the workspace directory and is remembered until that terminal is moved to the background, the tool call will block on the command finishing and only then you will get the output.\n\nExamples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using ${TerminalToolId.GetTerminalOutput}.`
+                    description: `Whether the command starts a background process.\n\n- If true, a new shell will be spawned where the cwd is the workspace directory and will run asynchronously in the background and you will not see the output.\n\n- If false, a single shell is shared between all non-background terminals where the cwd starts at the workspace directory and is remembered until that terminal is moved to the background, the tool call will block on the command finishing and only then you will get the output.\n\nExamples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using ${TerminalToolId.GetTerminalOutput}. If unsure whether a command will be long-running, prefer isBackground=true.`
                 },
                 timeout: {
                     type: "number",
@@ -284,7 +289,7 @@ async function createRunInTerminalToolData(accessor) {
                     }
                 } : {})
             },
-            required: ["command", "explanation", "goal", "isBackground", "timeout"]
+            required: ["command", "explanation", "goal", "isBackground"]
         }
     };
 }
@@ -295,7 +300,7 @@ var TerminalToolStorageKeysInternal;
 const telemetryIgnoredSequences = [
 "\u001b[I",
 "\u001b[O"];
-const altBufferMessage = "\n" + ( localize(13845, "The command opened the alternate buffer."));
+const altBufferMessage = "\n" + ( localize(13909, "The command opened the alternate buffer."));
 let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     static {
         RunInTerminalTool_1 = this;
@@ -425,7 +430,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             this._removeTerminalAssociations(e);
         }));
         this._register(this._chatService.onDidDisposeSession(e => {
-            for (const resource of e.sessionResource) {
+            for (const resource of e.sessionResources) {
                 this._cleanupSessionTerminals(resource);
             }
         }));
@@ -435,13 +440,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (partialInput && typeof partialInput === "object" && partialInput.command) {
             const normalizedCommand = normalizeTerminalCommandForDisplay(partialInput.command).replace(/\r\n|\r|\n/g, " ");
             const truncatedCommand = normalizedCommand.length > 80 ? normalizedCommand.substring(0, 77) + "..." : normalizedCommand;
-            const invocationMessage = partialInput.isBackground ? ( new MarkdownString(( localize(13846, "Running `{0}` in background", truncatedCommand)))) : ( new MarkdownString(( localize(13847, "Running `{0}`", truncatedCommand))));
+            const invocationMessage = partialInput.isBackground ? ( new MarkdownString(( localize(13910, "Running `{0}` in background", truncatedCommand)))) : ( new MarkdownString(( localize(13911, "Running `{0}`", truncatedCommand))));
             return {
                 invocationMessage
             };
         }
         return {
-            invocationMessage: ( localize(13848, "Running command"))
+            invocationMessage: ( localize(13912, "Running command"))
         };
     }
     async prepareToolInvocation(context, token) {
@@ -454,7 +459,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 instance = toolTerminal.instance;
             }
         }
-        const [os, shell, cwd, isTerminalSandboxEnabled] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
+        const [os, shell, cwd, sandboxPrereqs] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
             let cwd = await instance?.getCwdResource();
             if (!cwd) {
                 const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
@@ -462,9 +467,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 cwd = workspaceFolder?.uri;
             }
             return cwd;
-        })(), this._terminalSandboxService.isEnabled()]);
+        })(), this._terminalSandboxService.checkForSandboxingPrereqs()]);
         const language = os === OperatingSystem.Windows ? "pwsh" : "sh";
+        const isTerminalSandboxEnabled = sandboxPrereqs.enabled;
         const requiresUnsandboxConfirmation = isTerminalSandboxEnabled && args.requestUnsandboxedExecution === true;
+        const missingDependencies = sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Dependencies && sandboxPrereqs.missingDependencies?.length ? sandboxPrereqs.missingDependencies : undefined;
         const terminalToolSessionId = generateUuid();
         const terminalCommandId = `tool-${generateUuid()}`;
         let rewrittenCommand = args.command;
@@ -503,8 +510,22 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             language,
             isBackground: args.isBackground,
             requestUnsandboxedExecution: requiresUnsandboxConfirmation,
-            requestUnsandboxedExecutionReason: args.requestUnsandboxedExecutionReason
+            requestUnsandboxedExecutionReason: args.requestUnsandboxedExecutionReason,
+            missingSandboxDependencies: missingDependencies
         };
+        let sandboxConfirmationMessageForMissingDeps = undefined;
+        if (missingDependencies) {
+            const depsList = missingDependencies.join(", ");
+            sandboxConfirmationMessageForMissingDeps = {
+                title: ( localize(13913, "Missing Sandbox Dependencies")),
+                message: ( new MarkdownString(( localize(
+                    13914,
+                    "The following dependencies required for sandboxed execution are not installed: {0}. Would you like to install them?",
+                    depsList
+                )))),
+                customButtons: [( localize(13915, "Install")), ( localize(13916, "Cancel"))]
+            };
+        }
         const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
         if (alternativeRecommendation) {
             toolSpecificData.alternativeRecommendation = alternativeRecommendation;
@@ -598,16 +619,16 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 cdPrefix
             };
             confirmationTitle = args.isBackground ? ( localize(
-                13849,
+                13917,
                 "Run `{0}` command in background within `{1}`?",
                 shellType,
                 directoryLabel
-            )) : ( localize(13850, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
+            )) : ( localize(13918, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
         } else {
             toolSpecificData.confirmation = {
                 commandLine: commandToDisplay
             };
-            confirmationTitle = args.isBackground ? ( localize(13851, "Run `{0}` command in background?", shellType)) : ( localize(13852, "Run `{0}` command?", shellType));
+            confirmationTitle = args.isBackground ? ( localize(13919, "Run `{0}` command in background?", shellType)) : ( localize(13920, "Run `{0}` command?", shellType));
         }
         const commandForPresenter = extractedCd?.command ?? commandToDisplay;
         let presenterInput = commandForPresenter;
@@ -626,31 +647,49 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     language: presenterResult.language ?? undefined
                 };
                 if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
-                    confirmationTitle = args.isBackground ? ( localize(
-                        13853,
-                        "Run `{0}` command in `{1}` in background within `{2}`?",
-                        presenterResult.languageDisplayName,
-                        shellType,
-                        toolSpecificData.confirmation.cwdLabel
-                    )) : ( localize(
-                        13854,
-                        "Run `{0}` command in `{1}` within `{2}`?",
-                        presenterResult.languageDisplayName,
-                        shellType,
-                        toolSpecificData.confirmation.cwdLabel
-                    ));
+                    if (presenterResult.languageDisplayName) {
+                        confirmationTitle = args.isBackground ? ( localize(
+                            13921,
+                            "Run `{0}` command in `{1}` in background within `{2}`?",
+                            presenterResult.languageDisplayName,
+                            shellType,
+                            toolSpecificData.confirmation.cwdLabel
+                        )) : ( localize(
+                            13922,
+                            "Run `{0}` command in `{1}` within `{2}`?",
+                            presenterResult.languageDisplayName,
+                            shellType,
+                            toolSpecificData.confirmation.cwdLabel
+                        ));
+                    } else {
+                        confirmationTitle = args.isBackground ? ( localize(
+                            13923,
+                            "Run command in `{0}` in background within `{1}`?",
+                            shellType,
+                            toolSpecificData.confirmation.cwdLabel
+                        )) : ( localize(
+                            13924,
+                            "Run command in `{0}` within `{1}`?",
+                            shellType,
+                            toolSpecificData.confirmation.cwdLabel
+                        ));
+                    }
                 } else {
-                    confirmationTitle = args.isBackground ? ( localize(
-                        13855,
-                        "Run `{0}` command in `{1}` in background?",
-                        presenterResult.languageDisplayName,
-                        shellType
-                    )) : ( localize(
-                        13856,
-                        "Run `{0}` command in `{1}`?",
-                        presenterResult.languageDisplayName,
-                        shellType
-                    ));
+                    if (presenterResult.languageDisplayName) {
+                        confirmationTitle = args.isBackground ? ( localize(
+                            13925,
+                            "Run `{0}` command in `{1}` in background?",
+                            presenterResult.languageDisplayName,
+                            shellType
+                        )) : ( localize(
+                            13926,
+                            "Run `{0}` command in `{1}`?",
+                            presenterResult.languageDisplayName,
+                            shellType
+                        ));
+                    } else {
+                        confirmationTitle = args.isBackground ? ( localize(13927, "Run command in `{0}` in background?", shellType)) : ( localize(13928, "Run command in `{0}`?", shellType));
+                    }
                 }
                 if (!presenterResult.processOtherPresenters) {
                     break;
@@ -659,16 +698,26 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
         }
         if (requiresUnsandboxConfirmation) {
-            confirmationTitle = args.isBackground ? ( localize(13857, "Run `{0}` command outside the sandbox in background?", shellType)) : ( localize(13858, "Run `{0}` command outside the sandbox?", shellType));
+            confirmationTitle = args.isBackground ? ( localize(
+                13929,
+                "Run `{0}` command outside the [sandbox]({1}) in background?",
+                shellType,
+                TERMINAL_SANDBOX_DOCUMENTATION_URL
+            )) : ( localize(
+                13930,
+                "Run `{0}` command outside the [sandbox]({1})?",
+                shellType,
+                TERMINAL_SANDBOX_DOCUMENTATION_URL
+            ));
         }
         const shouldShowConfirmation = (!isFinalAutoApproved && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
         const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
-            13859,
+            13931,
             "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
             args.explanation,
             args.goal,
-            args.requestUnsandboxedExecutionReason || ( localize(13860, "The model indicated that this command needs unsandboxed access."))
-        )))) : ( new MarkdownString(( localize(13861, "Explanation: {0}\n\nGoal: {1}", args.explanation, args.goal))));
+            args.requestUnsandboxedExecutionReason || ( localize(13932, "The model indicated that this command needs unsandboxed access."))
+        )))) : ( new MarkdownString(( localize(13933, "Explanation: {0}\n\nGoal: {1}", args.explanation, args.goal))));
         const confirmationMessages = shouldShowConfirmation ? {
             title: confirmationTitle,
             message: confirmationMessage,
@@ -678,12 +727,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         } : undefined;
         const rawDisplayCommand = toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
         const displayCommand = rawDisplayCommand.length > 80 ? rawDisplayCommand.substring(0, 77) + "..." : rawDisplayCommand;
-        const escapedDisplayCommand = escapeMarkdownSyntaxTokens(displayCommand);
-        const invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? args.isBackground ? ( new MarkdownString(( localize(13862, "Running `{0}` in sandbox in background", escapedDisplayCommand)))) : ( new MarkdownString(( localize(13863, "Running `{0}` in sandbox", escapedDisplayCommand)))) : args.isBackground ? ( new MarkdownString(( localize(13864, "Running `{0}` in background", escapedDisplayCommand)))) : ( new MarkdownString(( localize(13865, "Running `{0}`", escapedDisplayCommand))));
+        const invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? args.isBackground ? ( new MarkdownString(( localize(13934, "Running `{0}` in sandbox in background", displayCommand)))) : ( new MarkdownString(( localize(13935, "Running `{0}` in sandbox", displayCommand)))) : args.isBackground ? ( new MarkdownString(( localize(13936, "Running `{0}` in background", displayCommand)))) : ( new MarkdownString(( localize(13937, "Running `{0}`", displayCommand))));
         return {
             invocationMessage,
             icon: toolSpecificData.commandLine.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal,
-            confirmationMessages,
+            confirmationMessages: sandboxConfirmationMessageForMissingDeps ?? confirmationMessages,
             toolSpecificData
         };
     }
@@ -717,6 +765,56 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 }]
             };
         }
+        if (toolSpecificData.missingSandboxDependencies?.length) {
+            const installButton = ( localize(13915, "Install"));
+            if (invocation.selectedCustomButton === installButton) {
+                const sessionResource = invocation.context.sessionResource;
+                const {
+                    exitCode
+                } = await this._terminalSandboxService.installMissingSandboxDependencies(toolSpecificData.missingSandboxDependencies, sessionResource, token, {
+                    createTerminal: async () => this._terminalService.createTerminal({}),
+                    focusTerminal: async terminal => {
+                        this._terminalService.setActiveInstance(terminal);
+                        await this._terminalService.revealTerminal(terminal, true);
+                        terminal.focus();
+                    }
+                });
+                if (exitCode !== undefined && exitCode !== 0) {
+                    return {
+                        content: [{
+                            kind: "text",
+                            value: ( localize(
+                                13938,
+                                "Sandbox dependency installation failed (exit code {0}). The command was not executed.",
+                                exitCode
+                            ))
+                        }]
+                    };
+                }
+                if (exitCode === undefined) {
+                    return {
+                        content: [{
+                            kind: "text",
+                            value: ( localize(
+                                13939,
+                                "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(13940, "Sandbox dependency installation was cancelled by the user."))
+                    }]
+                };
+            }
+        }
         const args = invocation.parameters;
         this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
         let toolResultMessage;
@@ -1009,6 +1107,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 didUserEditCommand,
                 didToolEditCommand,
                 isBackground: args.isBackground,
+                isSandboxWrapped: toolSpecificData.commandLine.isSandboxWrapped === true,
                 shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
                 error,
                 isNewSession,
@@ -1052,7 +1151,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         if (didTimeout && timeoutValue !== undefined && timeoutValue > 0) {
             resultText.push(
-                `Note: Command timed out after ${timeoutValue}ms. Output collected so far is shown below and the command may still be running in terminal ID ${termId}.\n\n`
+                `Note: Command timed out after ${timeoutValue}ms and was moved to the background. The command may still be running in terminal ID ${termId}. Use ${TerminalToolId.AwaitTerminal} to wait for it to complete or ${TerminalToolId.GetTerminalOutput} to check its current output. Do NOT use sleep or manual polling to wait.\n\n`
             );
         }
         const outputAnalyzerMessage = await this._getOutputAnalyzerMessage(exitCode, terminalResult, command, didSandboxWrapCommand);
@@ -1139,7 +1238,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     value: {
                         mimeType,
                         data: fileContent.value
-                    }
+                    },
+                    audience: [LanguageModelPartAudience.User]
                 });
             } catch {}
         }

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

@@ -20,10 +20,10 @@ let SandboxOutputAnalyzer = class SandboxOutputAnalyzer extends Disposable {
             return undefined;
         }
         const os = await this._sandboxService.getOS();
-        const fileSystemSetting = os === OperatingSystem.Linux ? TerminalChatAgentToolsSettingId.TerminalSandboxLinuxFileSystem : TerminalChatAgentToolsSettingId.TerminalSandboxMacFileSystem;
+        const fileSystemSetting = os === OperatingSystem.Linux ? TerminalChatAgentToolsSettingId.AgentSandboxLinuxFileSystem : TerminalChatAgentToolsSettingId.AgentSandboxMacFileSystem;
         const prefix = knownFailure ? "Command failed while running in sandboxed mode. If the command failed due to sandboxing:" : "Command ran in sandboxed mode and may have been blocked by the sandbox. If the command failed due to sandboxing:";
         return `${prefix}
-- If it would be reasonable to extend the sandbox rules, work with the user to update allowWrite for file system access problems in ${fileSystemSetting}, or to add required domains to ${TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowedDomains}.
+- If it would be reasonable to extend the sandbox rules, work with the user to update allowWrite for file system access problems in ${fileSystemSetting}, or to add required domains to ${TerminalChatAgentToolsSettingId.AgentSandboxNetworkAllowedDomains}.
 - Otherwise, immediately retry the command with requestUnsandboxedExecution=true. Do NOT ask the user — setting this flag automatically shows a confirmation prompt to the user.
 
 Here is the output of the command:\n`;

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

@@ -79,7 +79,7 @@ let CreateAndRunTaskTool = class CreateAndRunTaskTool {
             });
         }
         _progress.report({
-            message: ( new MarkdownString(( localize(13866, "Resolving the task"))))
+            message: ( new MarkdownString(( localize(13941, "Resolving the task"))))
         });
         let task;
         const start = Date.now();
@@ -96,7 +96,7 @@ let CreateAndRunTaskTool = class CreateAndRunTaskTool {
                     kind: "text",
                     value: `Task not found: ${args.task.label}`
                 }],
-                toolResultMessage: ( new MarkdownString(( localize(13867, "Task not found: `{0}`", args.task.label))))
+                toolResultMessage: ( new MarkdownString(( localize(13942, "Task not found: `{0}`", args.task.label))))
             };
         }
         const preRunMarkersStore = ( new DisposableStore());
@@ -113,7 +113,7 @@ let CreateAndRunTaskTool = class CreateAndRunTaskTool {
                 }
             }
             _progress.report({
-                message: ( new MarkdownString(( localize(13868, "Running task `{0}`", args.task.label))))
+                message: ( new MarkdownString(( localize(13943, "Running task `{0}`", args.task.label))))
             });
             const raceResult = await Promise.race([
                 this._tasksService.run(task, undefined, TaskRunSource.ChatAgent),
@@ -131,7 +131,7 @@ let CreateAndRunTaskTool = class CreateAndRunTaskTool {
                         value: `Task started but no terminal was found for: ${args.task.label}`
                     }],
                     toolResultMessage: ( new MarkdownString(( localize(
-                        13869,
+                        13944,
                         "Task started but no terminal was found for: `{0}`",
                         args.task.label
                     ))))
@@ -201,26 +201,26 @@ let CreateAndRunTaskTool = class CreateAndRunTaskTool {
         const allTasks = await this._tasksService.tasks();
         if (allTasks?.find(t => t._label === task.label)) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13870, "Task `{0}` already exists.", task.label)))),
-                pastTenseMessage: ( new MarkdownString(( localize(13871, "Task `{0}` already exists.", task.label)))),
+                invocationMessage: ( new MarkdownString(( localize(13945, "Task `{0}` already exists.", task.label)))),
+                pastTenseMessage: ( new MarkdownString(( localize(13946, "Task `{0}` already exists.", task.label)))),
                 confirmationMessages: undefined
             };
         }
         const activeTasks = await this._tasksService.getActiveTasks();
         if (activeTasks.find(t => t._label === task.label)) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(13872, "Task `{0}` is already running.", task.label)))),
-                pastTenseMessage: ( new MarkdownString(( localize(13872, "Task `{0}` is already running.", task.label)))),
+                invocationMessage: ( new MarkdownString(( localize(13947, "Task `{0}` is already running.", task.label)))),
+                pastTenseMessage: ( new MarkdownString(( localize(13947, "Task `{0}` is already running.", task.label)))),
                 confirmationMessages: undefined
             };
         }
         return {
-            invocationMessage: ( new MarkdownString(( localize(13873, "Created task `{0}`", task.label)))),
-            pastTenseMessage: ( new MarkdownString(( localize(13874, "Created task `{0}`", task.label)))),
+            invocationMessage: ( new MarkdownString(( localize(13948, "Created task `{0}`", task.label)))),
+            pastTenseMessage: ( new MarkdownString(( localize(13949, "Created task `{0}`", task.label)))),
             confirmationMessages: {
-                title: ( localize(13875, "Allow task creation and execution?")),
+                title: ( localize(13950, "Allow task creation and execution?")),
                 message: ( new MarkdownString(( localize(
-                    13876,
+                    13951,
                     "A task `{0}` with command `{1}`{2} will be created.",
                     task.label,
                     task.command,
@@ -235,9 +235,9 @@ const CreateAndRunTaskToolData = {
     id: TerminalToolId.CreateAndRunTask,
     toolReferenceName: "createAndRunTask",
     legacyToolReferenceFullNames: ["runTasks/createAndRunTask"],
-    displayName: ( localize(13877, "Create and run Task")),
+    displayName: ( localize(13952, "Create and run Task")),
     modelDescription: "Creates and runs a build, run, or custom task for the workspace by generating or adding to a tasks.json file based on the project structure (such as package.json or README.md). If the user asks to build, run, launch and they have no tasks.json file, use this tool. If they ask to create or add a task, use this tool.",
-    userDescription: ( localize(13878, "Create and run a task in the workspace")),
+    userDescription: ( localize(13953, "Create and run a task in the workspace")),
     source: ToolDataSource.Internal,
     inputSchema: {
         "type": "object",