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

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

@@ -0,0 +1,411 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { createElement, trackFocus, getActiveWindow, Dimension } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { createCancelablePromise, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { MicrotaskDelay } from '@codingame/monaco-vscode-api/vscode/vs/base/common/symbols';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { showChatView } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { isCellTextEditOperation } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { InlineChatWidget } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatWidget';
+import { MENU_INLINE_CHAT_WIDGET_SECONDARY } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { TerminalStickyScrollContribution } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminalContrib/stickyScroll/browser/terminalStickyScrollContribution';
+import * as terminalChatWidget from './media/terminalChatWidget.css';
+import { TerminalChatContextKeys, MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR, TerminalChatCommandId, MENU_TERMINAL_CHAT_WIDGET_STATUS } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(terminalChatWidget);
+var Constants;
+(function (Constants) {
+    Constants[Constants["HorizontalMargin"] = 10] = "HorizontalMargin";
+    Constants[Constants["VerticalMargin"] = 30] = "VerticalMargin";
+    Constants[Constants["RightPadding"] = 12] = "RightPadding";
+    Constants[Constants["MaxHeight"] = 480] = "MaxHeight";
+    Constants[Constants["MaxHeightPercentageOfViewport"] = 0.75] = "MaxHeightPercentageOfViewport";
+})(Constants || (Constants = {}));
+var Message;
+(function (Message) {
+    Message[Message["None"] = 0] = "None";
+    Message[Message["AcceptSession"] = 1] = "AcceptSession";
+    Message[Message["CancelSession"] = 2] = "CancelSession";
+    Message[Message["PauseSession"] = 4] = "PauseSession";
+    Message[Message["CancelRequest"] = 8] = "CancelRequest";
+    Message[Message["CancelInput"] = 16] = "CancelInput";
+    Message[Message["AcceptInput"] = 32] = "AcceptInput";
+    Message[Message["ReturnInput"] = 64] = "ReturnInput";
+})(Message || (Message = {}));
+let TerminalChatWidget = class TerminalChatWidget extends Disposable {
+    get inlineChatWidget() { return this._inlineChatWidget; }
+    get lastResponseContent() {
+        return this._lastResponseContent;
+    }
+    constructor(_terminalElement, _instance, _xterm, contextKeyService, _chatService, _storageService, _viewsService, instantiationService, _chatAgentService) {
+        super();
+        this._terminalElement = _terminalElement;
+        this._instance = _instance;
+        this._xterm = _xterm;
+        this._chatService = _chatService;
+        this._storageService = _storageService;
+        this._viewsService = _viewsService;
+        this._chatAgentService = _chatAgentService;
+        this._onDidHide = this._register(( new Emitter()));
+        this.onDidHide = this._onDidHide.event;
+        this._messages = this._store.add(( new Emitter()));
+        this._viewStateStorageKey = 'terminal-inline-chat-view-state';
+        this._terminalAgentName = 'terminal';
+        this._model = this._register(( new MutableDisposable()));
+        this._requestInProgress = observableValue(this, false);
+        this.requestInProgress = this._requestInProgress;
+        this._focusedContextKey = TerminalChatContextKeys.focused.bindTo(contextKeyService);
+        this._visibleContextKey = TerminalChatContextKeys.visible.bindTo(contextKeyService);
+        this._requestActiveContextKey = TerminalChatContextKeys.requestActive.bindTo(contextKeyService);
+        this._responseContainsCodeBlockContextKey = TerminalChatContextKeys.responseContainsCodeBlock.bindTo(contextKeyService);
+        this._responseContainsMulitpleCodeBlocksContextKey = TerminalChatContextKeys.responseContainsMultipleCodeBlocks.bindTo(contextKeyService);
+        this._container = createElement('div');
+        this._container.classList.add('terminal-inline-chat');
+        this._terminalElement.appendChild(this._container);
+        this._inlineChatWidget = instantiationService.createInstance(InlineChatWidget, {
+            location: ChatAgentLocation.Terminal,
+            resolveData: () => {
+                return undefined;
+            }
+        }, {
+            statusMenuId: {
+                menu: MENU_TERMINAL_CHAT_WIDGET_STATUS,
+                options: {
+                    buttonConfigProvider: action => ({
+                        showLabel: action.id !== TerminalChatCommandId.RerunRequest,
+                        showIcon: action.id === TerminalChatCommandId.RerunRequest,
+                        isSecondary: action.id !== TerminalChatCommandId.RunCommand && action.id !== TerminalChatCommandId.RunFirstCommand
+                    })
+                }
+            },
+            secondaryMenuId: MENU_INLINE_CHAT_WIDGET_SECONDARY,
+            chatWidgetViewOptions: {
+                menus: {
+                    telemetrySource: 'terminal-inline-chat',
+                    executeToolbar: MenuId.ChatExecute,
+                    inputSideToolbar: MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR,
+                }
+            }
+        });
+        this._register(this._inlineChatWidget.chatWidget.onDidChangeViewModel(() => this._saveViewState()));
+        this._register(Event.any(this._inlineChatWidget.onDidChangeHeight, this._instance.onDimensionsChanged, this._inlineChatWidget.chatWidget.onDidChangeContentHeight, Event.debounce(this._xterm.raw.onCursorMove, () => void 0, MicrotaskDelay))(() => this._relayout()));
+        const observer = ( new ResizeObserver(() => this._relayout()));
+        observer.observe(this._terminalElement);
+        this._register(toDisposable(() => observer.disconnect()));
+        this._resetPlaceholder();
+        this._container.appendChild(this._inlineChatWidget.domNode);
+        this._focusTracker = this._register(trackFocus(this._container));
+        this._register(this._focusTracker.onDidFocus(() => this._focusedContextKey.set(true)));
+        this._register(this._focusTracker.onDidBlur(() => this._focusedContextKey.set(false)));
+        this._register(autorun(r => {
+            const isBusy = this._inlineChatWidget.requestInProgress.read(r);
+            this._container.classList.toggle('busy', isBusy);
+            this._inlineChatWidget.toggleStatus(!!this._inlineChatWidget.responseContent);
+            if (isBusy || !this._inlineChatWidget.responseContent) {
+                this._responseContainsCodeBlockContextKey.set(false);
+                this._responseContainsMulitpleCodeBlocksContextKey.set(false);
+            }
+            else {
+                Promise.all([
+                    this._inlineChatWidget.getCodeBlockInfo(0),
+                    this._inlineChatWidget.getCodeBlockInfo(1)
+                ]).then(([firstCodeBlock, secondCodeBlock]) => {
+                    this._responseContainsCodeBlockContextKey.set(!!firstCodeBlock);
+                    this._responseContainsMulitpleCodeBlocksContextKey.set(!!secondCodeBlock);
+                    this._inlineChatWidget.updateToolbar(true);
+                });
+            }
+        }));
+        this.hide();
+    }
+    _relayout() {
+        if (this._dimension) {
+            this._doLayout();
+        }
+    }
+    _doLayout() {
+        const xtermElement = this._xterm.raw.element;
+        if (!xtermElement) {
+            return;
+        }
+        const style = getActiveWindow().getComputedStyle(xtermElement);
+        const xtermLeftPadding = parseInt(style.paddingLeft);
+        const width = xtermElement.clientWidth - xtermLeftPadding - Constants.RightPadding;
+        if (width === 0) {
+            return;
+        }
+        const terminalViewportHeight = this._getTerminalViewportHeight();
+        const widgetAllowedPercentBasedHeight = (terminalViewportHeight ?? 0) * Constants.MaxHeightPercentageOfViewport;
+        const height = Math.max(Math.min(Constants.MaxHeight, this._inlineChatWidget.contentHeight, widgetAllowedPercentBasedHeight), this._inlineChatWidget.minHeight);
+        if (height === 0) {
+            return;
+        }
+        this._dimension = ( new Dimension(width, height));
+        this._inlineChatWidget.layout(this._dimension);
+        this._inlineChatWidget.domNode.style.paddingLeft = `${xtermLeftPadding}px`;
+        this._updateXtermViewportPosition();
+    }
+    _resetPlaceholder() {
+        const defaultAgent = this._chatAgentService.getDefaultAgent(ChatAgentLocation.Terminal);
+        this.inlineChatWidget.placeholder = defaultAgent?.description ?? ( localize(11252, 'Ask about commands'));
+    }
+    async reveal(viewState) {
+        await this._createSession(viewState);
+        this._doLayout();
+        this._container.classList.remove('hide');
+        this._visibleContextKey.set(true);
+        this._resetPlaceholder();
+        this._inlineChatWidget.focus();
+        this._instance.scrollToBottom();
+    }
+    _getTerminalCursorTop() {
+        const font = this._instance.xterm?.getFont();
+        if (!font?.charHeight) {
+            return;
+        }
+        const terminalWrapperHeight = this._getTerminalViewportHeight() ?? 0;
+        const cellHeight = font.charHeight * font.lineHeight;
+        const topPadding = terminalWrapperHeight - (this._instance.rows * cellHeight);
+        const cursorY = (this._instance.xterm?.raw.buffer.active.cursorY ?? 0) + 1;
+        return topPadding + cursorY * cellHeight;
+    }
+    _updateXtermViewportPosition() {
+        const top = this._getTerminalCursorTop();
+        if (!top) {
+            return;
+        }
+        this._container.style.top = `${top}px`;
+        const terminalViewportHeight = this._getTerminalViewportHeight();
+        if (!terminalViewportHeight) {
+            return;
+        }
+        const widgetAllowedPercentBasedHeight = terminalViewportHeight * Constants.MaxHeightPercentageOfViewport;
+        const height = Math.max(Math.min(Constants.MaxHeight, this._inlineChatWidget.contentHeight, widgetAllowedPercentBasedHeight), this._inlineChatWidget.minHeight);
+        if (top > terminalViewportHeight - height && terminalViewportHeight - height > 0) {
+            this._setTerminalViewportOffset(top - (terminalViewportHeight - height));
+        }
+        else {
+            this._setTerminalViewportOffset(undefined);
+        }
+    }
+    _getTerminalViewportHeight() {
+        return this._terminalElement.clientHeight;
+    }
+    hide() {
+        this._container.classList.add('hide');
+        this._inlineChatWidget.reset();
+        this._resetPlaceholder();
+        this._inlineChatWidget.updateToolbar(false);
+        this._visibleContextKey.set(false);
+        this._inlineChatWidget.value = '';
+        this._instance.focus();
+        this._setTerminalViewportOffset(undefined);
+        this._onDidHide.fire();
+    }
+    _setTerminalViewportOffset(offset) {
+        if (offset === undefined || this._container.classList.contains('hide')) {
+            this._terminalElement.style.position = '';
+            this._terminalElement.style.bottom = '';
+            TerminalStickyScrollContribution.get(this._instance)?.hideUnlock();
+        }
+        else {
+            this._terminalElement.style.position = 'relative';
+            this._terminalElement.style.bottom = `${offset}px`;
+            TerminalStickyScrollContribution.get(this._instance)?.hideLock();
+        }
+    }
+    focus() {
+        this.inlineChatWidget.focus();
+    }
+    hasFocus() {
+        return this._inlineChatWidget.hasFocus();
+    }
+    setValue(value) {
+        this._inlineChatWidget.value = value ?? '';
+    }
+    async acceptCommand(shouldExecute) {
+        const code = await this.inlineChatWidget.getCodeBlockInfo(0);
+        if (!code) {
+            return;
+        }
+        const value = code.getValue();
+        this._instance.runCommand(value, shouldExecute);
+        this.clear();
+    }
+    get focusTracker() {
+        return this._focusTracker;
+    }
+    async _createSession(viewState) {
+        this._sessionCtor = createCancelablePromise(async (token) => {
+            if (!this._model.value) {
+                this._model.value = this._chatService.startSession(ChatAgentLocation.Terminal, token);
+                const model = this._model.value;
+                if (model) {
+                    this._inlineChatWidget.setChatModel(model, this._loadViewState());
+                    this._resetPlaceholder();
+                }
+                if (!this._model.value) {
+                    throw ( new Error('Failed to start chat session'));
+                }
+            }
+        });
+        this._register(toDisposable(() => this._sessionCtor?.cancel()));
+    }
+    _loadViewState() {
+        const rawViewState = this._storageService.get(this._viewStateStorageKey, StorageScope.PROFILE, undefined);
+        let viewState;
+        if (rawViewState) {
+            try {
+                viewState = JSON.parse(rawViewState);
+            }
+            catch {
+                viewState = undefined;
+            }
+        }
+        return viewState;
+    }
+    _saveViewState() {
+        this._storageService.store(this._viewStateStorageKey, JSON.stringify(this._inlineChatWidget.chatWidget.getViewState()), StorageScope.PROFILE, StorageTarget.USER);
+    }
+    clear() {
+        this.cancel();
+        this._model.clear();
+        this._responseContainsCodeBlockContextKey.reset();
+        this._requestActiveContextKey.reset();
+        this.hide();
+        this.setValue(undefined);
+    }
+    async acceptInput(query, options) {
+        if (!this._model.value) {
+            await this.reveal();
+        }
+        this._messages.fire(Message.AcceptInput);
+        const lastInput = this._inlineChatWidget.value;
+        if (!lastInput) {
+            return;
+        }
+        this._activeRequestCts?.cancel();
+        this._activeRequestCts = ( new CancellationTokenSource());
+        const store = ( new DisposableStore());
+        this._requestActiveContextKey.set(true);
+        const response = await this._inlineChatWidget.chatWidget.acceptInput(lastInput, { isVoiceInput: options?.isVoiceInput });
+        this._currentRequestId = response?.requestId;
+        const responsePromise = ( new DeferredPromise());
+        try {
+            this._requestActiveContextKey.set(true);
+            if (response) {
+                store.add(response.onDidChange(async () => {
+                    if (response.isCanceled) {
+                        this._requestActiveContextKey.set(false);
+                        responsePromise.complete(undefined);
+                        return;
+                    }
+                    if (response.isComplete) {
+                        this._requestActiveContextKey.set(false);
+                        this._requestActiveContextKey.set(false);
+                        const firstCodeBlock = await this._inlineChatWidget.getCodeBlockInfo(0);
+                        const secondCodeBlock = await this._inlineChatWidget.getCodeBlockInfo(1);
+                        this._responseContainsCodeBlockContextKey.set(!!firstCodeBlock);
+                        this._responseContainsMulitpleCodeBlocksContextKey.set(!!secondCodeBlock);
+                        this._inlineChatWidget.updateToolbar(true);
+                        responsePromise.complete(response);
+                    }
+                }));
+            }
+            await responsePromise.p;
+            this._lastResponseContent = response?.response.getMarkdown();
+            return response;
+        }
+        catch {
+            this._lastResponseContent = undefined;
+            return;
+        }
+        finally {
+            store.dispose();
+        }
+    }
+    cancel() {
+        this._sessionCtor?.cancel();
+        this._sessionCtor = undefined;
+        this._activeRequestCts?.cancel();
+        this._requestActiveContextKey.set(false);
+        const model = this._inlineChatWidget.getChatModel();
+        if (!model?.sessionId) {
+            return;
+        }
+        this._chatService.cancelCurrentRequestForSession(model?.sessionId);
+    }
+    async viewInChat() {
+        const widget = await showChatView(this._viewsService);
+        const currentRequest = this._inlineChatWidget.chatWidget.viewModel?.model.getRequests().find(r => r.id === this._currentRequestId);
+        if (!widget || !currentRequest?.response) {
+            return;
+        }
+        const message = [];
+        for (const item of currentRequest.response.response.value) {
+            if (item.kind === 'textEditGroup') {
+                for (const group of item.edits) {
+                    message.push({
+                        kind: 'textEdit',
+                        edits: group,
+                        uri: item.uri
+                    });
+                }
+            }
+            else if (item.kind === 'notebookEditGroup') {
+                for (const group of item.edits) {
+                    if (isCellTextEditOperation(group)) {
+                        message.push({
+                            kind: 'textEdit',
+                            edits: [group.edit],
+                            uri: group.uri
+                        });
+                    }
+                    else {
+                        message.push({
+                            kind: 'notebookEdit',
+                            edits: [group],
+                            uri: item.uri
+                        });
+                    }
+                }
+            }
+            else {
+                message.push(item);
+            }
+        }
+        this._chatService.addCompleteRequest(widget.viewModel.sessionId, `@${this._terminalAgentName} ${currentRequest.message.text}`, currentRequest.variableData, currentRequest.attempt, {
+            message,
+            result: currentRequest.response.result,
+            followups: currentRequest.response.followups
+        });
+        widget.focusLastMessage();
+        this.hide();
+    }
+};
+TerminalChatWidget = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IChatService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IViewsService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IChatAgentService))
+], TerminalChatWidget));
+
+export { TerminalChatWidget };

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

@@ -0,0 +1,3 @@
+import type { IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+export declare function getRecommendedToolsOverRunInTerminal(commandLine: string, languageModelToolsService: ILanguageModelToolsService): IToolResult | undefined;

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

@@ -0,0 +1,59 @@
+
+
+let previouslyRecommededInSession = false;
+const terminalCommands = [
+    {
+        commands: [
+            ( new RegExp(/^python3? -m pip install(\b)/)),
+            ( new RegExp(/^pip3? install(\b)/)),
+        ],
+        tags: ['python environment'],
+    },
+    {
+        commands: [
+            ( new RegExp(/^python3? -m jupyter(\b)/)),
+            ( new RegExp(/^python3? -m pip install\b.*jupyter\b.*/)),
+            ( new RegExp(/^pip3? install\b.*jupyter\b.*/)),
+            (
+            new RegExp(/^jupyter(\b)/)),
+        ],
+        tags: ['python environment', 'jupyter environment'],
+    }
+];
+function getRecommendedToolsOverRunInTerminal(commandLine, languageModelToolsService) {
+    const tools = languageModelToolsService.getTools();
+    if (!tools || previouslyRecommededInSession) {
+        return;
+    }
+    const recommendedTools = ( new Set());
+    const messages = [
+        `The terminal command '${commandLine}' was not executed.`,
+        `Try using some of the following tools instead of running a Terminal Command (if unable to use one of these tools as an alternative then run the same terminal command again):`,
+    ];
+    for (const terminalCommand of terminalCommands) {
+        if (!( terminalCommand.commands.some((condition) => condition.test(commandLine)))) {
+            continue;
+        }
+        const tagsToSearchFor = terminalCommand.tags;
+        Array.from(tools)
+            .filter(t => ( tagsToSearchFor.some(tag => t.tags?.includes(tag))))
+            .forEach(tool => {
+            recommendedTools.add(tool.id);
+        });
+    }
+    recommendedTools.forEach(toolName => {
+        messages.push(`- ${toolName}`);
+    });
+    if (recommendedTools.size) {
+        previouslyRecommededInSession = true;
+        return {
+            content: [{
+                    kind: 'text',
+                    value: messages.join('  \n')
+                }],
+        };
+    }
+    return undefined;
+}
+
+export { getRecommendedToolsOverRunInTerminal };

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

@@ -0,0 +1,51 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ChatElicitationRequestPart } from "@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/workbench/contrib/chat/browser/chatElicitationRequestPart";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IToolInvocationContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+export declare enum PollingConsts {
+    MinNoDataEvents = 2,
+    MinPollingDuration = 500,
+    FirstPollingMaxDuration = 20000,
+    ExtendedPollingMaxDuration = 120000,
+    MaxPollingIntervalDuration = 2000
+}
+export declare function racePollingOrPrompt(pollFn: () => Promise<{
+    terminalExecutionIdleBeforeTimeout: boolean;
+    output: string;
+    pollDurationMs?: number;
+    modelOutputEvalResponse?: string;
+}>, promptFn: () => {
+    promise: Promise<boolean>;
+    part?: Pick<ChatElicitationRequestPart, "hide" | "onDidRequestHide">;
+}, originalResult: {
+    terminalExecutionIdleBeforeTimeout: boolean;
+    output: string;
+    pollDurationMs?: number;
+    modelOutputEvalResponse?: string;
+}, token: CancellationToken, languageModelsService: ILanguageModelsService, execution: {
+    getOutput: () => string;
+    isActive?: () => Promise<boolean>;
+}): Promise<{
+    terminalExecutionIdleBeforeTimeout: boolean;
+    output: string;
+    pollDurationMs?: number;
+    modelOutputEvalResponse?: string;
+}>;
+export declare function getOutput(instance: ITerminalInstance, startMarker?: IXtermMarker): string;
+export declare function pollForOutputAndIdle(execution: {
+    getOutput: () => string;
+    isActive?: () => Promise<boolean>;
+}, extendedPolling: boolean, token: CancellationToken, languageModelsService: ILanguageModelsService): Promise<{
+    terminalExecutionIdleBeforeTimeout: boolean;
+    output: string;
+    pollDurationMs?: number;
+    modelOutputEvalResponse?: string;
+}>;
+export declare function promptForMorePolling(command: string, token: CancellationToken, context: IToolInvocationContext, chatService: IChatService): {
+    promise: Promise<boolean>;
+    part?: ChatElicitationRequestPart;
+};
+export declare function assessOutputForErrors(buffer: string, token: CancellationToken, languageModelsService: ILanguageModelsService): Promise<string>;