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

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatWidget.js

@@ -187,7 +187,7 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
     }
     _resetPlaceholder() {
         const defaultAgent = this._chatAgentService.getDefaultAgent(ChatAgentLocation.Terminal);
-        this.inlineChatWidget.placeholder = defaultAgent?.description ?? ( localize(13542, "Ask about commands"));
+        this.inlineChatWidget.placeholder = defaultAgent?.description ?? ( localize(13791, "Ask about commands"));
     }
     async reveal() {
         await this._createSession();
@@ -366,7 +366,7 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         if (!model?.sessionResource) {
             return;
         }
-        this._chatService.cancelCurrentRequestForSession(model?.sessionResource, "terminalChat");
+        void this._chatService.cancelCurrentRequestForSession(model?.sessionResource, "terminalChat");
     }
     async viewInChat() {
         const widget = await this._chatWidgetService.revealWidget();

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

@@ -1,6 +1,7 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 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 type { ICommandDetectionCapability } 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 { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
@@ -32,12 +33,13 @@ export declare class BasicExecuteStrategy extends Disposable implements ITermina
     private readonly _instance;
     private readonly _hasReceivedUserInput;
     private readonly _commandDetection;
+    private readonly _configurationService;
     private readonly _logService;
     readonly type = "basic";
     private readonly _startMarker;
     private readonly _onDidCreateStartMarker;
     onDidCreateStartMarker: Event<IXtermMarker | undefined>;
-    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _commandDetection: ICommandDetectionCapability, _configurationService: IConfigurationService, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken, commandId?: string): Promise<ITerminalExecuteStrategyResult>;
     private _log;
 }

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

@@ -4,16 +4,25 @@ import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { trackIdleOnPrompt, waitForIdle } from './executeStrategy.js';
-import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
+import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 
 let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
-    constructor(_instance, _hasReceivedUserInput, _commandDetection, _logService) {
+    constructor(
+        _instance,
+        _hasReceivedUserInput,
+        _commandDetection,
+        _configurationService,
+        _logService
+    ) {
         super();
         this._instance = _instance;
         this._hasReceivedUserInput = _hasReceivedUserInput;
         this._commandDetection = _commandDetection;
+        this._configurationService = _configurationService;
         this._logService = _logService;
         this.type = "basic";
         this._startMarker = this._register(( new MutableDisposable()));
@@ -23,7 +32,8 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
     async execute(commandLine, token, commandId) {
         const store = ( new DisposableStore());
         try {
-            const idlePromptPromise = trackIdleOnPrompt(this._instance, 1000, store);
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
+            const idlePromptPromise = trackIdleOnPrompt(this._instance, idlePollInterval, store, idlePollInterval);
             const onDone = Promise.race([
                 Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
                     this._log("onDone 1 of 2 via end event, waiting for short idle prompt");
@@ -44,7 +54,7 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
                         type: "disposal"
                     };
                 }),
-                trackIdleOnPrompt(this._instance, 3000, store).then(() => {
+                trackIdleOnPrompt(this._instance, idlePollInterval * 3, store, idlePollInterval).then(() => {
                     this._log("onDone long idle prompt");
                 })
             ]);
@@ -55,8 +65,8 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
             this._log("Waiting for idle");
-            await waitForIdle(this._instance.onData, 1000);
-            setupRecreatingStartMarker(
+            await waitForIdle(this._instance.onData, idlePollInterval);
+            const markerRecreation = setupRecreatingStartMarker(
                 xterm,
                 this._startMarker,
                 m => this._onDidCreateStartMarker.fire(m),
@@ -74,6 +84,7 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
                 );
             }
             this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
             this._instance.sendText(commandLine, true);
             this._log("Waiting for done event");
             const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
@@ -100,7 +111,7 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
                 this._log(`No finished command surfaced for requested=${commandId}`);
             }
             this._log("Waiting for idle");
-            await waitForIdle(this._instance.onData, 1000);
+            await waitForIdle(this._instance.onData, idlePollInterval);
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
@@ -111,13 +122,16 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
                 const commandOutput = finishedCommand?.getOutput();
                 if (commandOutput !== undefined) {
                     this._log("Fetched output via finished command");
-                    output = commandOutput;
+                    output = stripCommandEchoAndPrompt(commandOutput, commandLine, this._log.bind(this));
                 }
             }
             if (output === undefined) {
                 try {
                     output = xterm.getContentsAsText(this._startMarker.value, endMarker);
                     this._log("Fetched output via markers");
+                    if (output !== undefined) {
+                        output = stripCommandEchoAndPrompt(output, commandLine, this._log.bind(this));
+                    }
                 } catch {
                     this._log("Failed to fetch output via markers");
                     additionalInformationLines.push("Failed to retrieve command output");
@@ -143,6 +157,6 @@ let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
         this._logService.debug(`RunInTerminalTool#Basic: ${message}`);
     }
 };
-BasicExecuteStrategy = ( __decorate([( __param(3, ITerminalLogService))], BasicExecuteStrategy));
+BasicExecuteStrategy = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITerminalLogService))], BasicExecuteStrategy));
 
 export { BasicExecuteStrategy };

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

@@ -47,4 +47,4 @@ export declare function waitForIdleWithPromptHeuristics(onData: Event<unknown>,
  * Tracks the terminal for being idle on a prompt input. This must be called before `executeCommand`
  * is called.
  */
-export declare function trackIdleOnPrompt(instance: ITerminalInstance, idleDurationMs: number, store: DisposableStore): Promise<void>;
+export declare function trackIdleOnPrompt(instance: ITerminalInstance, idleDurationMs: number, store: DisposableStore, promptFallbackMs?: number): Promise<void>;

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

@@ -110,7 +110,7 @@ async function waitForIdleWithPromptHeuristics(onData, instance, idlePollInterva
         };
     }
 }
-async function trackIdleOnPrompt(instance, idleDurationMs, store) {
+async function trackIdleOnPrompt(instance, idleDurationMs, store, promptFallbackMs) {
     const idleOnPrompt = ( new DeferredPromise());
     const onData = instance.onData;
     const scheduler = store.add(( new RunOnceScheduler(() => {
@@ -124,7 +124,7 @@ async function trackIdleOnPrompt(instance, idleDurationMs, store) {
         }
         state = 3 ;
         scheduler.schedule();
-    }, 1000)));
+    }, promptFallbackMs ?? 1000)));
     let TerminalState;
     (function(TerminalState) {
         TerminalState[TerminalState["Initial"] = 0] = "Initial";

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

@@ -1,6 +1,7 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 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 { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
 import type { IMarker as IXtermMarker } from "@xterm/xterm";
@@ -14,12 +15,13 @@ import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbe
 export declare class NoneExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _hasReceivedUserInput;
+    private readonly _configurationService;
     private readonly _logService;
     readonly type = "none";
     private readonly _startMarker;
     private readonly _onDidCreateStartMarker;
     onDidCreateStartMarker: Event<IXtermMarker | undefined>;
-    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _logService: ITerminalLogService);
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _configurationService: IConfigurationService, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken, commandId?: string): Promise<ITerminalExecuteStrategyResult>;
     private _log;
 }

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

@@ -3,15 +3,18 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, MutableDisposable, DisposableStore } 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 { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { waitForIdle, waitForIdleWithPromptHeuristics } from './executeStrategy.js';
-import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
+import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 
 let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
-    constructor(_instance, _hasReceivedUserInput, _logService) {
+    constructor(_instance, _hasReceivedUserInput, _configurationService, _logService) {
         super();
         this._instance = _instance;
         this._hasReceivedUserInput = _hasReceivedUserInput;
+        this._configurationService = _configurationService;
         this._logService = _logService;
         this.type = "none";
         this._startMarker = this._register(( new MutableDisposable()));
@@ -30,12 +33,13 @@ let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
                 throw ( new Error("Xterm is not available"));
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
             this._log("Waiting for idle");
-            await waitForIdle(this._instance.onData, 1000);
+            await waitForIdle(this._instance.onData, idlePollInterval);
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
-            setupRecreatingStartMarker(
+            const markerRecreation = setupRecreatingStartMarker(
                 xterm,
                 this._startMarker,
                 m => this._onDidCreateStartMarker.fire(m),
@@ -48,12 +52,43 @@ let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
                 await waitForIdle(this._instance.onData, 100);
             }
             this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const startLine = this._startMarker.value?.line;
             this._instance.sendText(commandLine, true);
+            if (startLine !== undefined) {
+                this._log("Waiting for cursor to move past start line");
+                const cursorMovedPromise = ( new Promise(resolve => {
+                    const check = () => {
+                        const buffer = xterm.raw.buffer.active;
+                        const cursorLine = buffer.baseY + buffer.cursorY;
+                        if (cursorLine > startLine) {
+                            resolve();
+                        }
+                    };
+                    const listener = this._instance.onData(() => check());
+                    store.add(listener);
+                    check();
+                }));
+                const cursorMoveTimeout = ( new Promise(resolve => {
+                    const handle = setTimeout(() => resolve("timeout"), 5000);
+                    store.add({
+                        dispose: () => clearTimeout(handle)
+                    });
+                }));
+                const raceResult = await Promise.race([cursorMovedPromise, cursorMoveTimeout]);
+                if (raceResult === "timeout") {
+                    this._log(
+                        "Cursor did not move past start line before timeout, proceeding with idle detection"
+                    );
+                }
+            }
             this._log("Waiting for idle with prompt heuristics");
-            const promptResultOrAltBuffer = await Promise.race([
-                waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000, 10000),
-                alternateBufferPromise.then(() => "alternateBuffer")
-            ]);
+            const promptResultOrAltBuffer = await Promise.race([waitForIdleWithPromptHeuristics(
+                this._instance.onData,
+                this._instance,
+                idlePollInterval,
+                idlePollInterval * 10
+            ), alternateBufferPromise.then(() => "alternateBuffer")]);
             if (promptResultOrAltBuffer === "alternateBuffer") {
                 this._log("Detected alternate buffer entry, skipping output capture");
                 return {
@@ -77,10 +112,16 @@ let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
             try {
                 output = xterm.getContentsAsText(this._startMarker.value, endMarker);
                 this._log("Fetched output via markers");
+                if (output !== undefined) {
+                    output = stripCommandEchoAndPrompt(output, commandLine, this._log.bind(this));
+                }
             } catch {
                 this._log("Failed to fetch output via markers");
                 additionalInformationLines.push("Failed to retrieve command output");
             }
+            if (output !== undefined && output.trim().length === 0) {
+                additionalInformationLines.push("Command produced no output");
+            }
             return {
                 output,
                 additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
@@ -94,6 +135,6 @@ let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
         this._logService.debug(`RunInTerminalTool#None: ${message}`);
     }
 };
-NoneExecuteStrategy = ( __decorate([( __param(2, ITerminalLogService))], NoneExecuteStrategy));
+NoneExecuteStrategy = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ITerminalLogService))], NoneExecuteStrategy));
 
 export { NoneExecuteStrategy };

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

@@ -1,6 +1,7 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 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 type { ICommandDetectionCapability } 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 type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
@@ -16,12 +17,13 @@ import type { IMarker as IXtermMarker } from "@xterm/xterm";
 export declare class RichExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _commandDetection;
+    private readonly _configurationService;
     private readonly _logService;
     readonly type = "rich";
     private readonly _startMarker;
     private readonly _onDidCreateStartMarker;
     onDidCreateStartMarker: Event<IXtermMarker | undefined>;
-    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
+    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _configurationService: IConfigurationService, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken, commandId?: string): Promise<ITerminalExecuteStrategyResult>;
     private _log;
 }

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

@@ -4,15 +4,19 @@ import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { isCI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { trackIdleOnPrompt } from './executeStrategy.js';
-import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
+import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 
 let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
-    constructor(_instance, _commandDetection, _logService) {
+    constructor(_instance, _commandDetection, _configurationService, _logService) {
         super();
         this._instance = _instance;
         this._commandDetection = _commandDetection;
+        this._configurationService = _configurationService;
         this._logService = _logService;
         this.type = "rich";
         this._startMarker = this._register(( new MutableDisposable()));
@@ -28,6 +32,7 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
                 throw ( new Error("Xterm is not available"));
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
             const onDone = Promise.race([
                 Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
                     this._log("onDone via end event");
@@ -45,11 +50,11 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
                         type: "disposal"
                     };
                 }),
-                trackIdleOnPrompt(this._instance, 1000, store).then(() => {
+                trackIdleOnPrompt(this._instance, idlePollInterval, store, idlePollInterval).then(() => {
                     this._log("onDone via idle prompt");
                 })
             ]);
-            setupRecreatingStartMarker(
+            const markerRecreation = setupRecreatingStartMarker(
                 xterm,
                 this._startMarker,
                 m => this._onDidCreateStartMarker.fire(m),
@@ -57,6 +62,7 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
                 this._log.bind(this)
             );
             this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
             this._instance.runCommand(commandLine, true, commandId);
             this._log("Waiting for done event");
             const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
@@ -85,13 +91,16 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
                 const commandOutput = finishedCommand?.getOutput();
                 if (commandOutput !== undefined) {
                     this._log("Fetched output via finished command");
-                    output = commandOutput;
+                    output = stripCommandEchoAndPrompt(commandOutput, commandLine, this._log.bind(this));
                 }
             }
             if (output === undefined) {
                 try {
                     output = xterm.getContentsAsText(this._startMarker.value, endMarker);
                     this._log("Fetched output via markers");
+                    if (output !== undefined) {
+                        output = stripCommandEchoAndPrompt(output, commandLine, this._log.bind(this));
+                    }
                 } catch {
                     this._log("Failed to fetch output via markers");
                     additionalInformationLines.push("Failed to retrieve command output");
@@ -114,9 +123,14 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
         }
     }
     _log(message) {
-        this._logService.debug(`RunInTerminalTool#Rich: ${message}`);
+        const msg = `RunInTerminalTool#Rich: ${message}`;
+        if (isCI) {
+            this._logService.info(msg);
+        } else {
+            this._logService.debug(msg);
+        }
     }
 };
-RichExecuteStrategy = ( __decorate([( __param(2, ITerminalLogService))], RichExecuteStrategy));
+RichExecuteStrategy = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ITerminalLogService))], RichExecuteStrategy));
 
 export { RichExecuteStrategy };

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

@@ -9,7 +9,7 @@ export declare function setupRecreatingStartMarker(xterm: {
     raw: {
         registerMarker(): IXtermMarker | undefined;
     };
-}, startMarker: MutableDisposable<IXtermMarker>, fire: (marker: IXtermMarker | undefined) => void, store: DisposableStore, log?: (message: string) => void): void;
+}, startMarker: MutableDisposable<IXtermMarker>, fire: (marker: IXtermMarker | undefined) => void, store: DisposableStore, log?: (message: string) => void): IDisposable;
 export declare function createAltBufferPromise(xterm: {
     raw: {
         buffer: {
@@ -19,3 +19,22 @@ export declare function createAltBufferPromise(xterm: {
         };
     };
 }, store: DisposableStore, log?: (message: string) => void): Promise<void>;
+/**
+ * Strips the command echo and trailing prompt lines from marker-based terminal output.
+ * Without shell integration (or when `getOutput()` is unavailable), `getContentsAsText`
+ * captures the entire terminal buffer between the start and end markers, which includes:
+ * 1. The command echo line (what `sendText` wrote)
+ * 2. The actual command output
+ * 3. The next shell prompt line(s)
+ *
+ * This function removes (1) and (3) to isolate the actual output.
+ */
+export declare function stripCommandEchoAndPrompt(output: string, commandLine: string, log?: (message: string) => void): string;
+export declare function findCommandEcho(output: string, commandLine: string, allowSuffixMatch?: boolean): {
+    contentBefore: string;
+    linesAfter: string[];
+} | undefined;
+export declare function stripNewLinesAndBuildMapping(output: string): {
+    strippedOutput: string;
+    indexMapping: number[];
+};

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

@@ -27,6 +27,7 @@ function setupRecreatingStartMarker(xterm, startMarker, fire, store, log) {
         fire(undefined);
     }));
     store.add(startMarker);
+    return toDisposable(() => markerListener.dispose());
 }
 function createAltBufferPromise(xterm, store, log) {
     const deferred = ( new DeferredPromise());
@@ -47,5 +48,127 @@ function createAltBufferPromise(xterm, store, log) {
     }
     return deferred.p;
 }
+function stripCommandEchoAndPrompt(output, commandLine, log) {
+    log?.(
+        `stripCommandEchoAndPrompt input: output length=${output.length}, commandLine length=${commandLine.length}`
+    );
+    const result = _stripCommandEchoAndPromptOnce(output, commandLine, log);
+    if (result.trim().length > 0 && findCommandEcho(result, commandLine)) {
+        return _stripCommandEchoAndPromptOnce(result, commandLine, log);
+    }
+    return result;
+}
+function _stripCommandEchoAndPromptOnce(output, commandLine, log) {
+    const echoResult = findCommandEcho(output, commandLine,  true);
+    const lines = echoResult ? echoResult.linesAfter : output.split("\n");
+    const startIndex = 0;
+    const promptBefore = echoResult?.contentBefore ?? "";
+    const isUnixAt = /\w+@[\w.-]+:/.test(promptBefore);
+    const isUnixHost = !isUnixAt && /[\w.-]+:\S/.test(promptBefore);
+    const isUnix = isUnixAt || isUnixHost;
+    const isPowerShell = /^PS\s/i.test(promptBefore);
+    const isCmd = !isPowerShell && /^[A-Z]:\\/.test(promptBefore);
+    const isStarship = /\u276f/.test(promptBefore);
+    const isPython = />>>/.test(promptBefore);
+    const knownPrompt = isUnix || isPowerShell || isCmd || isStarship || isPython;
+    let endIndex = lines.length;
+    let trailingStrippedCount = 0;
+    const maxTrailingPromptLines = 2;
+    while (endIndex > startIndex) {
+        const line = lines[endIndex - 1].trimEnd();
+        if (line.length === 0) {
+            endIndex--;
+            continue;
+        }
+        if (trailingStrippedCount >= maxTrailingPromptLines) {
+            break;
+        }
+        const isCompletePrompt =
+        ((!knownPrompt || isUnixAt) && /^\s*\w+@[\w.-]+:.*[#$]\s*$/.test(line)) || ((!knownPrompt || isUnixHost) && /^\s*[\w.-]+:\S.*\s\w+[#$]\s*$/.test(line)) || ((!knownPrompt || isPowerShell) && /^PS\s+[A-Z]:\\.*>\s*$/.test(line)) || ((!knownPrompt || isCmd) && /^[A-Z]:\\.*>\s*$/.test(line)) || ((!knownPrompt || isStarship) && /\u276f\s*$/.test(line)) || ((!knownPrompt || isPython) && /^>>>\s*$/.test(line));
+        const isPromptFragment =
+        ((!knownPrompt || isUnix) && /^\s*[\w/.-]+[#$]\s*$/.test(line)) || ((!knownPrompt || isUnix) && /^\[\s*[\w.-]+(@[\w.-]+)?:[~\/]/.test(line)) || ((!knownPrompt || isUnix) && trailingStrippedCount > 0 && /^\s*[\w][-\w.]*(@[\w.-]+)?:\S/.test(line)) || ((!knownPrompt || isUnix) && /\]\s*[#$]\s*$/.test(line));
+        if (isCompletePrompt) {
+            endIndex--;
+            trailingStrippedCount++;
+            break;
+        } else if (isPromptFragment) {
+            endIndex--;
+            trailingStrippedCount++;
+        } else {
+            break;
+        }
+    }
+    const result = lines.slice(startIndex, endIndex).join("\n");
+    log?.(
+        `stripCommandEchoAndPrompt result: length=${result.length} (startIndex=${startIndex}, endIndex=${endIndex}, totalLines=${lines.length})`
+    );
+    return result;
+}
+function findCommandEcho(output, commandLine, allowSuffixMatch) {
+    const trimmedCommand = commandLine.trim();
+    if (trimmedCommand.length === 0) {
+        return undefined;
+    }
+    const {
+        strippedOutput,
+        indexMapping
+    } = stripNewLinesAndBuildMapping(output);
+    const matchIndex = strippedOutput.indexOf(trimmedCommand);
+    let matchEndInStripped;
+    let contentBefore;
+    if (matchIndex !== -1) {
+        contentBefore = strippedOutput.substring(0, matchIndex).trim();
+        matchEndInStripped = matchIndex + trimmedCommand.length - 1;
+    } else if (allowSuffixMatch) {
+        let suffixLen = 0;
+        for (let len = trimmedCommand.length - 1; len >= 1; len--) {
+            const suffix = trimmedCommand.substring(trimmedCommand.length - len);
+            if (strippedOutput.startsWith(suffix)) {
+                const charBefore = trimmedCommand[trimmedCommand.length - len - 1];
+                if (charBefore !== undefined && charBefore !== " " && charBefore !== "\t") {
+                    suffixLen = len;
+                }
+                break;
+            }
+        }
+        if (suffixLen === 0) {
+            return undefined;
+        }
+        contentBefore = "";
+        matchEndInStripped = suffixLen - 1;
+    } else {
+        return undefined;
+    }
+    const originalEnd = indexMapping[matchEndInStripped];
+    const lines = output.split("\n");
+    let echoEndLine = 0;
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineEnd = offset + lines[i].length;
+        if (offset <= originalEnd && originalEnd <= lineEnd) {
+            echoEndLine = i + 1;
+            break;
+        }
+        offset = lineEnd + 1;
+    }
+    return {
+        contentBefore,
+        linesAfter: lines.slice(echoEndLine)
+    };
+}
+function stripNewLinesAndBuildMapping(output) {
+    const indexMapping = [];
+    const strippedChars = [];
+    for (let i = 0; i < output.length; i++) {
+        if (output[i] !== "\n") {
+            strippedChars.push(output[i]);
+            indexMapping.push(i);
+        }
+    }
+    return {
+        strippedOutput: strippedChars.join(""),
+        indexMapping
+    };
+}
 
-export { createAltBufferPromise, setupRecreatingStartMarker };
+export { createAltBufferPromise, findCommandEcho, setupRecreatingStartMarker, stripCommandEchoAndPrompt, stripNewLinesAndBuildMapping };

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

@@ -4,17 +4,32 @@ import { truncateOutputKeepingTail } from './runInTerminalHelpers.js';
 const MAX_OUTPUT_LENGTH = 16000;
 function getOutput(instance, startMarker) {
     if (!instance.xterm || !instance.xterm.raw) {
-        return "";
+        return '';
     }
     const buffer = instance.xterm.raw.buffer.active;
-    const startLine = Math.max(startMarker?.line ?? 0, 0);
+    let startLine = Math.max(startMarker?.line ?? 0, 0);
+    while (startLine > 0 && buffer.getLine(startLine)?.isWrapped) {
+        startLine--;
+    }
     const endLine = buffer.length;
-    const lines = ( new Array(endLine - startLine));
+    const lines = [];
+    let currentLine = '';
     for (let y = startLine; y < endLine; y++) {
         const line = buffer.getLine(y);
-        lines[y - startLine] = line ? line.translateToString(true) : "";
+        if (!line) {
+            continue;
+        }
+        const isWrapped = !!buffer.getLine(y + 1)?.isWrapped;
+        currentLine += line.translateToString(!isWrapped);
+        if (!isWrapped) {
+            lines.push(currentLine);
+            currentLine = '';
+        }
+    }
+    if (currentLine) {
+        lines.push(currentLine);
     }
-    let output = lines.join("\n");
+    let output = lines.join('\n');
     if (output.length > MAX_OUTPUT_LENGTH) {
         output = truncateOutputKeepingTail(output, MAX_OUTPUT_LENGTH);
     }

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

@@ -9,6 +9,11 @@ export declare function isFish(envShell: string, os: OperatingSystem): boolean;
 export declare const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
 export declare function truncateOutputKeepingTail(output: string, maxLength: number): string;
 export declare function sanitizeTerminalOutput(output: string): string;
+/**
+ * Normalizes command text for UI display by removing unnecessary quote and forward slash
+ * escaping artifacts (for example: \" \' \/) commonly produced in streamed tool-call JSON.
+ */
+export declare function normalizeTerminalCommandForDisplay(commandLine: string): string;
 export declare function generateAutoApproveActions(commandLine: string, subCommands: string[], autoApproveResult: {
     subCommandResults: ICommandApprovalResultWithReason[];
     commandLineResult: ICommandApprovalResultWithReason;