@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

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

@@ -0,0 +1,163 @@
+
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { ChatElicitationRequestPart } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/workbench/contrib/chat/browser/chatElicitationRequestPart';
+import { ChatModel } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+
+var PollingConsts;
+(function (PollingConsts) {
+    PollingConsts[PollingConsts["MinNoDataEvents"] = 2] = "MinNoDataEvents";
+    PollingConsts[PollingConsts["MinPollingDuration"] = 500] = "MinPollingDuration";
+    PollingConsts[PollingConsts["FirstPollingMaxDuration"] = 20000] = "FirstPollingMaxDuration";
+    PollingConsts[PollingConsts["ExtendedPollingMaxDuration"] = 120000] = "ExtendedPollingMaxDuration";
+    PollingConsts[PollingConsts["MaxPollingIntervalDuration"] = 2000] = "MaxPollingIntervalDuration";
+})(PollingConsts || (PollingConsts = {}));
+async function racePollingOrPrompt(pollFn, promptFn, originalResult, token, languageModelsService, execution) {
+    const pollPromise = pollFn();
+    const { promise: promptPromise, part } = promptFn();
+    let promptResolved = false;
+    const pollPromiseWrapped = pollPromise.then(async (result) => {
+        if (!promptResolved && part) {
+            part.hide();
+        }
+        return { type: 'poll', result };
+    });
+    const promptPromiseWrapped = promptPromise.then(result => {
+        promptResolved = true;
+        return { type: 'prompt', result };
+    });
+    const raceResult = await Promise.race([
+        pollPromiseWrapped,
+        promptPromiseWrapped
+    ]);
+    if (raceResult.type === 'poll') {
+        return raceResult.result;
+    }
+    else if (raceResult.type === 'prompt') {
+        const promptResult = raceResult.result;
+        if (promptResult) {
+            return await pollForOutputAndIdle(execution, true, token, languageModelsService);
+        }
+        else {
+            return originalResult;
+        }
+    }
+    return await pollFn();
+}
+function getOutput(instance, startMarker) {
+    if (!instance.xterm || !instance.xterm.raw) {
+        return '';
+    }
+    const lines = [];
+    for (let y = Math.min(startMarker?.line ?? 0, 0); y < instance.xterm.raw.buffer.active.length; y++) {
+        const line = instance.xterm.raw.buffer.active.getLine(y);
+        if (!line) {
+            continue;
+        }
+        lines.push(line.translateToString(true));
+    }
+    return lines.join('\n');
+}
+async function pollForOutputAndIdle(execution, extendedPolling, token, languageModelsService) {
+    const maxWaitMs = extendedPolling ? PollingConsts.ExtendedPollingMaxDuration : PollingConsts.FirstPollingMaxDuration;
+    const maxInterval = PollingConsts.MaxPollingIntervalDuration;
+    let currentInterval = PollingConsts.MinPollingDuration;
+    const pollStartTime = Date.now();
+    let lastBufferLength = 0;
+    let noNewDataCount = 0;
+    let buffer = '';
+    let terminalExecutionIdleBeforeTimeout = false;
+    while (true) {
+        if (token.isCancellationRequested) {
+            break;
+        }
+        const now = Date.now();
+        const elapsed = now - pollStartTime;
+        const timeLeft = maxWaitMs - elapsed;
+        if (timeLeft <= 0) {
+            break;
+        }
+        const waitTime = Math.min(currentInterval, timeLeft);
+        await timeout(waitTime);
+        if (Date.now() - pollStartTime >= maxWaitMs) {
+            break;
+        }
+        currentInterval = Math.min(currentInterval * 2, maxInterval);
+        buffer = execution.getOutput();
+        const currentBufferLength = buffer.length;
+        if (currentBufferLength === lastBufferLength) {
+            noNewDataCount++;
+        }
+        else {
+            noNewDataCount = 0;
+            lastBufferLength = currentBufferLength;
+        }
+        if (noNewDataCount >= PollingConsts.MinNoDataEvents) {
+            if (execution.isActive && ((await execution.isActive()) === true)) {
+                noNewDataCount = 0;
+                lastBufferLength = currentBufferLength;
+                continue;
+            }
+            terminalExecutionIdleBeforeTimeout = true;
+            const modelOutputEvalResponse = await assessOutputForErrors(buffer, token, languageModelsService);
+            return { modelOutputEvalResponse, terminalExecutionIdleBeforeTimeout, output: buffer, pollDurationMs: Date.now() - pollStartTime + (extendedPolling ? PollingConsts.FirstPollingMaxDuration : 0) };
+        }
+    }
+    return { terminalExecutionIdleBeforeTimeout: false, output: buffer, pollDurationMs: Date.now() - pollStartTime + (extendedPolling ? PollingConsts.FirstPollingMaxDuration : 0) };
+}
+function promptForMorePolling(command, token, context, chatService) {
+    if (token.isCancellationRequested) {
+        return { promise: Promise.resolve(false) };
+    }
+    const chatModel = chatService.getSession(context.sessionId);
+    if (chatModel instanceof ChatModel) {
+        const request = chatModel.getRequests().at(-1);
+        if (request) {
+            let part = undefined;
+            const promise = ( new Promise(resolve => {
+                const thePart = part = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(11254, "Continue waiting for `{0}` to finish?", command)))), ( new MarkdownString(( localize(
+                    11255,
+                    "Copilot will continue to poll for output to determine when the terminal becomes idle for up to 2 minutes."
+                )))), '', ( localize(11256, 'Yes')), ( localize(11257, 'No')), async () => {
+                    thePart.state = 'accepted';
+                    thePart.hide();
+                    resolve(true);
+                }, async () => {
+                    thePart.state = 'rejected';
+                    thePart.hide();
+                    resolve(false);
+                }));
+                chatModel.acceptResponseProgress(request, thePart);
+            }));
+            return { promise, part };
+        }
+    }
+    return { promise: Promise.resolve(false) };
+}
+async function assessOutputForErrors(buffer, token, languageModelsService) {
+    const models = await languageModelsService.selectLanguageModels({ vendor: 'copilot', family: 'gpt-4o-mini' });
+    if (!models.length) {
+        return 'No models available';
+    }
+    const response = await languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier('Github.copilot-chat')), [{ role: ChatMessageRole.Assistant, content: [{ type: 'text', value: `Evaluate this terminal output to determine if there were errors or if the command ran successfully: ${buffer}.` }] }], {}, token);
+    const streaming = (async () => {
+        for await (const part of response.stream) {
+            if (Array.isArray(part)) {
+                for (const p of part) {
+                }
+            }
+        }
+    })();
+    try {
+        await Promise.all([response.result, streaming]);
+        return response.result;
+    }
+    catch (err) {
+        return 'Error occurred ' + err;
+    }
+}
+
+export { PollingConsts, assessOutputForErrors, getOutput, pollForOutputAndIdle, promptForMorePolling, racePollingOrPrompt };

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

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export type ICommandApprovalResult = "approved" | "denied" | "noMatch";
+export declare class CommandLineAutoApprover extends Disposable {
+    private readonly _configurationService;
+    private _denyListRules;
+    private _allowListRules;
+    private _allowListCommandLineRules;
+    private _denyListCommandLineRules;
+    constructor(_configurationService: IConfigurationService);
+    updateConfiguration(): void;
+    isCommandAutoApproved(command: string, shell: string, os: OperatingSystem): {
+        result: ICommandApprovalResult;
+        reason: string;
+    };
+    isCommandLineAutoApproved(commandLine: string): {
+        result: ICommandApprovalResult;
+        reason: string;
+    };
+    private _commandMatchesRegex;
+    private _mapAutoApproveConfigToRules;
+    private _convertAutoApproveEntryToRegex;
+}

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

@@ -0,0 +1,164 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { regExpLeadsToEndlessLoop } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-6883db80-c313-54eb-8fbc-5872c56b0326-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isPowerShell } from './runInTerminalHelpers.js';
+
+const neverMatchRegex = /(?!.*)/;
+let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
+    constructor(_configurationService) {
+        super();
+        this._configurationService = _configurationService;
+        this._denyListRules = [];
+        this._allowListRules = [];
+        this._allowListCommandLineRules = [];
+        this._denyListCommandLineRules = [];
+        this.updateConfiguration();
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TerminalChatAgentToolsSettingId.AutoApprove) ||
+                e.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible)) {
+                this.updateConfiguration();
+            }
+        }));
+    }
+    updateConfiguration() {
+        let configValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApprove);
+        const deprecatedValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible);
+        if (deprecatedValue && typeof deprecatedValue === 'object' && configValue && typeof configValue === 'object') {
+            configValue = {
+                ...configValue,
+                ...deprecatedValue
+            };
+        }
+        const { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules } = this._mapAutoApproveConfigToRules(configValue);
+        this._allowListRules = allowListRules;
+        this._denyListRules = denyListRules;
+        this._allowListCommandLineRules = allowListCommandLineRules;
+        this._denyListCommandLineRules = denyListCommandLineRules;
+    }
+    isCommandAutoApproved(command, shell, os) {
+        for (const rule of this._denyListRules) {
+            if (this._commandMatchesRegex(rule.regex, command, shell, os)) {
+                return { result: 'denied', reason: `Command '${command}' is denied by deny list rule: ${rule.sourceText}` };
+            }
+        }
+        for (const rule of this._allowListRules) {
+            if (this._commandMatchesRegex(rule.regex, command, shell, os)) {
+                return { result: 'approved', reason: `Command '${command}' is approved by allow list rule: ${rule.sourceText}` };
+            }
+        }
+        return { result: 'noMatch', reason: `Command '${command}' has no matching auto approve entries` };
+    }
+    isCommandLineAutoApproved(commandLine) {
+        for (const rule of this._denyListCommandLineRules) {
+            if (rule.regex.test(commandLine)) {
+                return { result: 'denied', reason: `Command line '${commandLine}' is denied by deny list rule: ${rule.sourceText}` };
+            }
+        }
+        for (const rule of this._allowListCommandLineRules) {
+            if (rule.regex.test(commandLine)) {
+                return { result: 'approved', reason: `Command line '${commandLine}' is approved by allow list rule: ${rule.sourceText}` };
+            }
+        }
+        return { result: 'noMatch', reason: `Command line '${commandLine}' has no matching auto approve entries` };
+    }
+    _commandMatchesRegex(regex, command, shell, os) {
+        if (regex.test(command)) {
+            return true;
+        }
+        else if (isPowerShell(shell, os) && command.startsWith('(')) {
+            if (regex.test(command.slice(1))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _mapAutoApproveConfigToRules(config) {
+        if (!config || typeof config !== 'object') {
+            return {
+                denyListRules: [],
+                allowListRules: [],
+                allowListCommandLineRules: [],
+                denyListCommandLineRules: []
+            };
+        }
+        const denyListRules = [];
+        const allowListRules = [];
+        const allowListCommandLineRules = [];
+        const denyListCommandLineRules = [];
+        Object.entries(config).forEach(([key, value]) => {
+            if (typeof value === 'boolean') {
+                const regex = this._convertAutoApproveEntryToRegex(key);
+                if (value === true) {
+                    allowListRules.push({ regex, sourceText: key });
+                }
+                else if (value === false) {
+                    denyListRules.push({ regex, sourceText: key });
+                }
+            }
+            else if (typeof value === 'object' && value !== null) {
+                const objectValue = value;
+                if (typeof objectValue.approve === 'boolean') {
+                    const regex = this._convertAutoApproveEntryToRegex(key);
+                    if (objectValue.approve === true) {
+                        if (objectValue.matchCommandLine === true) {
+                            allowListCommandLineRules.push({ regex, sourceText: key });
+                        }
+                        else {
+                            allowListRules.push({ regex, sourceText: key });
+                        }
+                    }
+                    else if (objectValue.approve === false) {
+                        if (objectValue.matchCommandLine === true) {
+                            denyListCommandLineRules.push({ regex, sourceText: key });
+                        }
+                        else {
+                            denyListRules.push({ regex, sourceText: key });
+                        }
+                    }
+                }
+            }
+        });
+        return {
+            denyListRules,
+            allowListRules,
+            allowListCommandLineRules,
+            denyListCommandLineRules
+        };
+    }
+    _convertAutoApproveEntryToRegex(value) {
+        const regexMatch = value.match(/^\/(?<pattern>.+)\/(?<flags>[dgimsuvy]*)$/);
+        const regexPattern = regexMatch?.groups?.pattern;
+        if (regexPattern) {
+            let flags = regexMatch.groups?.flags;
+            if (flags) {
+                flags = flags.replaceAll('g', '');
+            }
+            if (regexPattern === '.*') {
+                return ( new RegExp(regexPattern));
+            }
+            try {
+                const regex = ( new RegExp(regexPattern, flags || undefined));
+                if (regExpLeadsToEndlessLoop(regex)) {
+                    return neverMatchRegex;
+                }
+                return regex;
+            }
+            catch (error) {
+                return neverMatchRegex;
+            }
+        }
+        if (value === '') {
+            return neverMatchRegex;
+        }
+        const sanitizedValue = value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+        return ( new RegExp(`^${sanitizedValue}\\b`));
+    }
+};
+CommandLineAutoApprover = ( __decorate([
+    ( __param(0, IConfigurationService))
+], CommandLineAutoApprover));
+
+export { CommandLineAutoApprover };

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

@@ -0,0 +1,14 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/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";
+export declare class BasicExecuteStrategy implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _commandDetection;
+    private readonly _logService;
+    readonly type = "basic";
+    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}

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

@@ -0,0 +1,101 @@
+
+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 { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { trackIdleOnPrompt, waitForIdle } from './executeStrategy.js';
+
+let BasicExecuteStrategy = class BasicExecuteStrategy {
+    constructor(_instance, _commandDetection, _logService) {
+        this._instance = _instance;
+        this._commandDetection = _commandDetection;
+        this._logService = _logService;
+        this.type = 'basic';
+    }
+    async execute(commandLine, token) {
+        const store = ( new DisposableStore());
+        try {
+            const idlePromptPromise = trackIdleOnPrompt(this._instance, 1000, store);
+            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 e;
+                    });
+                }),
+                Event.toPromise(token.onCancellationRequested, store).then(() => {
+                    this._log('onDone via cancellation');
+                }),
+                trackIdleOnPrompt(this._instance, 3000, store).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'));
+            }
+            this._log('Waiting for idle');
+            await waitForIdle(this._instance.onData, 1000);
+            let startMarker = store.add(xterm.raw.registerMarker());
+            store.add(startMarker.onDispose(() => {
+                this._log(`Start marker was disposed, recreating`);
+                startMarker = xterm.raw.registerMarker();
+            }));
+            this._log(`Executing command line \`${commandLine}\``);
+            this._instance.sendText(commandLine, true);
+            const finishedCommand = await onDone;
+            this._log('Waiting for idle');
+            await waitForIdle(this._instance.onData, 1000);
+            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 = commandOutput;
+                }
+            }
+            if (output === undefined) {
+                try {
+                    output = xterm.getContentsAsText(startMarker, endMarker);
+                    this._log('Fetched output via markers');
+                }
+                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(2, ITerminalLogService))
+], BasicExecuteStrategy));
+
+export { BasicExecuteStrategy };

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

@@ -0,0 +1,16 @@
+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 } 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";
+export interface ITerminalExecuteStrategy {
+    readonly type: "rich" | "basic" | "none";
+    execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
+}
+export interface ITerminalExecuteStrategyResult {
+    output: string | undefined;
+    additionalInformation?: string;
+    exitCode?: number;
+    error?: string;
+}
+export declare function waitForIdle(onData: Event<unknown>, idleDurationMs: number): Promise<void>;
+export declare function trackIdleOnPrompt(instance: ITerminalInstance, idleDurationMs: number, store: DisposableStore): Promise<void>;

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

@@ -0,0 +1,52 @@
+
+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());
+}
+async function trackIdleOnPrompt(instance, idleDurationMs, store) {
+    const idleOnPrompt = ( new DeferredPromise());
+    const onData = instance.onData;
+    const scheduler = store.add(( new RunOnceScheduler(() => {
+        idleOnPrompt.complete();
+    }, idleDurationMs)));
+    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 = {}));
+    let state = TerminalState.Initial;
+    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 === TerminalState.Initial) {
+                    state = TerminalState.Prompt;
+                }
+                else if (state === TerminalState.Executing) {
+                    state = TerminalState.PromptAfterExecuting;
+                }
+            }
+            else if (match.groups?.type === 'C' || match.groups?.type === 'D') {
+                state = TerminalState.Executing;
+            }
+        }
+        if (state === TerminalState.PromptAfterExecuting) {
+            scheduler.schedule();
+        }
+        else {
+            scheduler.cancel();
+        }
+    }));
+    return idleOnPrompt.p;
+}
+
+export { trackIdleOnPrompt, waitForIdle };

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

@@ -0,0 +1,12 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+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";
+export declare class NoneExecuteStrategy implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _logService;
+    readonly type = "none";
+    constructor(_instance: ITerminalInstance, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}

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

@@ -0,0 +1,71 @@
+
+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 { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { waitForIdle } from './executeStrategy.js';
+
+let NoneExecuteStrategy = class NoneExecuteStrategy {
+    constructor(_instance, _logService) {
+        this._instance = _instance;
+        this._logService = _logService;
+        this.type = 'none';
+    }
+    async execute(commandLine, token) {
+        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'));
+            }
+            this._log('Waiting for idle');
+            await waitForIdle(this._instance.onData, 1000);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            let startMarker = store.add(xterm.raw.registerMarker());
+            store.add(startMarker.onDispose(() => {
+                this._log(`Start marker was disposed, recreating`);
+                startMarker = xterm.raw.registerMarker();
+            }));
+            this._log(`Executing command line \`${commandLine}\``);
+            this._instance.sendText(commandLine, true);
+            this._log('Waiting for idle');
+            await waitForIdle(this._instance.onData, 1000);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const endMarker = store.add(xterm.raw.registerMarker());
+            let output;
+            const additionalInformationLines = [];
+            try {
+                output = xterm.getContentsAsText(startMarker, endMarker);
+                this._log('Fetched output via markers');
+            }
+            catch {
+                this._log('Failed to fetch output via markers');
+                additionalInformationLines.push('Failed to retrieve command 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(1, ITerminalLogService))
+], NoneExecuteStrategy));
+
+export { NoneExecuteStrategy };

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

@@ -0,0 +1,14 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/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";
+export declare class RichExecuteStrategy implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _commandDetection;
+    private readonly _logService;
+    readonly type = "rich";
+    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}