@codingame/monaco-vscode-chat-service-override 28.4.0 → 29.0.0

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

@@ -47,6 +47,9 @@ function truncateOutputKeepingTail(output, maxLength) {
     const endPortion = output.slice(-availableLength);
     return TRUNCATION_MESSAGE + endPortion;
 }
+function normalizeTerminalCommandForDisplay(commandLine) {
+    return commandLine.replace(/\\(["'\/])/g, "$1");
+}
 function generateAutoApproveActions(commandLine, subCommands, autoApproveResult) {
     const actions = [];
     const canCreateAutoApproval = (autoApproveResult.subCommandResults.every(e => e.result !== "denied") && autoApproveResult.commandLineResult.result !== "denied");
@@ -152,7 +155,7 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         const firstSubcommandFirstWord = unapprovedSubCommands.length > 0 ? unapprovedSubCommands[0].split(" ")[0] : "";
         if (firstSubcommandFirstWord !== commandLine && !( commandsWithSubcommands.has(commandLine)) && !( commandsWithSubSubCommands.has(commandLine))) {
             actions.push({
-                label: ( localize(13543, "Allow Exact Command Line in this Session")),
+                label: ( localize(13792, "Allow Exact Command Line in this Session")),
                 data: {
                     type: "newRule",
                     rule: {
@@ -166,7 +169,7 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
                 }
             });
             actions.push({
-                label: ( localize(13544, "Allow Exact Command Line in this Workspace")),
+                label: ( localize(13793, "Allow Exact Command Line in this Workspace")),
                 data: {
                     type: "newRule",
                     rule: {
@@ -180,7 +183,7 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
                 }
             });
             actions.push({
-                label: ( localize(13545, "Always Allow Exact Command Line")),
+                label: ( localize(13794, "Always Allow Exact Command Line")),
                 data: {
                     type: "newRule",
                     rule: {
@@ -199,15 +202,15 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         actions.push(( new Separator()));
     }
     actions.push({
-        label: ( localize(13546, "Allow All Commands in this Session")),
-        tooltip: ( localize(13547, "Allow this tool to run in this session without confirmation.")),
+        label: ( localize(13795, "Allow All Commands in this Session")),
+        tooltip: ( localize(13796, "Allow this tool to run in this session without confirmation.")),
         data: {
             type: "sessionApproval"
         }
     });
     actions.push(( new Separator()));
     actions.push({
-        label: ( localize(13548, "Configure Auto Approve...")),
+        label: ( localize(13797, "Configure Auto Approve...")),
         data: {
             type: "configure"
         }
@@ -243,4 +246,4 @@ function extractCdPrefix(commandLine, shell, os) {
     return undefined;
 }
 
-export { TRUNCATION_MESSAGE, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, truncateOutputKeepingTail };
+export { TRUNCATION_MESSAGE, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, normalizeTerminalCommandForDisplay, truncateOutputKeepingTail };

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

@@ -9,6 +9,7 @@ import { Task } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/t
 import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
 import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { IExecution, IPollingResult, OutputMonitorState } from "./tools/monitoring/types.js";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
 export declare function getTaskDefinition(id: string): {
     taskLabel: string;
     taskType: string;
@@ -50,7 +51,7 @@ export declare function resolveDependencyTasks(parentTask: Task, workspaceFolder
 /**
  * Collects output, polling duration, and idle status for all terminals.
  */
-export declare function collectTerminalResults(terminals: ITerminalInstance[], task: Task, instantiationService: IInstantiationService, invocationContext: IToolInvocationContext, progress: ToolProgress, token: CancellationToken, disposableStore: DisposableStore, isActive?: (task: Task) => Promise<boolean>, dependencyTasks?: Task[], taskService?: ITaskService): Promise<Array<{
+export declare function collectTerminalResults(terminals: ITerminalInstance[], task: Task, instantiationService: IInstantiationService, invocationContext: IToolInvocationContext, progress: ToolProgress, token: CancellationToken, disposableStore: DisposableStore, isActive?: (task: Task) => Promise<boolean>, dependencyTasks?: Task[], taskService?: ITaskService, startMarkersByTerminalInstanceId?: Map<number, IXtermMarker | undefined>): Promise<Array<{
     name: string;
     output: string;
     resources?: ILinkLocation[];

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

@@ -133,7 +133,8 @@ async function collectTerminalResults(
     disposableStore,
     isActive,
     dependencyTasks,
-    taskService
+    taskService,
+    startMarkersByTerminalInstanceId
 ) {
     const results = [];
     if (token.isCancellationRequested) {
@@ -152,6 +153,7 @@ async function collectTerminalResults(
         message: ( new MarkdownString(`Checking output for ${( terminalNames.map(n => `\`${n}\``)).join(", ")}`))
     });
     const terminalPromises = ( terminals.map(async instance => {
+        const startMarker = startMarkersByTerminalInstanceId ? startMarkersByTerminalInstanceId.get(instance.instanceId) : instance.registerMarker();
         let terminalTask = task;
         if (dependencyTasks?.length) {
             const reconnectionData = instance.reconnectionProperties?.data;
@@ -170,7 +172,7 @@ async function collectTerminalResults(
             }
         }
         const execution = {
-            getOutput: () => getOutput(instance) ?? "",
+            getOutput: marker => getOutput(instance, marker ?? startMarker) ?? "",
             task: terminalTask,
             isActive: isActive ? () => isActive(terminalTask) : undefined,
             instance,
@@ -188,38 +190,51 @@ async function collectTerminalResults(
                 await timeout(100);
             }
         }
-        const hasProblemMatchers = terminalTask.configurationProperties.problemMatchers && terminalTask.configurationProperties.problemMatchers.length > 0;
-        const outputMonitor = disposableStore.add(instantiationService.createInstance(
-            OutputMonitor,
-            execution,
-            hasProblemMatchers ? taskProblemPollFn : undefined,
-            invocationContext,
-            token,
-            task._label
-        ));
-        await Promise.race([
-            Event.toPromise(outputMonitor.onDidFinishCommand),
-            Event.toPromise(token.onCancellationRequested)
-        ]);
-        const pollingResult = outputMonitor.pollingResult;
-        return {
-            name: instance.shellLaunchConfig.name ?? instance.title ?? "unknown",
-            output: pollingResult?.output ?? "",
-            pollDurationMs: pollingResult?.pollDurationMs ?? 0,
-            resources: pollingResult?.resources,
-            state: pollingResult?.state || OutputMonitorState.Idle,
-            inputToolManualAcceptCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualAcceptCount ?? 0,
-            inputToolManualRejectCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualRejectCount ?? 0,
-            inputToolManualChars: outputMonitor.outputMonitorTelemetryCounters.inputToolManualChars ?? 0,
-            inputToolAutoAcceptCount: outputMonitor.outputMonitorTelemetryCounters.inputToolAutoAcceptCount ?? 0,
-            inputToolAutoChars: outputMonitor.outputMonitorTelemetryCounters.inputToolAutoChars ?? 0,
-            inputToolManualShownCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualShownCount ?? 0,
-            inputToolFreeFormInputShownCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputShownCount ?? 0,
-            inputToolFreeFormInputCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputCount ?? 0
-        };
+        try {
+            const hasProblemMatchers = terminalTask.configurationProperties.problemMatchers && terminalTask.configurationProperties.problemMatchers.length > 0;
+            const outputMonitor = disposableStore.add(instantiationService.createInstance(
+                OutputMonitor,
+                execution,
+                hasProblemMatchers ? taskProblemPollFn : undefined,
+                invocationContext,
+                token,
+                task._label
+            ));
+            await Promise.race([
+                Event.toPromise(outputMonitor.onDidFinishCommand),
+                Event.toPromise(token.onCancellationRequested)
+            ]);
+            const pollingResult = outputMonitor.pollingResult;
+            return {
+                name: instance.shellLaunchConfig.name ?? instance.title ?? "unknown",
+                output: pollingResult?.output ?? "",
+                pollDurationMs: pollingResult?.pollDurationMs ?? 0,
+                resources: pollingResult?.resources,
+                state: pollingResult?.state || OutputMonitorState.Idle,
+                inputToolManualAcceptCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualAcceptCount ?? 0,
+                inputToolManualRejectCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualRejectCount ?? 0,
+                inputToolManualChars: outputMonitor.outputMonitorTelemetryCounters.inputToolManualChars ?? 0,
+                inputToolAutoAcceptCount: outputMonitor.outputMonitorTelemetryCounters.inputToolAutoAcceptCount ?? 0,
+                inputToolAutoChars: outputMonitor.outputMonitorTelemetryCounters.inputToolAutoChars ?? 0,
+                inputToolManualShownCount: outputMonitor.outputMonitorTelemetryCounters.inputToolManualShownCount ?? 0,
+                inputToolFreeFormInputShownCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputShownCount ?? 0,
+                inputToolFreeFormInputCount: outputMonitor.outputMonitorTelemetryCounters.inputToolFreeFormInputCount ?? 0
+            };
+        } finally {
+            startMarker?.dispose();
+        }
     }));
     const parallelResults = await Promise.all(terminalPromises);
     results.push(...parallelResults);
+    if (startMarkersByTerminalInstanceId) {
+        const activeInstanceIds = ( new Set(( terminals.map(instance => instance.instanceId))));
+        for (const [instanceId, marker] of startMarkersByTerminalInstanceId) {
+            if (!( activeInstanceIds.has(instanceId))) {
+                marker?.dispose();
+                startMarkersByTerminalInstanceId.delete(instanceId);
+            }
+        }
+    }
     return results;
 }
 async function taskProblemPollFn(execution, token, taskService) {

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/terminal.chatAgentTools.contribution.d.ts

@@ -1 +1,18 @@
-export {};
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { type IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { ITrustedDomainService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/common/trustedDomainService.service";
+export declare class ChatAgentToolsContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _instantiationService;
+    private readonly _toolsService;
+    private readonly _configurationService;
+    private readonly _trustedDomainService;
+    static readonly ID = "terminal.chatAgentTools";
+    private readonly _runInTerminalToolRegistration;
+    private _runInTerminalToolRegistrationVersion;
+    constructor(_instantiationService: IInstantiationService, _toolsService: ILanguageModelToolsService, _configurationService: IConfigurationService, _trustedDomainService: ITrustedDomainService);
+    private _runInTerminalTool;
+    private _registerRunInTerminalTool;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/terminal.chatAgentTools.contribution.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
@@ -29,6 +29,7 @@ import { CreateAndRunTaskTool, CreateAndRunTaskToolData } from './tools/task/cre
 import { GetTaskOutputTool, GetTaskOutputToolData } from './tools/task/getTaskOutputTool.js';
 import { RunTaskTool, RunTaskToolData } from './tools/task/runTaskTool.js';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ITrustedDomainService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/common/trustedDomainService.service';
 import '../common/terminalSandboxService.js';
 
 let ShellIntegrationTimeoutMigrationContribution = class ShellIntegrationTimeoutMigrationContribution extends Disposable {
@@ -75,50 +76,84 @@ let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Dispos
     static {
         this.ID = "terminal.chatAgentTools";
     }
-    constructor(instantiationService, toolsService) {
+    constructor(
+        _instantiationService,
+        _toolsService,
+        _configurationService,
+        _trustedDomainService
+    ) {
         super();
-        const confirmTerminalCommandTool = instantiationService.createInstance(ConfirmTerminalCommandTool);
+        this._instantiationService = _instantiationService;
+        this._toolsService = _toolsService;
+        this._configurationService = _configurationService;
+        this._trustedDomainService = _trustedDomainService;
+        this._runInTerminalToolRegistration = this._register(( new MutableDisposable()));
+        this._runInTerminalToolRegistrationVersion = 0;
+        const confirmTerminalCommandTool = _instantiationService.createInstance(ConfirmTerminalCommandTool);
         this._register(
-            toolsService.registerTool(ConfirmTerminalCommandToolData, confirmTerminalCommandTool)
+            _toolsService.registerTool(ConfirmTerminalCommandToolData, confirmTerminalCommandTool)
         );
-        const getTerminalOutputTool = instantiationService.createInstance(GetTerminalOutputTool);
+        const getTerminalOutputTool = _instantiationService.createInstance(GetTerminalOutputTool);
         this._register(
-            toolsService.registerTool(GetTerminalOutputToolData, getTerminalOutputTool)
+            _toolsService.registerTool(GetTerminalOutputToolData, getTerminalOutputTool)
         );
-        this._register(toolsService.executeToolSet.addTool(GetTerminalOutputToolData));
-        const awaitTerminalTool = instantiationService.createInstance(AwaitTerminalTool);
-        this._register(toolsService.registerTool(AwaitTerminalToolData, awaitTerminalTool));
-        this._register(toolsService.executeToolSet.addTool(AwaitTerminalToolData));
-        const killTerminalTool = instantiationService.createInstance(KillTerminalTool);
-        this._register(toolsService.registerTool(KillTerminalToolData, killTerminalTool));
-        this._register(toolsService.executeToolSet.addTool(KillTerminalToolData));
-        instantiationService.invokeFunction(createRunInTerminalToolData).then(runInTerminalToolData => {
-            const runInTerminalTool = instantiationService.createInstance(RunInTerminalTool);
-            this._register(toolsService.registerTool(runInTerminalToolData, runInTerminalTool));
-            this._register(toolsService.executeToolSet.addTool(runInTerminalToolData));
-        });
-        const getTerminalSelectionTool = instantiationService.createInstance(GetTerminalSelectionTool);
+        this._register(_toolsService.executeToolSet.addTool(GetTerminalOutputToolData));
+        const awaitTerminalTool = _instantiationService.createInstance(AwaitTerminalTool);
+        this._register(_toolsService.registerTool(AwaitTerminalToolData, awaitTerminalTool));
+        this._register(_toolsService.executeToolSet.addTool(AwaitTerminalToolData));
+        const killTerminalTool = _instantiationService.createInstance(KillTerminalTool);
+        this._register(_toolsService.registerTool(KillTerminalToolData, killTerminalTool));
+        this._register(_toolsService.executeToolSet.addTool(KillTerminalToolData));
+        this._registerRunInTerminalTool();
+        const getTerminalSelectionTool = _instantiationService.createInstance(GetTerminalSelectionTool);
         this._register(
-            toolsService.registerTool(GetTerminalSelectionToolData, getTerminalSelectionTool)
+            _toolsService.registerTool(GetTerminalSelectionToolData, getTerminalSelectionTool)
         );
-        const getTerminalLastCommandTool = instantiationService.createInstance(GetTerminalLastCommandTool);
+        const getTerminalLastCommandTool = _instantiationService.createInstance(GetTerminalLastCommandTool);
         this._register(
-            toolsService.registerTool(GetTerminalLastCommandToolData, getTerminalLastCommandTool)
+            _toolsService.registerTool(GetTerminalLastCommandToolData, getTerminalLastCommandTool)
         );
-        this._register(toolsService.readToolSet.addTool(GetTerminalSelectionToolData));
-        this._register(toolsService.readToolSet.addTool(GetTerminalLastCommandToolData));
-        const runTaskTool = instantiationService.createInstance(RunTaskTool);
-        this._register(toolsService.registerTool(RunTaskToolData, runTaskTool));
-        const getTaskOutputTool = instantiationService.createInstance(GetTaskOutputTool);
-        this._register(toolsService.registerTool(GetTaskOutputToolData, getTaskOutputTool));
-        const createAndRunTaskTool = instantiationService.createInstance(CreateAndRunTaskTool);
-        this._register(toolsService.registerTool(CreateAndRunTaskToolData, createAndRunTaskTool));
-        this._register(toolsService.executeToolSet.addTool(RunTaskToolData));
-        this._register(toolsService.executeToolSet.addTool(CreateAndRunTaskToolData));
-        this._register(toolsService.readToolSet.addTool(GetTaskOutputToolData));
+        this._register(_toolsService.readToolSet.addTool(GetTerminalSelectionToolData));
+        this._register(_toolsService.readToolSet.addTool(GetTerminalLastCommandToolData));
+        const runTaskTool = _instantiationService.createInstance(RunTaskTool);
+        this._register(_toolsService.registerTool(RunTaskToolData, runTaskTool));
+        const getTaskOutputTool = _instantiationService.createInstance(GetTaskOutputTool);
+        this._register(_toolsService.registerTool(GetTaskOutputToolData, getTaskOutputTool));
+        const createAndRunTaskTool = _instantiationService.createInstance(CreateAndRunTaskTool);
+        this._register(_toolsService.registerTool(CreateAndRunTaskToolData, createAndRunTaskTool));
+        this._register(_toolsService.executeToolSet.addTool(RunTaskToolData));
+        this._register(_toolsService.executeToolSet.addTool(CreateAndRunTaskToolData));
+        this._register(_toolsService.readToolSet.addTool(GetTaskOutputToolData));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxEnabled) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowedDomains) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkDeniedDomains) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowTrustedDomains)) {
+                this._registerRunInTerminalTool();
+            }
+        }));
+        this._register(this._trustedDomainService.onDidChangeTrustedDomains(() => {
+            this._registerRunInTerminalTool();
+        }));
+    }
+    _registerRunInTerminalTool() {
+        const version = ++this._runInTerminalToolRegistrationVersion;
+        this._instantiationService.invokeFunction(createRunInTerminalToolData).then(runInTerminalToolData => {
+            if (this._store.isDisposed || version !== this._runInTerminalToolRegistrationVersion) {
+                return;
+            }
+            if (!this._runInTerminalTool) {
+                this._runInTerminalTool = this._register(this._instantiationService.createInstance(RunInTerminalTool));
+            }
+            this._runInTerminalToolRegistration.value = undefined;
+            const store = ( new DisposableStore());
+            store.add(this._toolsService.registerToolData(runInTerminalToolData));
+            store.add(
+                this._toolsService.registerToolImplementation(runInTerminalToolData.id, this._runInTerminalTool)
+            );
+            store.add(this._toolsService.executeToolSet.addTool(runInTerminalToolData));
+            this._runInTerminalToolRegistration.value = store;
+        });
     }
 };
-ChatAgentToolsContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageModelToolsService))], ChatAgentToolsContribution));
+ChatAgentToolsContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageModelToolsService)), ( __param(2, IConfigurationService)), ( __param(3, ITrustedDomainService))], ChatAgentToolsContribution));
 registerWorkbenchContribution2(
     ChatAgentToolsContribution.ID,
     ChatAgentToolsContribution,
@@ -126,7 +161,7 @@ registerWorkbenchContribution2(
 );
 registerActiveInstanceAction({
     id: TerminalChatAgentToolsCommandId.ChatAddTerminalSelection,
-    title: ( localize(13549, "Add Terminal Selection to Chat")),
+    title: ( localize(13798, "Add Terminal Selection to Chat")),
     precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, sharedWhenClause.terminalAvailable)),
     menu: [{
         id: MenuId.TerminalInstanceContext,
@@ -147,11 +182,13 @@ registerActiveInstanceAction({
         chatView.attachmentModel.addContext({
             id: `terminal-selection-${Date.now()}`,
             kind: "generic",
-            name: ( localize(13550, "Terminal Selection")),
-            fullName: ( localize(13550, "Terminal Selection")),
+            name: ( localize(13799, "Terminal Selection")),
+            fullName: ( localize(13799, "Terminal Selection")),
             value: selection,
             icon: Codicon.terminal
         });
         chatView.focusInput();
     }
 });
+
+export { ChatAgentToolsContribution };

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

@@ -11,7 +11,7 @@ import { timeout, raceCancellationError } from '@codingame/monaco-vscode-api/vsc
 const AwaitTerminalToolData = {
     id: TerminalToolId.AwaitTerminal,
     toolReferenceName: "awaitTerminal",
-    displayName: ( localize(13551, "Await Terminal")),
+    displayName: ( localize(13800, "Await Terminal")),
     modelDescription: "Wait for a background terminal command to complete. Returns the output, exit code, or timeout status.",
     icon: Codicon.terminal,
     source: ToolDataSource.Internal,
@@ -33,8 +33,8 @@ const AwaitTerminalToolData = {
 class AwaitTerminalTool extends Disposable {
     async prepareToolInvocation(_context, _token) {
         return {
-            invocationMessage: ( localize(13552, "Awaiting terminal completion")),
-            pastTenseMessage: ( localize(13553, "Awaited terminal completion"))
+            invocationMessage: ( localize(13801, "Awaiting terminal completion")),
+            pastTenseMessage: ( localize(13802, "Awaited terminal completion"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.js

@@ -154,7 +154,7 @@ let NpmScriptAutoApprover = class NpmScriptAutoApprover extends Disposable {
             isAutoApproved: true,
             scriptName,
             autoApproveInfo: ( new MarkdownString(( localize(
-                13554,
+                13803,
                 "Auto approved as {0} is defined in package.json",
                 `\`${scriptName}\``
             ))))

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

@@ -30,6 +30,7 @@ export interface ICommandLineAnalyzerOptions {
     treeSitterLanguage: TreeSitterCommandParserLanguage;
     terminalToolSessionId: string;
     chatSessionResource: URI | undefined;
+    requiresUnsandboxConfirmation?: boolean;
 }
 export interface ICommandLineAnalyzerResult {
     /**

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

@@ -40,7 +40,8 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         this._commandLineAutoApprover = this._register(instantiationService.createInstance(CommandLineAutoApprover));
     }
     async analyze(options) {
-        if (options.chatSessionResource && this._terminalChatService.hasChatSessionAutoApproval(options.chatSessionResource)) {
+        const isAutoApproveEnabledInSettings = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+        if (isAutoApproveEnabledInSettings && options.chatSessionResource && this._terminalChatService.hasChatSessionAutoApproval(options.chatSessionResource)) {
             this._log("Session has auto approval enabled, auto approving command");
             const disableUri = createCommandUri(
                 TerminalChatCommandId.DisableSessionAutoApproval,
@@ -55,7 +56,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 isAutoApproved: true,
                 isAutoApproveAllowed: true,
                 disclaimers: [],
-                autoApproveInfo: ( new MarkdownString(`${( localize(13555, "Auto approved for this session"))} ([${( localize(13556, "Disable"))}](${( disableUri.toString())}))`, mdTrustSettings))
+                autoApproveInfo: ( new MarkdownString(`${( localize(13804, "Auto approved for this session"))} ([${( localize(13805, "Disable"))}](${( disableUri.toString())}))`, mdTrustSettings))
             };
         }
         const trimmedCommandLine = options.commandLine.trimStart();
@@ -73,7 +74,16 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         let isAutoApproved = false;
         let autoApproveInfo;
         let customActions;
-        if (!subCommands) {
+        if (!subCommands?.length) {
+            if (trimmedCommandLine.length === 0) {
+                this._log("Command line is empty, auto approving");
+                return {
+                    isAutoApproved: true,
+                    isAutoApproveAllowed: true,
+                    disclaimers: []
+                };
+            }
+            this._log("No sub-commands were parsed, auto approval is not allowed");
             return {
                 isAutoApproveAllowed: false,
                 disclaimers: []
@@ -148,7 +158,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         const subCommandsLowerFirstWordOnly = ( subCommands.map(command => command.split(" ")[0].toLowerCase()));
         if (!isAutoApproved && (( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLower.includes(command))) || (isPowerShell(options.shell, options.os) && ( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLowerPwshOnly.includes(command)))))) {
             disclaimers.push(( localize(
-                13557,
+                13806,
                 "Web content may contain malicious code or attempt prompt injection attacks."
             )));
         }
@@ -189,10 +199,10 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
             return ( asArray(result).filter(e => isAutoApproveRule(e.rule)).map(e => {
                 const escapedSourceText = e.rule.sourceText.replaceAll("$", "\\$");
                 if (e.rule.sourceTarget === "session") {
-                    return localize(13558, "{0} (session)", `\`${escapedSourceText}\``);
+                    return localize(13807, "{0} (session)", `\`${escapedSourceText}\``);
                 }
                 const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule.sourceTarget);
-                const tooltip = ( localize(13559, "View rule in settings"));
+                const tooltip = ( localize(13808, "View rule in settings"));
                 let label = escapedSourceText;
                 switch (e.rule?.sourceTarget) {
                 case ConfigurationTarget.DEFAULT:
@@ -223,9 +233,9 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         if (isGlobalAutoApproved) {
             const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, "global");
             return (new MarkdownString(`${( localize(
-                13560,
+                13809,
                 "Auto approved by setting {0}",
-                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(13561, "View settings"))}")`
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(13810, "View settings"))}")`
             ))}`, mdTrustSettings));
         }
         if (isAutoApproved) {
@@ -234,7 +244,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 {
                     if (isAutoApproveRule(commandLineResult.rule)) {
                         return (new MarkdownString(
-                            localize(13562, "Auto approved by rule {0}", formatRuleLinks(commandLineResult)),
+                            localize(13811, "Auto approved by rule {0}", formatRuleLinks(commandLineResult)),
                             mdTrustSettings
                         ));
                     }
@@ -249,12 +259,12 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     const uniqueRules = dedupeRules(subCommandResults);
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(13562, "Auto approved by rule {0}", formatRuleLinks(uniqueRules)),
+                            localize(13811, "Auto approved by rule {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     } else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(13563, "Auto approved by rules {0}", formatRuleLinks(uniqueRules)),
+                            localize(13812, "Auto approved by rules {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }
@@ -267,7 +277,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 {
                     if (commandLineResult.rule) {
                         return (new MarkdownString(localize(
-                            13564,
+                            13813,
                             "Auto approval denied by rule {0}",
                             formatRuleLinks(commandLineResult)
                         ), mdTrustSettings));
@@ -279,12 +289,12 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === "denied"));
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(13564, "Auto approval denied by rule {0}", formatRuleLinks(uniqueRules)),
+                            localize(13813, "Auto approval denied by rule {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     } else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(13565, "Auto approval denied by rules {0}", formatRuleLinks(uniqueRules)),
+                            localize(13814, "Auto approval denied by rules {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }

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

@@ -149,12 +149,12 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
             )).join(", ");
             if (!isAutoApproveAllowed) {
                 disclaimers.push(( localize(
-                    13566,
+                    13815,
                     "File write operations detected that cannot be auto approved: {0}",
                     fileWritesList
                 )));
             } else {
-                disclaimers.push(( localize(13567, "File write operations detected: {0}", fileWritesList)));
+                disclaimers.push(( localize(13816, "File write operations detected: {0}", fileWritesList)));
             }
         }
         return {

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

@@ -16,7 +16,7 @@ let CommandLineSandboxAnalyzer = class CommandLineSandboxAnalyzer extends Dispos
         }
         return {
             isAutoApproveAllowed: true,
-            forceAutoApproval: true
+            forceAutoApproval: _options.requiresUnsandboxConfirmation ? false : true
         };
     }
 };

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

@@ -2,8 +2,9 @@ import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/
 import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
 /**
  * Command line presenter for sandboxed commands.
- * Extracts the original command from the sandbox wrapper for cleaner display,
- * while the actual sandboxed command runs unchanged.
+ * Returns the display form of the command (provided via {@link ICommandLineRewriterResult.forDisplay}
+ * from the rewriter pipeline) for cleaner presentation, while the actual sandboxed command runs
+ * unchanged.
  */
 export declare class SandboxedCommandLinePresenter implements ICommandLinePresenter {
     private readonly _sandboxService;

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

@@ -11,7 +11,7 @@ let SandboxedCommandLinePresenter = class SandboxedCommandLinePresenter {
             return undefined;
         }
         return {
-            commandLine: options.commandLine.original ?? options.commandLine.forDisplay,
+            commandLine: options.commandLine.forDisplay,
             processOtherPresenters: true
         };
     }

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

@@ -10,9 +10,11 @@ export interface ICommandLineRewriterOptions {
     cwd: URI | undefined;
     shell: string;
     os: OperatingSystem;
+    requestUnsandboxedExecution?: boolean;
 }
 export interface ICommandLineRewriterResult {
     rewritten: string;
     reasoning: string;
     forDisplay?: string;
+    isSandboxWrapped?: boolean;
 }

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

@@ -9,6 +9,9 @@ let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Dispos
         this._sandboxService = _sandboxService;
     }
     async rewrite(options) {
+        if (options.requestUnsandboxedExecution) {
+            return undefined;
+        }
         if (!(await this._sandboxService.isEnabled())) {
             return undefined;
         }
@@ -20,7 +23,8 @@ let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Dispos
         return {
             rewritten: wrappedCommand,
             reasoning: "Wrapped command for sandbox execution",
-            forDisplay: options.commandLine
+            forDisplay: options.commandLine,
+            isSandboxWrapped: true
         };
     }
 };

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

@@ -12,7 +12,7 @@ const GetTerminalLastCommandToolData = {
     id: TerminalToolId.TerminalLastCommand,
     toolReferenceName: "terminalLastCommand",
     legacyToolReferenceFullNames: ["runCommands/terminalLastCommand"],
-    displayName: ( localize(13568, "Get Terminal Last Command")),
+    displayName: ( localize(13817, "Get Terminal Last Command")),
     modelDescription: "Get the last command run in the active terminal.",
     source: ToolDataSource.Internal,
     icon: Codicon.terminal
@@ -24,8 +24,8 @@ let GetTerminalLastCommandTool = class GetTerminalLastCommandTool extends Dispos
     }
     async prepareToolInvocation(context, token) {
         return {
-            invocationMessage: ( localize(13569, "Getting last terminal command")),
-            pastTenseMessage: ( localize(13570, "Got last terminal command"))
+            invocationMessage: ( localize(13818, "Getting last terminal command")),
+            pastTenseMessage: ( localize(13819, "Got last terminal command"))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {