@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.d.ts

@@ -0,0 +1,68 @@
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { IChatToolInvocation, type IChatTerminalToolInvocationData, type ILegacyChatTerminalToolInvocationData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import type { CodeBlockModelCollection } from "../../../common/codeBlockModelCollection.js";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { EditorPool } from "../chatContentCodePools.js";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare enum TerminalToolConfirmationStorageKeys {
+    TerminalAutoApproveWarningAccepted = "chat.tools.terminal.autoApprove.warningAccepted"
+}
+export interface ITerminalNewAutoApproveRule {
+    key: string;
+    value: boolean | {
+        approve: boolean;
+        matchCommandLine?: boolean;
+    };
+}
+export type TerminalNewAutoApproveButtonData = ({
+    type: "enable";
+} | {
+    type: "configure";
+} | {
+    type: "skip";
+} | {
+    type: "newRule";
+    rule: ITerminalNewAutoApproveRule | ITerminalNewAutoApproveRule[];
+} | {
+    type: "sessionApproval";
+});
+export declare class ChatTerminalToolConfirmationSubPart extends BaseChatToolInvocationSubPart {
+    private readonly context;
+    private readonly renderer;
+    private readonly editorPool;
+    private readonly currentWidthDelegate;
+    private readonly codeBlockModelCollection;
+    private readonly codeBlockStartIndex;
+    private readonly instantiationService;
+    private readonly dialogService;
+    private readonly keybindingService;
+    private readonly modelService;
+    private readonly languageService;
+    private readonly configurationService;
+    private readonly contextKeyService;
+    private readonly chatWidgetService;
+    private readonly preferencesService;
+    private readonly storageService;
+    private readonly terminalChatService;
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation, terminalData: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, codeBlockStartIndex: number, instantiationService: IInstantiationService, dialogService: IDialogService, keybindingService: IKeybindingService, modelService: IModelService, languageService: ILanguageService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, preferencesService: IPreferencesService, storageService: IStorageService, terminalChatService: ITerminalChatService, textModelService: ITextModelService, hoverService: IHoverService);
+    private _createButtons;
+    private _showAutoApproveWarning;
+    private _getUniqueCodeBlockUri;
+    private _appendMarkdownPart;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js

@@ -0,0 +1,353 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { h, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { HoverStyle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover';
+import { HoverPosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { createCommandUri, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { thenRegisterOrDispose, thenIfNotDisposed, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+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 { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { ITerminalChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { TerminalContribSettingId, TerminalContribCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/terminalContribExports';
+import { migrateLegacyTerminalToolSpecificData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ToolConfirmKind, IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { AcceptToolConfirmationActionId, SkipToolConfirmationActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatCustomConfirmationWidget } from '../chatConfirmationWidget.js';
+import { ChatMarkdownContentPart } from '../chatMarkdownContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+
+var TerminalToolConfirmationStorageKeys;
+(function (TerminalToolConfirmationStorageKeys) {
+    TerminalToolConfirmationStorageKeys["TerminalAutoApproveWarningAccepted"] = "chat.tools.terminal.autoApprove.warningAccepted";
+})(TerminalToolConfirmationStorageKeys || (TerminalToolConfirmationStorageKeys = {}));
+let ChatTerminalToolConfirmationSubPart = class ChatTerminalToolConfirmationSubPart extends BaseChatToolInvocationSubPart {
+    constructor(toolInvocation, terminalData, context, renderer, editorPool, currentWidthDelegate, codeBlockModelCollection, codeBlockStartIndex, instantiationService, dialogService, keybindingService, modelService, languageService, configurationService, contextKeyService, chatWidgetService, preferencesService, storageService, terminalChatService, textModelService, hoverService) {
+        super(toolInvocation);
+        this.context = context;
+        this.renderer = renderer;
+        this.editorPool = editorPool;
+        this.currentWidthDelegate = currentWidthDelegate;
+        this.codeBlockModelCollection = codeBlockModelCollection;
+        this.codeBlockStartIndex = codeBlockStartIndex;
+        this.instantiationService = instantiationService;
+        this.dialogService = dialogService;
+        this.keybindingService = keybindingService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.configurationService = configurationService;
+        this.contextKeyService = contextKeyService;
+        this.chatWidgetService = chatWidgetService;
+        this.preferencesService = preferencesService;
+        this.storageService = storageService;
+        this.terminalChatService = terminalChatService;
+        this.codeblocks = [];
+        if (toolInvocation.fromSubAgent) {
+            context.container.classList.add('from-sub-agent');
+        }
+        if (!toolInvocation.confirmationMessages?.title) {
+            throw ( new Error('Confirmation messages are missing'));
+        }
+        terminalData = migrateLegacyTerminalToolSpecificData(terminalData);
+        const { title, message, disclaimer, terminalCustomActions } = toolInvocation.confirmationMessages;
+        const autoApproveEnabled = this.configurationService.getValue(TerminalContribSettingId.EnableAutoApprove) === true;
+        const autoApproveWarningAccepted = this.storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+        let moreActions = undefined;
+        if (autoApproveEnabled) {
+            moreActions = [];
+            if (!autoApproveWarningAccepted) {
+                moreActions.push({
+                    label: ( localize(5137, 'Enable Auto Approve...')),
+                    data: {
+                        type: 'enable'
+                    }
+                });
+                moreActions.push(( new Separator()));
+                if (terminalCustomActions) {
+                    for (const action of terminalCustomActions) {
+                        if (!(action instanceof Separator)) {
+                            action.disabled = true;
+                        }
+                    }
+                }
+            }
+            if (terminalCustomActions) {
+                moreActions.push(...terminalCustomActions);
+            }
+            if (moreActions.length === 0) {
+                moreActions = undefined;
+            }
+        }
+        const codeBlockRenderOptions = {
+            hideToolbar: true,
+            reserveWidth: 19,
+            verticalPadding: 5,
+            editorOptions: {
+                wordWrap: 'on',
+                readOnly: false,
+                tabFocusMode: true,
+                ariaLabel: typeof title === 'string' ? title : title.value
+            }
+        };
+        const languageId = this.languageService.getLanguageIdByLanguageName(terminalData.language ?? 'sh') ?? 'shellscript';
+        const model = this._register(this.modelService.createModel(terminalData.commandLine.toolEdited ?? terminalData.commandLine.original, this.languageService.createById(languageId), this._getUniqueCodeBlockUri(), true));
+        thenRegisterOrDispose(textModelService.createModelReference(model.uri), this._store);
+        const editor = this._register(this.editorPool.get());
+        const renderPromise = editor.object.render({
+            codeBlockIndex: this.codeBlockStartIndex,
+            codeBlockPartIndex: 0,
+            element: this.context.element,
+            languageId,
+            renderOptions: codeBlockRenderOptions,
+            textModel: Promise.resolve(model),
+            chatSessionResource: this.context.element.sessionResource
+        }, this.currentWidthDelegate());
+        this._register(thenIfNotDisposed(renderPromise, () => this._onDidChangeHeight.fire()));
+        this.codeblocks.push({
+            codeBlockIndex: this.codeBlockStartIndex,
+            codemapperUri: undefined,
+            elementId: this.context.element.id,
+            focus: () => editor.object.focus(),
+            ownerMarkdownPartId: this.codeblocksPartId,
+            uri: model.uri,
+            uriPromise: Promise.resolve(model.uri),
+            chatSessionResource: this.context.element.sessionResource
+        });
+        this._register(editor.object.onDidChangeContentHeight(() => {
+            editor.object.layout(this.currentWidthDelegate());
+            this._onDidChangeHeight.fire();
+        }));
+        this._register(model.onDidChangeContent(e => {
+            terminalData.commandLine.userEdited = model.getValue();
+        }));
+        const elements = h('.chat-confirmation-message-terminal', [
+            h('.chat-confirmation-message-terminal-editor@editor'),
+            h('.chat-confirmation-message-terminal-disclaimer@disclaimer'),
+        ]);
+        append(elements.editor, editor.object.element);
+        this._register(hoverService.setupDelayedHover(elements.editor, {
+            content: message || '',
+            style: HoverStyle.Pointer,
+            position: { hoverPosition: HoverPosition.LEFT },
+        }));
+        const confirmWidget = this._register(this.instantiationService.createInstance((ChatCustomConfirmationWidget), this.context, {
+            title,
+            icon: Codicon.terminal,
+            message: elements.root,
+            buttons: this._createButtons(moreActions)
+        }));
+        if (disclaimer) {
+            this._appendMarkdownPart(elements.disclaimer, disclaimer, codeBlockRenderOptions);
+        }
+        const hasToolConfirmationKey = ChatContextKeys.Editing.hasToolConfirmation.bindTo(this.contextKeyService);
+        hasToolConfirmationKey.set(true);
+        this._register(toDisposable(() => hasToolConfirmationKey.reset()));
+        this._register(confirmWidget.onDidClick(async (button) => {
+            let doComplete = true;
+            const data = button.data;
+            let toolConfirmKind = ToolConfirmKind.Denied;
+            if (typeof data === 'boolean') {
+                if (data) {
+                    toolConfirmKind = ToolConfirmKind.UserAction;
+                    if (terminalData.autoApproveInfo) {
+                        terminalData.autoApproveInfo = undefined;
+                    }
+                }
+            }
+            else if (typeof data !== 'boolean') {
+                switch (data.type) {
+                    case 'enable': {
+                        const optedIn = await this._showAutoApproveWarning();
+                        if (optedIn) {
+                            this.storageService.store(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, true, StorageScope.APPLICATION, StorageTarget.USER);
+                            if (!terminalCustomActions) {
+                                toolConfirmKind = ToolConfirmKind.UserAction;
+                            }
+                            else {
+                                for (const action of terminalCustomActions) {
+                                    if (!(action instanceof Separator)) {
+                                        action.disabled = false;
+                                    }
+                                }
+                                confirmWidget.updateButtons(this._createButtons(terminalCustomActions));
+                                doComplete = false;
+                            }
+                        }
+                        else {
+                            doComplete = false;
+                        }
+                        break;
+                    }
+                    case 'skip': {
+                        toolConfirmKind = ToolConfirmKind.Skipped;
+                        break;
+                    }
+                    case 'newRule': {
+                        const newRules = asArray(data.rule);
+                        const inspect = this.configurationService.inspect(TerminalContribSettingId.AutoApprove);
+                        const oldValue = inspect.user?.value ?? {};
+                        let newValue;
+                        if (isObject(oldValue)) {
+                            newValue = { ...oldValue };
+                            for (const newRule of newRules) {
+                                newValue[newRule.key] = newRule.value;
+                            }
+                        }
+                        else {
+                            this.preferencesService.openSettings({
+                                jsonEditor: true,
+                                target: ConfigurationTarget.USER,
+                                revealSetting: {
+                                    key: TerminalContribSettingId.AutoApprove
+                                },
+                            });
+                            throw ( new ErrorNoTelemetry(`Cannot add new rule, existing setting is unexpected format`));
+                        }
+                        await this.configurationService.updateValue(TerminalContribSettingId.AutoApprove, newValue, ConfigurationTarget.USER);
+                        function formatRuleLinks(newRules) {
+                            return ( newRules.map(e => {
+                                const settingsUri = createCommandUri(TerminalContribCommandId.OpenTerminalSettingsLink, ConfigurationTarget.USER);
+                                return `[\`${e.key}\`](${( settingsUri.toString())} "${( localize(5138, 'View rule in settings'))}")`;
+                            })).join(', ');
+                        }
+                        const mdTrustSettings = {
+                            isTrusted: {
+                                enabledCommands: [TerminalContribCommandId.OpenTerminalSettingsLink]
+                            }
+                        };
+                        if (newRules.length === 1) {
+                            terminalData.autoApproveInfo = ( new MarkdownString(( localize(5139, 'Auto approve rule {0} added', formatRuleLinks(newRules))), mdTrustSettings));
+                        }
+                        else if (newRules.length > 1) {
+                            terminalData.autoApproveInfo = ( new MarkdownString(( localize(5140, 'Auto approve rules {0} added', formatRuleLinks(newRules))), mdTrustSettings));
+                        }
+                        toolConfirmKind = ToolConfirmKind.UserAction;
+                        break;
+                    }
+                    case 'configure': {
+                        this.preferencesService.openSettings({
+                            target: ConfigurationTarget.USER,
+                            query: `@id:${TerminalContribSettingId.AutoApprove}`,
+                        });
+                        doComplete = false;
+                        break;
+                    }
+                    case 'sessionApproval': {
+                        const sessionId = this.context.element.sessionId;
+                        this.terminalChatService.setChatSessionAutoApproval(sessionId, true);
+                        const disableUri = createCommandUri(TerminalContribCommandId.DisableSessionAutoApproval, sessionId);
+                        const mdTrustSettings = {
+                            isTrusted: {
+                                enabledCommands: [TerminalContribCommandId.DisableSessionAutoApproval]
+                            }
+                        };
+                        terminalData.autoApproveInfo = ( new MarkdownString(`${( localize(5141, 'All commands will be auto approved for this session'))} ([${( localize(5142, 'Disable'))}](${( disableUri.toString())}))`, mdTrustSettings));
+                        toolConfirmKind = ToolConfirmKind.UserAction;
+                        break;
+                    }
+                }
+            }
+            if (doComplete) {
+                IChatToolInvocation.confirmWith(toolInvocation, { type: toolConfirmKind });
+                this.chatWidgetService.getWidgetBySessionResource(this.context.element.sessionResource)?.focusInput();
+            }
+        }));
+        this._register(confirmWidget.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        this.domNode = confirmWidget.domNode;
+    }
+    _createButtons(moreActions) {
+        const getLabelAndTooltip = (label, actionId, tooltipDetail = label) => {
+            const keybinding = this.keybindingService.lookupKeybinding(actionId)?.getLabel();
+            const tooltip = keybinding ? `${tooltipDetail} (${keybinding})` : (tooltipDetail);
+            return { label, tooltip };
+        };
+        return [
+            {
+                ...getLabelAndTooltip(( localize(5143, "Allow")), AcceptToolConfirmationActionId),
+                data: true,
+                moreActions,
+            },
+            {
+                ...getLabelAndTooltip(( localize(5144, "Skip")), SkipToolConfirmationActionId, ( localize(5145, 'Proceed without executing this command'))),
+                data: { type: 'skip' },
+                isSecondary: true,
+            },
+        ];
+    }
+    async _showAutoApproveWarning() {
+        const promptResult = await this.dialogService.prompt({
+            type: Severity.Info,
+            message: ( localize(5146, 'Enable terminal auto approve?')),
+            buttons: [{
+                    label: ( localize(5147, 'Enable')),
+                    run: () => true
+                }],
+            cancelButton: true,
+            custom: {
+                icon: Codicon.shield,
+                markdownDetails: [{
+                        markdown: ( new MarkdownString(( localize(
+                            5148,
+                            'This will enable a configurable subset of commands to run in the terminal autonomously. It provides *best effort protections* and assumes the agent is not acting maliciously.'
+                        )))),
+                    }, {
+                        markdown: ( new MarkdownString(`[${( localize(5149, 'Learn more about the potential risks and how to avoid them.'))}](https://code.visualstudio.com/docs/copilot/security#_security-considerations)`))
+                    }],
+            }
+        });
+        return promptResult.result === true;
+    }
+    _getUniqueCodeBlockUri() {
+        return ( URI.from({
+            scheme: Schemas.vscodeChatCodeBlock,
+            path: generateUuid(),
+        }));
+    }
+    _appendMarkdownPart(container, message, codeBlockRenderOptions) {
+        const part = this._register(this.instantiationService.createInstance(ChatMarkdownContentPart, {
+            kind: 'markdownContent',
+            content: typeof message === 'string' ? ( new MarkdownString()).appendMarkdown(message) : message
+        }, this.context, this.editorPool, false, this.codeBlockStartIndex, this.renderer, undefined, this.currentWidthDelegate(), this.codeBlockModelCollection, { codeBlockRenderOptions }));
+        append(container, part.domNode);
+        this._register(part.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+    }
+};
+ChatTerminalToolConfirmationSubPart = ( __decorate([
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IDialogService)),
+    ( __param(10, IKeybindingService)),
+    ( __param(11, IModelService)),
+    ( __param(12, ILanguageService)),
+    ( __param(13, IConfigurationService)),
+    ( __param(14, IContextKeyService)),
+    ( __param(15, IChatWidgetService)),
+    ( __param(16, IPreferencesService)),
+    ( __param(17, IStorageService)),
+    ( __param(18, ITerminalChatService)),
+    ( __param(19, ITextModelService)),
+    ( __param(20, IHoverService))
+], ChatTerminalToolConfirmationSubPart));
+
+export { ChatTerminalToolConfirmationSubPart, TerminalToolConfirmationStorageKeys };

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolProgressPart.d.ts

@@ -0,0 +1,100 @@
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatToolInvocation, IChatToolInvocationSerialized, type IChatTerminalToolInvocationData, type ILegacyChatTerminalToolInvocationData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { CodeBlockModelCollection } from "../../../common/codeBlockModelCollection.js";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+import { Action, IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IChatTerminalToolProgressPart, ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalGroupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalCommand } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { EditorPool } from "../chatContentCodePools.js";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+export declare class ChatTerminalToolProgressPart extends BaseChatToolInvocationSubPart implements IChatTerminalToolProgressPart {
+    private readonly _instantiationService;
+    private readonly _terminalChatService;
+    private readonly _terminalService;
+    private readonly _contextKeyService;
+    private readonly _chatWidgetService;
+    private readonly _keybindingService;
+    readonly domNode: HTMLElement;
+    private readonly _actionBar;
+    private readonly _titleElement;
+    private readonly _outputView;
+    private readonly _terminalOutputContextKey;
+    private _terminalSessionRegistration;
+    private readonly _elementIndex;
+    private readonly _contentIndex;
+    private readonly _sessionResource;
+    private readonly _showOutputAction;
+    private _showOutputActionAdded;
+    private readonly _focusAction;
+    private readonly _terminalData;
+    private _terminalCommandUri;
+    private _storedCommandId;
+    private readonly _commandText;
+    private readonly _isSerializedInvocation;
+    private _terminalInstance;
+    private readonly _decoration;
+    private markdownPart;
+    get codeblocks(): IChatCodeBlockInfo[];
+    get elementIndex(): number;
+    get contentIndex(): number;
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, terminalData: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockStartIndex: number, codeBlockModelCollection: CodeBlockModelCollection, _instantiationService: IInstantiationService, _terminalChatService: ITerminalChatService, _terminalService: ITerminalService, _contextKeyService: IContextKeyService, _chatWidgetService: IChatWidgetService, _keybindingService: IKeybindingService);
+    private _initializeTerminalActions;
+    private _addActions;
+    private _getResolvedCommand;
+    private _ensureShowOutputAction;
+    private _clearCommandAssociation;
+    private _registerInstanceListener;
+    private _removeFocusAction;
+    private _toggleOutput;
+    private _ensureTerminalInstance;
+    private _handleOutputFocus;
+    private _handleOutputBlur;
+    private _handleDispose;
+    getCommandAndOutputAsText(): string | undefined;
+    focusOutput(): void;
+    private _focusChatInput;
+    focusTerminal(): Promise<void>;
+    toggleOutputFromKeyboard(): Promise<void>;
+    private _toggleOutputFromAction;
+    private _collapseOutputAndFocusInput;
+    private _resolveCommand;
+}
+export declare class ToggleChatTerminalOutputAction extends Action implements IAction {
+    private readonly _toggle;
+    private readonly _keybindingService;
+    private readonly _telemetryService;
+    private _expanded;
+    constructor(_toggle: () => Promise<void>, _keybindingService: IKeybindingService, _telemetryService: ITelemetryService);
+    run(): Promise<void>;
+    syncPresentation(expanded: boolean): void;
+    refreshKeybindingTooltip(): void;
+    private _updatePresentation;
+    private _updateTooltip;
+}
+export declare class FocusChatInstanceAction extends Action implements IAction {
+    private _instance;
+    private _command;
+    private readonly _commandUri;
+    private readonly _commandId;
+    private readonly _terminalService;
+    private readonly _terminalEditorService;
+    private readonly _terminalGroupService;
+    private readonly _keybindingService;
+    private readonly _telemetryService;
+    constructor(_instance: ITerminalInstance | undefined, _command: ITerminalCommand | undefined, _commandUri: URI | undefined, _commandId: string | undefined, isTerminalHidden: boolean, _terminalService: ITerminalService, _terminalEditorService: ITerminalEditorService, _terminalGroupService: ITerminalGroupService, _keybindingService: IKeybindingService, _telemetryService: ITelemetryService);
+    run(): Promise<void>;
+    refreshKeybindingTooltip(): void;
+    private _resolveCommand;
+    private _updateTooltip;
+}