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

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

@@ -1,164 +0,0 @@
-
-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) {
-        const store = ( new DisposableStore());
-        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

@@ -1,50 +0,0 @@
-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
-     */
-    execute(commandLine: string, token: CancellationToken, commandId?: 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

@@ -1,163 +0,0 @@
-
-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

@@ -1,27 +0,0 @@
-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): Promise<ITerminalExecuteStrategyResult>;
-    private _log;
-}

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

@@ -1,142 +0,0 @@
-
-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) {
-        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

@@ -1,29 +0,0 @@
-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): Promise<ITerminalExecuteStrategyResult>;
-    private _log;
-}