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

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

@@ -0,0 +1,165 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+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, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+
+let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
+    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()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+    }
+    async execute(commandLine, token, commandId, _commandLineForMetadata) {
+        const store = ( new DisposableStore());
+        this._register(store);
+        try {
+            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");
+                    return idlePromptPromise.then(() => {
+                        this._log("onDone 2 of 2 via short idle prompt");
+                        return {
+                            "type": "success",
+                            command: e
+                        };
+                    });
+                }),
+                Event.toPromise(token.onCancellationRequested, store).then(() => {
+                    this._log("onDone via cancellation");
+                }),
+                Event.toPromise(this._instance.onDisposed, store).then(() => {
+                    this._log("onDone via terminal disposal");
+                    return {
+                        type: "disposal"
+                    };
+                }),
+                trackIdleOnPrompt(this._instance, idlePollInterval * 3, store, idlePollInterval).then(() => {
+                    this._log("onDone long idle prompt");
+                })
+            ]);
+            this._log("Waiting for xterm");
+            const xterm = await this._instance.xtermReadyPromise;
+            if (!xterm) {
+                throw ( new Error("Xterm is not available"));
+            }
+            const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
+            this._log("Waiting for idle");
+            await waitForIdle(this._instance.onData, idlePollInterval);
+            const markerRecreation = setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
+            if (this._hasReceivedUserInput()) {
+                this._log("Command timed out, sending SIGINT and retrying");
+                await this._instance.sendText("\u0003", false);
+                await waitForIdle(this._instance.onData, 100);
+            }
+            if (commandId) {
+                this._log(
+                    `In basic execute strategy: skipping pre-bound command id ${commandId} because basic shell integration executes via sendText`
+                );
+            }
+            this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const forceBracketedPasteMode = isMacintosh;
+            this._instance.sendText(commandLine, true, forceBracketedPasteMode);
+            this._log("Waiting for done event");
+            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
+                type: "alternateBuffer"
+            }))]);
+            if (onDoneResult && onDoneResult.type === "disposal") {
+                throw ( new Error("The terminal was closed"));
+            }
+            if (onDoneResult && onDoneResult.type === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
+                return {
+                    output: undefined,
+                    exitCode: undefined,
+                    error: "alternateBuffer",
+                    didEnterAltBuffer: true
+                };
+            }
+            const finishedCommand = onDoneResult && onDoneResult.type === "success" ? onDoneResult.command : undefined;
+            if (finishedCommand) {
+                this._log(
+                    `Finished command id=${finishedCommand.id ?? "none"} for requested=${commandId ?? "none"}`
+                );
+            } else if (commandId) {
+                this._log(`No finished command surfaced for requested=${commandId}`);
+            }
+            this._log("Waiting for idle");
+            await waitForIdle(this._instance.onData, idlePollInterval);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const endMarker = store.add(xterm.raw.registerMarker());
+            let output;
+            const additionalInformationLines = [];
+            if (finishedCommand) {
+                const commandOutput = finishedCommand?.getOutput();
+                if (commandOutput !== undefined) {
+                    this._log("Fetched output via finished command");
+                    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");
+                }
+            }
+            if (output !== undefined && output.trim().length === 0) {
+                additionalInformationLines.push("Command produced no output");
+            }
+            const exitCode = finishedCommand?.exitCode;
+            if (isNumber(exitCode) && exitCode > 0) {
+                additionalInformationLines.push(`Command exited with code ${exitCode}`);
+            }
+            return {
+                output,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode
+            };
+        } finally {
+            store.dispose();
+        }
+    }
+    _log(message) {
+        this._logService.debug(`RunInTerminalTool#Basic: ${message}`);
+    }
+};
+BasicExecuteStrategy = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITerminalLogService))], BasicExecuteStrategy));
+
+export { BasicExecuteStrategy };

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

@@ -0,0 +1,53 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import type { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { DisposableStore, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+export interface ITerminalExecuteStrategy extends IDisposable {
+    readonly type: "rich" | "basic" | "none";
+    /**
+     * Executes a command line and gets a result designed to be passed directly to an LLM. The
+     * result will include information about the exit code.
+     * @param commandLine The command line to execute
+     * @param token Cancellation token
+     * @param commandId Optional predefined command ID to link the command
+     * @param commandLineForMetadata Optional command line to report in terminal execution metadata.
+     * This can differ from the command line that is sent to the shell, for example when the command
+     * is wrapped for sandbox execution.
+     */
+    execute(commandLine: string, token: CancellationToken, commandId?: string, commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    readonly onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+}
+export interface ITerminalExecuteStrategyResult {
+    output: string | undefined;
+    additionalInformation?: string;
+    exitCode?: number;
+    error?: string;
+    didEnterAltBuffer?: boolean;
+}
+export declare function waitForIdle(onData: Event<unknown>, idleDurationMs: number): Promise<void>;
+export interface IPromptDetectionResult {
+    /**
+     * Whether a prompt was detected.
+     */
+    detected: boolean;
+    /**
+     * The reason for logging.
+     */
+    reason?: string;
+}
+/**
+ * Detects if the given text content appears to end with a common prompt pattern.
+ */
+export declare function detectsCommonPromptPattern(cursorLine: string): IPromptDetectionResult;
+/**
+ * Enhanced version of {@link waitForIdle} that uses prompt detection heuristics. After the terminal
+ * idles for the specified period, checks if the terminal's cursor line looks like a common prompt.
+ * If not, extends the timeout to give the command more time to complete.
+ */
+export declare function waitForIdleWithPromptHeuristics(onData: Event<unknown>, instance: ITerminalInstance, idlePollIntervalMs: number, extendedTimeoutMs: number): Promise<IPromptDetectionResult>;
+/**
+ * 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, promptFallbackMs?: number): Promise<void>;

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

@@ -0,0 +1,163 @@
+
+import { DeferredPromise, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+async function waitForIdle(onData, idleDurationMs) {
+    const store = ( new DisposableStore());
+    const deferred = ( new DeferredPromise());
+    const scheduler = store.add(( new RunOnceScheduler(() => deferred.complete(), idleDurationMs)));
+    store.add(onData(() => scheduler.schedule()));
+    scheduler.schedule();
+    return deferred.p.finally(() => store.dispose());
+}
+function detectsCommonPromptPattern(cursorLine) {
+    if (cursorLine.trim().length === 0) {
+        return {
+            detected: false,
+            reason: "Content is empty or contains only whitespace"
+        };
+    }
+    if (/PS\s+[A-Z]:\\.*>\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `PowerShell prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/^[A-Z]:\\.*>\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Command Prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/\$\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Bash-style prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/#\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Root prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/^>>>\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Python REPL prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/\u276f\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Starship prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/[>%]\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Generic prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    return {
+        detected: false,
+        reason: `No common prompt pattern found in last line: "${cursorLine}"`
+    };
+}
+async function waitForIdleWithPromptHeuristics(onData, instance, idlePollIntervalMs, extendedTimeoutMs) {
+    await waitForIdle(onData, idlePollIntervalMs);
+    const xterm = await instance.xtermReadyPromise;
+    if (!xterm) {
+        return {
+            detected: false,
+            reason: `Xterm not available, using ${idlePollIntervalMs}ms timeout`
+        };
+    }
+    const startTime = Date.now();
+    while (Date.now() - startTime < extendedTimeoutMs) {
+        try {
+            let content = "";
+            const buffer = xterm.raw.buffer.active;
+            const line = buffer.getLine(buffer.baseY + buffer.cursorY);
+            if (line) {
+                content = line.translateToString(true);
+            }
+            const promptResult = detectsCommonPromptPattern(content);
+            if (promptResult.detected) {
+                return promptResult;
+            }
+        } catch (error) {}
+        await waitForIdle(
+            onData,
+            Math.min(idlePollIntervalMs, extendedTimeoutMs - (Date.now() - startTime))
+        );
+    }
+    try {
+        let content = "";
+        const buffer = xterm.raw.buffer.active;
+        const line = buffer.getLine(buffer.baseY + buffer.cursorY);
+        if (line) {
+            content = line.translateToString(true) + "\n";
+        }
+        return {
+            detected: false,
+            reason: `Extended timeout reached without prompt detection. Last line: "${content.trim()}"`
+        };
+    } catch (error) {
+        return {
+            detected: false,
+            reason: `Extended timeout reached. Error reading terminal content: ${error}`
+        };
+    }
+}
+async function trackIdleOnPrompt(instance, idleDurationMs, store, promptFallbackMs) {
+    const idleOnPrompt = ( new DeferredPromise());
+    const onData = instance.onData;
+    const scheduler = store.add(( new RunOnceScheduler(() => {
+        idleOnPrompt.complete();
+    }, idleDurationMs)));
+    let state = 0 ;
+    const promptFallbackScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 2  || state === 3 ) {
+            promptFallbackScheduler.cancel();
+            return;
+        }
+        state = 3 ;
+        scheduler.schedule();
+    }, promptFallbackMs ?? 1000)));
+    let TerminalState;
+    (function(TerminalState) {
+        TerminalState[TerminalState["Initial"] = 0] = "Initial";
+        TerminalState[TerminalState["Prompt"] = 1] = "Prompt";
+        TerminalState[TerminalState["Executing"] = 2] = "Executing";
+        TerminalState[TerminalState["PromptAfterExecuting"] = 3] = "PromptAfterExecuting";
+    })(TerminalState || (TerminalState = {}));
+    store.add(onData(e => {
+        const matches = e.matchAll(/(?:\x1b\]|\x9d)[16]33;(?<type>[ACD])(?:;.*)?(?:\x1b\\|\x07|\x9c)/g);
+        for (const match of matches) {
+            if (match.groups?.type === "A") {
+                if (state === 0 ) {
+                    state = 1 ;
+                } else if (state === 2 ) {
+                    state = 3 ;
+                }
+            } else if (match.groups?.type === "C" || match.groups?.type === "D") {
+                state = 2 ;
+            }
+        }
+        if (state === 3 ) {
+            promptFallbackScheduler.cancel();
+            scheduler.schedule();
+        } else {
+            scheduler.cancel();
+            if (state === 0  || state === 1 ) {
+                promptFallbackScheduler.schedule();
+            } else {
+                promptFallbackScheduler.cancel();
+            }
+        }
+    }));
+    return idleOnPrompt.p;
+}
+
+export { detectsCommonPromptPattern, trackIdleOnPrompt, waitForIdle, waitForIdleWithPromptHeuristics };

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

@@ -0,0 +1,27 @@
+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";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+/**
+ * This strategy is used when no shell integration is available. There are very few extension APIs
+ * available in this case. This uses similar strategies to the basic integration strategy, but
+ * with `sendText` instead of `shellIntegration.executeCommand` and relying on idle events instead
+ * of execution events.
+ */
+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, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken, _commandId?: string, _commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}

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

@@ -0,0 +1,142 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+
+let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
+    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()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+    }
+    async execute(commandLine, token, _commandId, _commandLineForMetadata) {
+        const store = ( new DisposableStore());
+        try {
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            this._log("Waiting for xterm");
+            const xterm = await this._instance.xtermReadyPromise;
+            if (!xterm) {
+                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, idlePollInterval);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const markerRecreation = setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
+            if (this._hasReceivedUserInput()) {
+                this._log("Command timed out, sending SIGINT and retrying");
+                await this._instance.sendText("\u0003", false);
+                await waitForIdle(this._instance.onData, 100);
+            }
+            this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const startLine = this._startMarker.value?.line;
+            const forceBracketedPasteMode = isMacintosh;
+            this._instance.sendText(commandLine, true, forceBracketedPasteMode);
+            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"), 1000);
+                    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,
+                idlePollInterval,
+                idlePollInterval * 10
+            ), alternateBufferPromise.then(() => "alternateBuffer")]);
+            if (promptResultOrAltBuffer === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
+                return {
+                    output: undefined,
+                    additionalInformation: undefined,
+                    exitCode: undefined,
+                    error: "alternateBuffer",
+                    didEnterAltBuffer: true
+                };
+            }
+            const promptResult = promptResultOrAltBuffer;
+            this._log(
+                `Prompt detection result: ${promptResult.detected ? "detected" : "not detected"} - ${promptResult.reason}`
+            );
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const endMarker = store.add(xterm.raw.registerMarker());
+            let output;
+            const additionalInformationLines = [];
+            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,
+                exitCode: undefined
+            };
+        } finally {
+            store.dispose();
+        }
+    }
+    _log(message) {
+        this._logService.debug(`RunInTerminalTool#None: ${message}`);
+    }
+};
+NoneExecuteStrategy = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ITerminalLogService))], NoneExecuteStrategy));
+
+export { NoneExecuteStrategy };

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

@@ -0,0 +1,29 @@
+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";
+import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+/**
+ * This strategy is used when the terminal has rich shell integration/command detection is
+ * available, meaning every sequence we rely upon should be exactly where we expect it to be. In
+ * particular (`633;`) `A, B, E, C, D` all happen in exactly that order. While things still could go
+ * wrong in this state, minimal verification is done in this mode since rich command detection is a
+ * strong signal that it's behaving correctly.
+ */
+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, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken, commandId?: string, commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}