@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,39 @@
+import { Separator } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+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 { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+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 { 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 { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
+import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { CodeBlockModelCollection } from "../../../common/codeBlockModelCollection.js";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { ILanguageModelToolsConfirmationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service";
+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 { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service";
+import { AbstractToolConfirmationSubPart } from "./abstractToolConfirmationSubPart.js";
+import { EditorPool } from "../chatContentCodePools.js";
+export declare class ToolConfirmationSubPart extends AbstractToolConfirmationSubPart {
+    private readonly renderer;
+    private readonly editorPool;
+    private readonly currentWidthDelegate;
+    private readonly codeBlockModelCollection;
+    private readonly codeBlockStartIndex;
+    private readonly modelService;
+    private readonly languageService;
+    private readonly commandService;
+    private readonly markerService;
+    private readonly chatMarkdownAnchorService;
+    private readonly confirmationService;
+    private markdownParts;
+    get codeblocks(): IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, codeBlockStartIndex: number, instantiationService: IInstantiationService, keybindingService: IKeybindingService, modelService: IModelService, languageService: ILanguageService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, commandService: ICommandService, markerService: IMarkerService, languageModelToolsService: ILanguageModelToolsService, chatMarkdownAnchorService: IChatMarkdownAnchorService, confirmationService: ILanguageModelToolsConfirmationService);
+    protected additionalPrimaryActions(): (Separator | import("../chatConfirmationWidget.js").IChatConfirmationButton<() => void>)[];
+    protected createContentElement(): HTMLElement | string;
+    protected getTitle(): string;
+    private _makeMarkdownPart;
+}

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

@@ -0,0 +1,275 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { h, createElement, addDisposableGenericMouseDownListener, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { count } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { isEmptyObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { ElementSizeObserver } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/config/elementSizeObserver';
+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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+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 { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { createToolInputUri, createToolSchemaUri } 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';
+import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service';
+import { SkipToolConfirmationActionId, AcceptToolConfirmationActionId } 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 { renderFileWidgets } from '../../chatInlineAnchorWidget.js';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service';
+import { ChatMarkdownContentPart } from '../chatMarkdownContentPart.js';
+import { AbstractToolConfirmationSubPart } from './abstractToolConfirmationSubPart.js';
+
+const SHOW_MORE_MESSAGE_HEIGHT_TRIGGER = 45;
+let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractToolConfirmationSubPart {
+    get codeblocks() {
+        return this.markdownParts.flatMap(part => part.codeblocks);
+    }
+    constructor(toolInvocation, context, renderer, editorPool, currentWidthDelegate, codeBlockModelCollection, codeBlockStartIndex, instantiationService, keybindingService, modelService, languageService, contextKeyService, chatWidgetService, commandService, markerService, languageModelToolsService, chatMarkdownAnchorService, confirmationService) {
+        if (!toolInvocation.confirmationMessages?.title) {
+            throw ( new Error('Confirmation messages are missing'));
+        }
+        super(toolInvocation, context, instantiationService, keybindingService, contextKeyService, chatWidgetService, languageModelToolsService);
+        this.renderer = renderer;
+        this.editorPool = editorPool;
+        this.currentWidthDelegate = currentWidthDelegate;
+        this.codeBlockModelCollection = codeBlockModelCollection;
+        this.codeBlockStartIndex = codeBlockStartIndex;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.commandService = commandService;
+        this.markerService = markerService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+        this.confirmationService = confirmationService;
+        this.markdownParts = [];
+        this.render({
+            allowActionId: AcceptToolConfirmationActionId,
+            skipActionId: SkipToolConfirmationActionId,
+            allowLabel: toolInvocation.confirmationMessages.confirmResults ? ( localize(5162, "Allow and Review")) : ( localize(5163, "Allow")),
+            skipLabel: ( localize(5164, 'Proceed without running this tool')),
+            partType: 'chatToolConfirmation',
+            subtitle: typeof toolInvocation.originMessage === 'string' ? toolInvocation.originMessage : toolInvocation.originMessage?.value,
+        });
+        if (toolInvocation.fromSubAgent) {
+            context.container.classList.add('from-sub-agent');
+        }
+    }
+    additionalPrimaryActions() {
+        const actions = super.additionalPrimaryActions();
+        if (this.toolInvocation.confirmationMessages?.allowAutoConfirm !== false) {
+            const confirmActions = this.confirmationService.getPreConfirmActions({
+                toolId: this.toolInvocation.toolId,
+                source: this.toolInvocation.source,
+                parameters: this.toolInvocation.parameters
+            });
+            for (const action of confirmActions) {
+                if (action.divider) {
+                    actions.push(( new Separator()));
+                }
+                actions.push({
+                    label: action.label,
+                    tooltip: action.detail,
+                    data: async () => {
+                        const shouldConfirm = await action.select();
+                        if (shouldConfirm) {
+                            this.confirmWith(this.toolInvocation, { type: ToolConfirmKind.UserAction });
+                        }
+                    }
+                });
+            }
+        }
+        if (this.toolInvocation.confirmationMessages?.confirmResults) {
+            actions.unshift({
+                label: ( localize(5165, 'Allow and Skip Reviewing Result')),
+                data: () => {
+                    this.toolInvocation.confirmationMessages.confirmResults = undefined;
+                    this.confirmWith(this.toolInvocation, { type: ToolConfirmKind.UserAction });
+                }
+            }, ( new Separator()));
+        }
+        return actions;
+    }
+    createContentElement() {
+        const { message, disclaimer } = this.toolInvocation.confirmationMessages;
+        const toolInvocation = this.toolInvocation;
+        if (typeof message === 'string' && !disclaimer) {
+            return message;
+        }
+        else {
+            const codeBlockRenderOptions = {
+                hideToolbar: true,
+                reserveWidth: 19,
+                verticalPadding: 5,
+                editorOptions: {
+                    tabFocusMode: true,
+                    ariaLabel: this.getTitle(),
+                },
+            };
+            const elements = h('div', [
+                h('.message@messageContainer', [
+                    h('.message-wrapper@message'),
+                    h('.see-more@showMore', [
+                        h('a', [( localize(5166, "Show More"))])
+                    ]),
+                ]),
+                h('.editor@editor'),
+                h('.disclaimer@disclaimer'),
+            ]);
+            if (toolInvocation.toolSpecificData?.kind === 'input' && toolInvocation.toolSpecificData.rawInput && !isEmptyObject(toolInvocation.toolSpecificData.rawInput)) {
+                const titleEl = createElement('h3');
+                titleEl.textContent = ( localize(5167, "Input"));
+                elements.editor.appendChild(titleEl);
+                const inputData = toolInvocation.toolSpecificData;
+                const codeBlockRenderOptions = {
+                    hideToolbar: true,
+                    reserveWidth: 19,
+                    maxHeightInLines: 13,
+                    verticalPadding: 5,
+                    editorOptions: {
+                        wordWrap: 'off',
+                        readOnly: false,
+                        ariaLabel: this.getTitle(),
+                    }
+                };
+                const langId = this.languageService.getLanguageIdByLanguageName('json');
+                const rawJsonInput = JSON.stringify(inputData.rawInput ?? {}, null, 1);
+                const canSeeMore = count(rawJsonInput, '\n') > 2;
+                const model = this._register(this.modelService.createModel(
+                rawJsonInput.replace(/\n */g, ' '), this.languageService.createById(langId), createToolInputUri(toolInvocation.toolCallId), true));
+                const markerOwner = generateUuid();
+                const schemaUri = createToolSchemaUri(toolInvocation.toolId);
+                const validator = ( new RunOnceScheduler(async () => {
+                    const newMarker = [];
+                    const result = await this.commandService.executeCommand('json.validate', schemaUri, model.getValue());
+                    for (const item of result ?? []) {
+                        if (item.range && item.message) {
+                            newMarker.push({
+                                severity: item.severity === 'Error' ? MarkerSeverity.Error : MarkerSeverity.Warning,
+                                message: item.message,
+                                startLineNumber: item.range[0].line + 1,
+                                startColumn: item.range[0].character + 1,
+                                endLineNumber: item.range[1].line + 1,
+                                endColumn: item.range[1].character + 1,
+                                code: item.code ? String(item.code) : undefined
+                            });
+                        }
+                    }
+                    this.markerService.changeOne(markerOwner, model.uri, newMarker);
+                }, 500));
+                validator.schedule();
+                this._register(model.onDidChangeContent(() => validator.schedule()));
+                this._register(toDisposable(() => this.markerService.remove(markerOwner, [model.uri])));
+                this._register(validator);
+                const editor = this._register(this.editorPool.get());
+                editor.object.render({
+                    codeBlockIndex: this.codeBlockStartIndex,
+                    codeBlockPartIndex: 0,
+                    element: this.context.element,
+                    languageId: langId ?? 'json',
+                    renderOptions: codeBlockRenderOptions,
+                    textModel: Promise.resolve(model),
+                    chatSessionResource: this.context.element.sessionResource
+                }, this.currentWidthDelegate());
+                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 => {
+                    try {
+                        inputData.rawInput = JSON.parse(model.getValue());
+                    }
+                    catch {
+                    }
+                }));
+                elements.editor.append(editor.object.element);
+                if (canSeeMore) {
+                    const seeMore = h('div.see-more', [h('a@link')]);
+                    seeMore.link.textContent = ( localize(5168, "See more"));
+                    this._register(addDisposableGenericMouseDownListener(seeMore.link, () => {
+                        try {
+                            const parsed = JSON.parse(model.getValue());
+                            model.setValue(JSON.stringify(parsed, null, 2));
+                            editor.object.editor.updateOptions({ tabFocusMode: false });
+                            editor.object.editor.updateOptions({ wordWrap: 'on' });
+                        }
+                        catch {
+                        }
+                        seeMore.root.remove();
+                    }));
+                    elements.editor.append(seeMore.root);
+                }
+            }
+            const mdPart = this._makeMarkdownPart(elements.message, message, codeBlockRenderOptions);
+            const messageSeeMoreObserver = this._register(( new ElementSizeObserver(mdPart.domNode, undefined)));
+            const updateSeeMoreDisplayed = () => {
+                const show = messageSeeMoreObserver.getHeight() > SHOW_MORE_MESSAGE_HEIGHT_TRIGGER;
+                if (elements.messageContainer.classList.contains('can-see-more') !== show) {
+                    elements.messageContainer.classList.toggle('can-see-more', show);
+                    this._onDidChangeHeight.fire();
+                }
+            };
+            this._register(addDisposableListener(elements.showMore, 'click', () => {
+                elements.messageContainer.classList.toggle('can-see-more', false);
+                this._onDidChangeHeight.fire();
+                messageSeeMoreObserver.dispose();
+            }));
+            this._register(messageSeeMoreObserver.onDidChange(updateSeeMoreDisplayed));
+            messageSeeMoreObserver.startObserving();
+            if (disclaimer) {
+                this._makeMarkdownPart(elements.disclaimer, disclaimer, codeBlockRenderOptions);
+            }
+            else {
+                elements.disclaimer.remove();
+            }
+            return elements.root;
+        }
+    }
+    getTitle() {
+        const { title } = this.toolInvocation.confirmationMessages;
+        return typeof title === 'string' ? title : title.value;
+    }
+    _makeMarkdownPart(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 }));
+        renderFileWidgets(part.domNode, this.instantiationService, this.chatMarkdownAnchorService, this._store);
+        container.append(part.domNode);
+        this._register(part.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        return part;
+    }
+};
+ToolConfirmationSubPart = ( __decorate([
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, IModelService)),
+    ( __param(10, ILanguageService)),
+    ( __param(11, IContextKeyService)),
+    ( __param(12, IChatWidgetService)),
+    ( __param(13, ICommandService)),
+    ( __param(14, IMarkerService)),
+    ( __param(15, ILanguageModelToolsService)),
+    ( __param(16, IChatMarkdownAnchorService)),
+    ( __param(17, ILanguageModelToolsConfirmationService))
+], ToolConfirmationSubPart));
+
+export { ToolConfirmationSubPart };

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

@@ -0,0 +1,32 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatRendererContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { CodeBlockModelCollection } from "../../../common/codeBlockModelCollection.js";
+import { ChatTreeItem, IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { EditorPool } from "../chatContentCodePools.js";
+import { IChatContentPart, IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { CollapsibleListPool } from "../chatReferencesContentPart.js";
+export declare class ChatToolInvocationPart extends Disposable implements IChatContentPart {
+    private readonly toolInvocation;
+    private readonly context;
+    private readonly renderer;
+    private readonly listPool;
+    private readonly editorPool;
+    private readonly currentWidthDelegate;
+    private readonly codeBlockModelCollection;
+    private readonly announcedToolProgressKeys;
+    private readonly codeBlockStartIndex;
+    private readonly instantiationService;
+    readonly domNode: HTMLElement;
+    private _onDidChangeHeight;
+    readonly onDidChangeHeight: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    get codeblocks(): IChatCodeBlockInfo[];
+    get codeblocksPartId(): string | undefined;
+    private subPart;
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, listPool: CollapsibleListPool, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, announcedToolProgressKeys: Set<string> | undefined, codeBlockStartIndex: number, instantiationService: IInstantiationService);
+    private createToolInvocationSubPart;
+    hasSameContent(other: IChatRendererContent, followingContent: IChatRendererContent[], element: ChatTreeItem): boolean;
+    addDisposable(disposable: IDisposable): void;
+}

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

@@ -0,0 +1,119 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { ToolInvocationPresentation, isToolResultOutputDetails, isToolResultInputOutputDetails } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ExtensionsInstallConfirmationWidgetSubPart } from './chatExtensionsInstallToolSubPart.js';
+import { ChatInputOutputMarkdownProgressPart } from './chatInputOutputMarkdownProgressPart.js';
+import { ChatResultListSubPart } from './chatResultListSubPart.js';
+import { ChatTerminalToolConfirmationSubPart } from './chatTerminalToolConfirmationSubPart.js';
+import { ChatTerminalToolProgressPart } from './chatTerminalToolProgressPart.js';
+import { ToolConfirmationSubPart } from './chatToolConfirmationSubPart.js';
+import { ChatToolOutputSubPart } from './chatToolOutputPart.js';
+import { ChatToolPostExecuteConfirmationPart } from './chatToolPostExecuteConfirmationPart.js';
+import { ChatToolProgressSubPart } from './chatToolProgressPart.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let ChatToolInvocationPart = class ChatToolInvocationPart extends Disposable {
+    get codeblocks() {
+        return this.subPart?.codeblocks ?? [];
+    }
+    get codeblocksPartId() {
+        return this.subPart?.codeblocksPartId;
+    }
+    constructor(toolInvocation, context, renderer, listPool, editorPool, currentWidthDelegate, codeBlockModelCollection, announcedToolProgressKeys, codeBlockStartIndex, instantiationService) {
+        super();
+        this.toolInvocation = toolInvocation;
+        this.context = context;
+        this.renderer = renderer;
+        this.listPool = listPool;
+        this.editorPool = editorPool;
+        this.currentWidthDelegate = currentWidthDelegate;
+        this.codeBlockModelCollection = codeBlockModelCollection;
+        this.announcedToolProgressKeys = announcedToolProgressKeys;
+        this.codeBlockStartIndex = codeBlockStartIndex;
+        this.instantiationService = instantiationService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this.domNode = $('.chat-tool-invocation-part');
+        if (toolInvocation.fromSubAgent) {
+            this.domNode.classList.add('from-sub-agent');
+        }
+        if (toolInvocation.presentation === 'hidden') {
+            return;
+        }
+        if (toolInvocation.kind === 'toolInvocation') {
+            const initialState = toolInvocation.state.get().type;
+            this._register(autorun(reader => {
+                if (toolInvocation.state.read(reader).type !== initialState) {
+                    render();
+                }
+            }));
+        }
+        const partStore = this._register(( new DisposableStore()));
+        const render = () => {
+            clearNode(this.domNode);
+            partStore.clear();
+            if (toolInvocation.presentation === ToolInvocationPresentation.HiddenAfterComplete && IChatToolInvocation.isComplete(toolInvocation)) {
+                return;
+            }
+            this.subPart = partStore.add(this.createToolInvocationSubPart());
+            this.domNode.appendChild(this.subPart.domNode);
+            partStore.add(this.subPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+            partStore.add(this.subPart.onNeedsRerender(render));
+            this._onDidChangeHeight.fire();
+        };
+        render();
+    }
+    createToolInvocationSubPart() {
+        if (this.toolInvocation.kind === 'toolInvocation') {
+            if (this.toolInvocation.toolSpecificData?.kind === 'extensions') {
+                return this.instantiationService.createInstance(ExtensionsInstallConfirmationWidgetSubPart, this.toolInvocation, this.context);
+            }
+            const state = this.toolInvocation.state.get();
+            if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
+                if (this.toolInvocation.toolSpecificData?.kind === 'terminal') {
+                    return this.instantiationService.createInstance(ChatTerminalToolConfirmationSubPart, this.toolInvocation, this.toolInvocation.toolSpecificData, this.context, this.renderer, this.editorPool, this.currentWidthDelegate, this.codeBlockModelCollection, this.codeBlockStartIndex);
+                }
+                else {
+                    return this.instantiationService.createInstance(ToolConfirmationSubPart, this.toolInvocation, this.context, this.renderer, this.editorPool, this.currentWidthDelegate, this.codeBlockModelCollection, this.codeBlockStartIndex);
+                }
+            }
+            if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
+                return this.instantiationService.createInstance(ChatToolPostExecuteConfirmationPart, this.toolInvocation, this.context);
+            }
+        }
+        if (this.toolInvocation.toolSpecificData?.kind === 'terminal') {
+            return this.instantiationService.createInstance(ChatTerminalToolProgressPart, this.toolInvocation, this.toolInvocation.toolSpecificData, this.context, this.renderer, this.editorPool, this.currentWidthDelegate, this.codeBlockStartIndex, this.codeBlockModelCollection);
+        }
+        const resultDetails = IChatToolInvocation.resultDetails(this.toolInvocation);
+        if (Array.isArray(resultDetails) && resultDetails.length) {
+            return this.instantiationService.createInstance(ChatResultListSubPart, this.toolInvocation, this.context, this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage, resultDetails, this.listPool);
+        }
+        if (isToolResultOutputDetails(resultDetails)) {
+            return this.instantiationService.createInstance(ChatToolOutputSubPart, this.toolInvocation, this.context);
+        }
+        if (isToolResultInputOutputDetails(resultDetails)) {
+            return this.instantiationService.createInstance(ChatInputOutputMarkdownProgressPart, this.toolInvocation, this.context, this.codeBlockStartIndex, this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage, this.toolInvocation.originMessage, resultDetails.input, resultDetails.output, !!resultDetails.isError);
+        }
+        if (this.toolInvocation.kind === 'toolInvocation' && this.toolInvocation.toolSpecificData?.kind === 'input' && !IChatToolInvocation.isComplete(this.toolInvocation)) {
+            return this.instantiationService.createInstance(ChatInputOutputMarkdownProgressPart, this.toolInvocation, this.context, this.codeBlockStartIndex, this.toolInvocation.invocationMessage, this.toolInvocation.originMessage, typeof this.toolInvocation.toolSpecificData.rawInput === 'string' ? this.toolInvocation.toolSpecificData.rawInput : JSON.stringify(this.toolInvocation.toolSpecificData.rawInput, null, 2), undefined, false);
+        }
+        return this.instantiationService.createInstance(ChatToolProgressSubPart, this.toolInvocation, this.context, this.renderer, this.announcedToolProgressKeys);
+    }
+    hasSameContent(other, followingContent, element) {
+        return (other.kind === 'toolInvocation' || other.kind === 'toolInvocationSerialized') && this.toolInvocation.toolCallId === other.toolCallId;
+    }
+    addDisposable(disposable) {
+        this._register(disposable);
+    }
+};
+ChatToolInvocationPart = ( __decorate([
+    ( __param(9, IInstantiationService))
+], ChatToolInvocationPart));
+
+export { ChatToolInvocationPart };

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

@@ -0,0 +1,19 @@
+import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+export declare abstract class BaseChatToolInvocationSubPart extends Disposable {
+    protected readonly toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized;
+    protected static idPool: number;
+    abstract readonly domNode: HTMLElement;
+    protected _onNeedsRerender: Emitter<void>;
+    readonly onNeedsRerender: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    protected _onDidChangeHeight: Emitter<void>;
+    readonly onDidChangeHeight: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    abstract codeblocks: IChatCodeBlockInfo[];
+    private readonly _codeBlocksPartId;
+    get codeblocksPartId(): string;
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized);
+    protected getIcon(): ThemeIcon;
+}

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

@@ -0,0 +1,36 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+
+class BaseChatToolInvocationSubPart extends Disposable {
+    static { this.idPool = 0; }
+    get codeblocksPartId() {
+        return this._codeBlocksPartId;
+    }
+    constructor(toolInvocation) {
+        super();
+        this.toolInvocation = toolInvocation;
+        this._onNeedsRerender = this._register(( new Emitter()));
+        this.onNeedsRerender = this._onNeedsRerender.event;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._codeBlocksPartId = 'tool-' + (BaseChatToolInvocationSubPart.idPool++);
+    }
+    getIcon() {
+        const toolInvocation = this.toolInvocation;
+        const confirmState = IChatToolInvocation.executionConfirmedOrDenied(toolInvocation);
+        const isSkipped = confirmState?.type === ToolConfirmKind.Skipped;
+        if (isSkipped) {
+            return Codicon.circleSlash;
+        }
+        return confirmState?.type === ToolConfirmKind.Denied ?
+            Codicon.error :
+            IChatToolInvocation.isComplete(toolInvocation) ?
+                Codicon.check : ThemeIcon.modify(Codicon.loading, 'spin');
+    }
+}
+
+export { BaseChatToolInvocationSubPart };

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

@@ -0,0 +1,21 @@
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+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 { IChatOutputRendererService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatOutputItemRenderer.service";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare class ChatToolOutputSubPart extends BaseChatToolInvocationSubPart {
+    private readonly context;
+    private readonly chatOutputItemRendererService;
+    private readonly chatWidgetService;
+    private readonly instantiationService;
+    /** Remembers cached state on re-render */
+    private static readonly _cachedStates;
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    private readonly _disposeCts;
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, chatOutputItemRendererService: IChatOutputRendererService, chatWidgetService: IChatWidgetService, instantiationService: IInstantiationService);
+    dispose(): void;
+    private createOutputPart;
+}