@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

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

@@ -0,0 +1,518 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
+import { OutputMonitorState, PollingConsts } from './types.js';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+
+function getLastLine(output) {
+    if (!output) {
+        return "";
+    }
+    const trimmedOutput = output.replace(/[\r\n]+$/, "");
+    if (!trimmedOutput) {
+        return "";
+    }
+    const lastLineFeed = trimmedOutput.lastIndexOf("\n");
+    const lastLine = lastLineFeed === -1 ? trimmedOutput : trimmedOutput.slice(lastLineFeed + 1);
+    const lastCarriageReturn = lastLine.lastIndexOf("\r");
+    return lastCarriageReturn === -1 ? lastLine : lastLine.slice(lastCarriageReturn + 1);
+}
+let OutputMonitor = class OutputMonitor extends Disposable {
+    get state() {
+        return this._state;
+    }
+    _formatLastLineForLog(output) {
+        if (!output) {
+            return "<empty>";
+        }
+        const lastLine = getLastLine(output).trimEnd();
+        if (!lastLine) {
+            return "<empty>";
+        }
+        if (this._isSensitivePrompt(lastLine)) {
+            return "<redacted>";
+        }
+        return lastLine.length > 200 ? lastLine.slice(0, 200) + "…" : lastLine;
+    }
+    get pollingResult() {
+        return this._pollingResult;
+    }
+    get outputMonitorTelemetryCounters() {
+        return this._outputMonitorTelemetryCounters;
+    }
+    _fireFinishedOnce() {
+        if (this._didFinish) {
+            return;
+        }
+        this._didFinish = true;
+        this._onDidFinishCommand.fire();
+    }
+    dispose() {
+        if (!this._didFinish) {
+            this._pollingResult ??= {
+                state: OutputMonitorState.Cancelled,
+                output: this._execution.getOutput(),
+                pollDurationMs: 0,
+                resources: undefined
+            };
+        }
+        this._fireFinishedOnce();
+        super.dispose();
+    }
+    constructor(
+        _execution,
+        _pollFn,
+        invocationContext,
+        token,
+        command,
+        _taskService,
+        _logService
+    ) {
+        super();
+        this._execution = _execution;
+        this._pollFn = _pollFn;
+        this._taskService = _taskService;
+        this._logService = _logService;
+        this._state = OutputMonitorState.PollingForIdle;
+        this._userInputtedSinceIdleDetected = false;
+        this._userInputListener = this._register(( new MutableDisposable()));
+        this._outputMonitorTelemetryCounters = {
+            inputToolManualAcceptCount: 0,
+            inputToolManualRejectCount: 0,
+            inputToolManualChars: 0,
+            inputToolAutoAcceptCount: 0,
+            inputToolAutoChars: 0,
+            inputToolManualShownCount: 0,
+            inputToolFreeFormInputShownCount: 0,
+            inputToolFreeFormInputCount: 0
+        };
+        this._onDidFinishCommand = this._register(( new Emitter()));
+        this.onDidFinishCommand = this._onDidFinishCommand.event;
+        this._onDidDetectInputNeeded = this._register(( new Emitter()));
+        this.onDidDetectInputNeeded = this._onDidDetectInputNeeded.event;
+        this._onDidDetectSensitiveInputNeeded = this._register(( new Emitter()));
+        this.onDidDetectSensitiveInputNeeded = this._onDidDetectSensitiveInputNeeded.event;
+        this._asyncMode = false;
+        this._command = "";
+        this._didFinish = false;
+        this._command = command;
+        this._invocationContext = invocationContext;
+        const cts = ( new CancellationTokenSource(token));
+        this._currentMonitoringCts = cts;
+        this._register(toDisposable(() => {
+            this._currentMonitoringCts?.cancel();
+            this._currentMonitoringCts?.dispose();
+        }));
+        timeout(0).then(() => {
+            if (this._currentMonitoringCts !== cts) {
+                return;
+            }
+            this._startMonitoring(command, invocationContext, cts.token);
+        });
+    }
+    async _startMonitoring(command, invocationContext, token) {
+        const pollStartTime = Date.now();
+        let resources;
+        let output;
+        let extended = false;
+        try {
+            while (!token.isCancellationRequested) {
+                switch (this._state) {
+                case OutputMonitorState.PollingForIdle:
+                    {
+                        this._logService.trace(`OutputMonitor: Entering PollingForIdle (extended=${extended})`);
+                        this._state = await this._waitForIdle(this._execution, extended, token);
+                        this._logService.trace(
+                            `OutputMonitor: PollingForIdle completed -> state=${OutputMonitorState[this._state]}`
+                        );
+                        continue;
+                    }
+                case OutputMonitorState.Timeout:
+                    {
+                        this._logService.trace(`OutputMonitor: Entering Timeout state (extended=${extended})`);
+                        const shouldContinuePolling = await this._handleTimeoutState(command, invocationContext, extended, token);
+                        if (shouldContinuePolling) {
+                            extended = true;
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else if (this._asyncMode) {
+                            this._logService.trace(
+                                "OutputMonitor: Async mode - timeout reached, waiting for new terminal data"
+                            );
+                            extended = false;
+                            await this._waitForNewData(token);
+                            if (token.isCancellationRequested) {
+                                break;
+                            }
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else {
+                            break;
+                        }
+                    }
+                case OutputMonitorState.Cancelled:
+                    break;
+                case OutputMonitorState.Idle:
+                    {
+                        this._logService.trace("OutputMonitor: Entering Idle handler");
+                        const idleResult = await this._handleIdleState(token);
+                        if (idleResult.shouldContinuePolling) {
+                            this._logService.trace("OutputMonitor: Idle handler -> continue polling");
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else if (this._asyncMode) {
+                            this._logService.trace(
+                                "OutputMonitor: Async mode - waiting for new terminal data before next monitoring cycle"
+                            );
+                            await this._waitForNewData(token);
+                            if (token.isCancellationRequested) {
+                                break;
+                            }
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else {
+                            this._logService.trace(
+                                `OutputMonitor: Idle handler -> stop polling (hasResources=${!!idleResult.resources}, outputLen=${idleResult.output?.length ?? 0})`
+                            );
+                            resources = idleResult.resources;
+                            output = idleResult.output;
+                        }
+                        break;
+                    }
+                }
+                if (this._state === OutputMonitorState.Idle || this._state === OutputMonitorState.Cancelled || this._state === OutputMonitorState.Timeout) {
+                    break;
+                }
+            }
+            if (token.isCancellationRequested) {
+                this._state = OutputMonitorState.Cancelled;
+            }
+        } finally {
+            this._logService.trace(
+                `OutputMonitor: Monitoring finished (state=${OutputMonitorState[this._state]}, duration=${Date.now() - pollStartTime}ms)`
+            );
+            this._pollingResult = {
+                state: this._state,
+                output: output ?? this._execution.getOutput(),
+                pollDurationMs: Date.now() - pollStartTime,
+                resources
+            };
+            this._userInputListener.clear();
+            this._fireFinishedOnce();
+        }
+    }
+    continueMonitoringAsync(token) {
+        this._asyncMode = true;
+        const currentMonitoringCts = this._currentMonitoringCts;
+        currentMonitoringCts?.cancel();
+        currentMonitoringCts?.dispose();
+        this._currentMonitoringCts = ( new CancellationTokenSource(token));
+        this._state = OutputMonitorState.PollingForIdle;
+        this._startMonitoring(this._command, this._invocationContext, this._currentMonitoringCts.token);
+    }
+    _waitForNewData(token) {
+        return ( new Promise(resolve => {
+            if (token.isCancellationRequested) {
+                resolve();
+                return;
+            }
+            const cleanup = () => {
+                dataListener.dispose();
+                tokenListener.dispose();
+                disposedListener.dispose();
+            };
+            const dataListener = this._execution.instance.onData(() => {
+                cleanup();
+                resolve();
+            });
+            const tokenListener = token.onCancellationRequested(() => {
+                cleanup();
+                resolve();
+            });
+            const disposedListener = this._execution.instance.onDisposed(() => {
+                cleanup();
+                resolve();
+            });
+        }));
+    }
+    async _handleIdleState(token) {
+        const output = this._execution.getOutput();
+        const outputTail = output.slice(-1e3);
+        const outputLastLine = getLastLine(outputTail);
+        this._logService.trace(
+            `OutputMonitor: Idle output summary: len=${output.length}, lastLine=${this._formatLastLineForLog(outputTail)}`
+        );
+        if (detectsNonInteractiveHelpPattern(outputLastLine)) {
+            this._logService.trace("OutputMonitor: Idle -> non-interactive help pattern detected, stopping");
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        const isTask = this._execution.task !== undefined;
+        if (isTask && detectsVSCodeTaskFinishMessage(outputTail)) {
+            this._logService.trace("OutputMonitor: Idle -> VS Code task finish message detected, stopping");
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        if (!isTask && detectsGenericPressAnyKeyPattern(outputTail)) {
+            this._logService.trace(
+                "OutputMonitor: Idle -> generic \"press any key\" detected, signaling agent"
+            );
+            this._onDidDetectInputNeeded.fire();
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        if (this._userInputtedSinceIdleDetected) {
+            this._logService.trace(
+                "OutputMonitor: User input detected since idle; skipping prompt and continuing polling"
+            );
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: true
+            };
+        }
+        let shouldFireInputNeeded = detectsInputRequiredPattern(outputLastLine);
+        if (!shouldFireInputNeeded && detectsLikelyInputRequiredPattern(outputLastLine)) {
+            const isActive = this._execution.isActive ? await this._execution.isActive() : undefined;
+            if (isActive === true) {
+                shouldFireInputNeeded = true;
+            }
+        }
+        if (shouldFireInputNeeded && this._userInputtedSinceIdleDetected) {
+            this._logService.trace(
+                "OutputMonitor: User input detected during isActive await; skipping prompt and continuing polling"
+            );
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: true
+            };
+        }
+        if (this._asyncMode) {
+            if (shouldFireInputNeeded) {
+                if (this._isSensitivePrompt(outputLastLine)) {
+                    this._logService.trace(
+                        "OutputMonitor: Async mode - sensitive input prompt detected, signaling sensitive UI"
+                    );
+                    this._onDidDetectSensitiveInputNeeded.fire();
+                } else {
+                    this._logService.trace(
+                        "OutputMonitor: Async mode - input-required pattern detected, signaling agent"
+                    );
+                    this._onDidDetectInputNeeded.fire();
+                }
+            }
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        if (shouldFireInputNeeded) {
+            if (this._isSensitivePrompt(outputLastLine)) {
+                this._logService.trace("OutputMonitor: Sensitive input prompt detected, signaling sensitive UI");
+                this._onDidDetectSensitiveInputNeeded.fire();
+            } else {
+                this._logService.trace("OutputMonitor: Input-required pattern detected, signaling agent");
+                this._onDidDetectInputNeeded.fire();
+            }
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        this._cleanupIdleInputListener();
+        const custom = await this._pollFn?.(this._execution, token, this._taskService);
+        this._logService.trace(`OutputMonitor: Custom poller result: ${custom ? "provided" : "none"}`);
+        const resources = custom?.resources;
+        return {
+            resources,
+            shouldContinuePolling: false,
+            output: custom?.output ?? output
+        };
+    }
+    async _handleTimeoutState(_command, _invocationContext, _extended, _token) {
+        if (_extended) {
+            this._logService.info(
+                "OutputMonitor: Extended polling timeout reached after 2 minutes, signaling potential input needed"
+            );
+            this._onDidDetectInputNeeded.fire();
+            this._state = OutputMonitorState.Cancelled;
+            return false;
+        }
+        return true;
+    }
+    async _waitForIdle(execution, extendedPolling, token) {
+        const maxWaitMs = extendedPolling ? PollingConsts.ExtendedPollingMaxDuration : PollingConsts.FirstPollingMaxDuration;
+        const maxInterval = PollingConsts.MaxPollingIntervalDuration;
+        let currentInterval = PollingConsts.MinPollingDuration;
+        let waited = 0;
+        let consecutiveIdleEvents = 0;
+        let hasReceivedData = false;
+        const onDataDisposable = execution.instance.onData(_data => {
+            hasReceivedData = true;
+        });
+        try {
+            while (!token.isCancellationRequested && waited < maxWaitMs) {
+                const waitTime = Math.min(currentInterval, maxWaitMs - waited);
+                try {
+                    await timeout(waitTime, token);
+                } catch (err) {
+                    if (token.isCancellationRequested) {
+                        return OutputMonitorState.Cancelled;
+                    }
+                    throw err;
+                }
+                waited += waitTime;
+                currentInterval = Math.min(currentInterval * 2, maxInterval);
+                const currentOutput = execution.getOutput();
+                const currentTail = currentOutput.slice(-1000);
+                const currentLastLine = getLastLine(currentTail);
+                if (detectsNonInteractiveHelpPattern(currentLastLine)) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> non-interactive help detected (waited=${waited}ms)`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+                const promptResult = detectsHighConfidenceInputPattern(currentLastLine);
+                if (promptResult) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> high-confidence input pattern detected (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+                if (hasReceivedData) {
+                    consecutiveIdleEvents = 0;
+                    hasReceivedData = false;
+                } else {
+                    consecutiveIdleEvents++;
+                }
+                const recentlyIdle = consecutiveIdleEvents >= PollingConsts.MinIdleEvents;
+                const isActive = execution.isActive ? await execution.isActive() : undefined;
+                this._logService.trace(
+                    `OutputMonitor: waitForIdle check: waited=${waited}ms, recentlyIdle=${recentlyIdle}, isActive=${isActive}`
+                );
+                if (recentlyIdle && isActive !== true) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> recentlyIdle && !active (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+                if (recentlyIdle && isActive === true && detectsLikelyInputRequiredPattern(currentLastLine)) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> broad input pattern detected while active+idle (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+            }
+        } finally {
+            onDataDisposable.dispose();
+        }
+        if (token.isCancellationRequested) {
+            return OutputMonitorState.Cancelled;
+        }
+        return OutputMonitorState.Timeout;
+    }
+    _setupIdleInputListener() {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this._userInputtedSinceIdleDetected = false;
+        this._logService.trace("OutputMonitor: Setting up idle input listener");
+        this._userInputListener.value = this._execution.instance.onDidInputData(() => {
+            this._userInputtedSinceIdleDetected = true;
+            this._logService.trace("OutputMonitor: Detected user terminal input while idle");
+        });
+    }
+    _cleanupIdleInputListener() {
+        this._userInputtedSinceIdleDetected = false;
+        this._userInputListener.clear();
+    }
+    _isSensitivePrompt(prompt) {
+        if (isCanonicalSudoSPrompt(this._command, prompt)) {
+            return false;
+        }
+        return detectsSensitiveInputPrompt(prompt);
+    }
+};
+OutputMonitor = ( __decorate([( __param(5, ITaskService)), ( __param(6, ITerminalLogService))], OutputMonitor));
+function isCanonicalSudoSPrompt(command, prompt) {
+    return /(?:^|\s)sudo\s+-S(?:\s|$)/.test(command) && /^\[sudo\]\s+password for .+:\s*$/i.test(prompt);
+}
+function detectsSensitiveInputPrompt(cursorLine) {
+    return /(password|passphrase|token|api\s*key|secret|verification code|otp\b|one[\s-]?time (?:code|password)|2fa|mfa|pin\s*(?:code|number)?[: ]?\s*$|authentication code)/i.test(cursorLine);
+}
+function detectsHighConfidenceInputPattern(cursorLine) {
+    return ([
+        /\s*(?:\[[^\]]\][^\[]*)+(?:\(default is\s+"[^"]+"\):)?\s+$/,
+        /(?:\(|\[)\s*(?:y(?:es)?\s*\/\s*n(?:o)?|n(?:o)?\s*\/\s*y(?:es)?)\s*(?:\]|\))\s+$/i,
+        /[?:]\s*(?:\(|\[)?\s*y(?:es)?\s*\/\s*n(?:o)?\s*(?:\]|\))?\s+$/i,
+        /\(y\) +$/i,
+        /:\s+\([^)]*\) +$/,
+        /\(END\)$/,
+        /password(?: for [^:]+)?:\s*$/i,
+        /press a(?:ny)? key/i,
+        /^(?:\s|\x1b\[[0-9;]*m)*\?.*[›❯▸▶]\s*$/
+    ].some(e => e.test(cursorLine)));
+}
+function detectsInputRequiredPattern(cursorLine) {
+    return detectsHighConfidenceInputPattern(cursorLine);
+}
+function detectsLikelyInputRequiredPattern(cursorLine) {
+    if (detectsHighConfidenceInputPattern(cursorLine)) {
+        return true;
+    }
+    return ([
+        /: +$/,
+        /\? *(?:\([a-z\s]+\))? +$/i
+    ].some(e => e.test(cursorLine)));
+}
+function detectsNonInteractiveHelpPattern(cursorLine) {
+    return ([
+        /press [h?]\s*(?:\+\s*enter)?\s*to (?:show|open|display|get|see)\s*(?:available )?(?:help|commands|options)/i,
+        /press h\s*(?:or\s*\?)?\s*(?:\+\s*enter)?\s*for (?:help|commands|options)/i,
+        /press \?\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:help|commands|options|list)/i,
+        /type\s*[h?]\s*(?:\+\s*enter)?\s*(?:for|to see|to show)\s*(?:help|commands|options)/i,
+        /hit\s*[h?]\s*(?:\+\s*enter)?\s*(?:for|to see|to show)\s*(?:help|commands|options)/i,
+        /press o\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:open|launch)(?:\s*(?:the )?(?:app|application|browser)|\s+in\s+(?:the\s+)?browser)?/i,
+        /press r\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:restart|reload|refresh)(?:\s*(?:the )?(?:server|dev server|service))?/i,
+        /press q\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:quit|exit|stop)(?:\s*(?:the )?(?:server|app|process))?/i,
+        /press u\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:show|print|display)\s*(?:the )?(?:server )?urls?/i
+    ].some(e => e.test(cursorLine)));
+}
+const taskFinishMessages = [(
+localize(14664, "Terminal will be reused by tasks, press any key to close it.")), ( localize(14665, "Terminal will be reused by tasks, press any key to close it.")), (
+localize(14666, "Press any key to close the terminal.")), ( localize(14667, "Press any key to close the terminal.")), (
+localize(14668, "The terminal will be reused by tasks. Press any key to close."))];
+const normalizedTaskFinishMessages = ( taskFinishMessages.map(msg => msg.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase()));
+function detectsVSCodeTaskFinishMessage(cursorLine) {
+    const compact = cursorLine.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase();
+    return ( normalizedTaskFinishMessages.some(msg => compact.includes(msg)));
+}
+function detectsGenericPressAnyKeyPattern(cursorLine) {
+    if (detectsVSCodeTaskFinishMessage(cursorLine)) {
+        return false;
+    }
+    return /press a(?:ny)? key/i.test(cursorLine);
+}
+
+export { OutputMonitor, detectsGenericPressAnyKeyPattern, detectsHighConfidenceInputPattern, detectsInputRequiredPattern, detectsLikelyInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsSensitiveInputPrompt, detectsVSCodeTaskFinishMessage, getLastLine };

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

@@ -0,0 +1,42 @@
+import type { Task } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { ILinkLocation } from "../../taskHelpers.js";
+import type { IMarker as XtermMarker } from "@xterm/xterm";
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export interface IConfirmationPrompt {
+    prompt: string;
+    options: string[];
+    descriptions?: string[];
+    detectedRequestForFreeFormInput: boolean;
+    suggestedInput?: string;
+}
+export interface IExecution {
+    getOutput: (marker?: XtermMarker) => string;
+    isActive?: () => Promise<boolean>;
+    task?: Task | Pick<Task, "configurationProperties">;
+    dependencyTasks?: Task[];
+    instance: Pick<ITerminalInstance, "sendText" | "instanceId" | "onDidInputData" | "onDisposed" | "onData" | "focus" | "registerMarker">;
+    sessionResource: URI | undefined;
+}
+export interface IPollingResult {
+    output: string;
+    resources?: ILinkLocation[];
+    state: OutputMonitorState;
+}
+export declare enum OutputMonitorState {
+    Initial = "Initial",
+    Idle = "Idle",
+    PollingForIdle = "PollingForIdle",
+    Prompting = "Prompting",
+    Timeout = "Timeout",
+    Active = "Active",
+    Cancelled = "Cancelled"
+}
+export declare enum PollingConsts {
+    MinIdleEvents = 2,// Minimum number of idle checks before considering the terminal idle
+    MinPollingDuration = 500,
+    FirstPollingMaxDuration = 20000,// 20 seconds
+    ExtendedPollingMaxDuration = 120000,// 2 minutes
+    MaxPollingIntervalDuration = 10000,// 10 seconds - grows via exponential backoff
+    MaxRecursionCount = 5
+}

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

@@ -0,0 +1,23 @@
+
+
+var OutputMonitorState;
+(function (OutputMonitorState) {
+    OutputMonitorState["Initial"] = "Initial";
+    OutputMonitorState["Idle"] = "Idle";
+    OutputMonitorState["PollingForIdle"] = "PollingForIdle";
+    OutputMonitorState["Prompting"] = "Prompting";
+    OutputMonitorState["Timeout"] = "Timeout";
+    OutputMonitorState["Active"] = "Active";
+    OutputMonitorState["Cancelled"] = "Cancelled";
+})(OutputMonitorState || (OutputMonitorState = {}));
+var PollingConsts;
+(function (PollingConsts) {
+    PollingConsts[PollingConsts["MinIdleEvents"] = 2] = "MinIdleEvents";
+    PollingConsts[PollingConsts["MinPollingDuration"] = 500] = "MinPollingDuration";
+    PollingConsts[PollingConsts["FirstPollingMaxDuration"] = 20000] = "FirstPollingMaxDuration";
+    PollingConsts[PollingConsts["ExtendedPollingMaxDuration"] = 120000] = "ExtendedPollingMaxDuration";
+    PollingConsts[PollingConsts["MaxPollingIntervalDuration"] = 10000] = "MaxPollingIntervalDuration";
+    PollingConsts[PollingConsts["MaxRecursionCount"] = 5] = "MaxRecursionCount";
+})(PollingConsts || (PollingConsts = {}));
+
+export { OutputMonitorState, PollingConsts };

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

@@ -0,0 +1,9 @@
+export interface IOutputAnalyzerOptions {
+    readonly exitCode: number | undefined;
+    readonly exitResult: string;
+    readonly commandLine: string;
+    readonly isSandboxWrapped: boolean;
+}
+export interface IOutputAnalyzer {
+    analyze(options: IOutputAnalyzerOptions): Promise<string | undefined>;
+}

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

@@ -1,6 +1,6 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
-import { RunInTerminalTool } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool";
+import { RunInTerminalTool } from "./runInTerminalTool.js";
 export declare const ConfirmTerminalCommandToolData: IToolData;
 export declare class ConfirmTerminalCommandTool extends RunInTerminalTool {
     protected get _enableCommandLineSandboxRewriting(): boolean;

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

@@ -2,12 +2,12 @@
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { RunInTerminalTool } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool';
+import { RunInTerminalTool } from './runInTerminalTool.js';
 import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
 
 const ConfirmTerminalCommandToolData = {
     id: TerminalToolId.ConfirmTerminalCommand,
-    displayName: ( localize(14480, "Confirm Terminal Command")),
+    displayName: ( localize(14669, "Confirm Terminal Command")),
     modelDescription: [
         "This tool allows you to get explicit user confirmation for a terminal command without executing it.",
         "",
@@ -25,7 +25,7 @@ const ConfirmTerminalCommandToolData = {
         "",
         "After confirmation, use a tool to actually execute the command."
     ].join("\n"),
-    userDescription: ( localize(14481, "Tool for confirming terminal commands")),
+    userDescription: ( localize(14670, "Tool for confirming terminal commands")),
     source: ToolDataSource.Internal,
     icon: Codicon.shield,
     inputSchema: {