@codingame/monaco-vscode-katex-common 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatListRenderer.js

@@ -1,11 +1,12 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { $ as $$1, append, addDisposableListener, EventType, clearNode, addStandardDisposableListener, WindowIntervalTimer, getWindow, reset, scheduleAtNextAnimationFrame, findParentWithClass } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { $ as $$1, append, addDisposableListener, EventType, createElement, DisposableResizeObserver, clearNode, addStandardDisposableListener, WindowIntervalTimer, getWindow, reset, findParentWithClass } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { renderFormattedText } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/formattedTextRenderer';
 import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
 import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
 import { DropdownMenuActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dropdown/dropdownActionViewItem';
 import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { CachedListVirtualDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list';
 import { coalesce, distinct } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
@@ -38,11 +39,12 @@ import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/t
 import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
 import { IWorkbenchIssueService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/issue/common/issue.service';
 import { CodiconActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/view/cellParts/cellActionView';
-import { annotateSpecialMarkdownContent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/annotations';
+import { annotateSpecialMarkdownContent, hasCodeblockUriTag, extractSubAgentInvocationIdFromText } from '../../common/widget/annotations.js';
 import { checkModeOption } 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/actions/chatContextKeys';
 import { chatSubcommandLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { ChatAgentVoteDirection, IChatToolInvocation, isChatFollowup, ChatErrorLevel, ChatAgentVoteDownReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { isResponseVM, isRequestVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
@@ -64,8 +66,9 @@ import { EditorPool, DiffEditorPool } from './chatContentParts/chatContentCodePo
 import { ChatElicitationContentPart } from './chatContentParts/chatElicitationContentPart.js';
 import { ChatErrorConfirmationContentPart } from './chatContentParts/chatErrorConfirmationPart.js';
 import { ChatErrorContentPart } from './chatContentParts/chatErrorContentPart.js';
+import { ChatQuestionCarouselPart } from './chatContentParts/chatQuestionCarouselPart.js';
 import { ChatExtensionsContentPart } from './chatContentParts/chatExtensionsContentPart.js';
-import { ChatMarkdownContentPart } from './chatContentParts/chatMarkdownContentPart.js';
+import { codeblockHasClosingBackticks, ChatMarkdownContentPart } from './chatContentParts/chatMarkdownContentPart.js';
 import { ChatMcpServersInteractionContentPart } from './chatContentParts/chatMcpServersInteractionContentPart.js';
 import { ChatMultiDiffContentPart } from './chatContentParts/chatMultiDiffContentPart.js';
 import { ChatWorkingProgressContentPart, ChatProgressContentPart } from './chatContentParts/chatProgressContentPart.js';
@@ -75,19 +78,50 @@ import { CollapsibleListPool, ChatUsedReferencesListContentPart } from './chatCo
 import { ChatTaskContentPart } from './chatContentParts/chatTaskContentPart.js';
 import { ChatTextEditContentPart } from './chatContentParts/chatTextEditContentPart.js';
 import { ChatThinkingContentPart } from './chatContentParts/chatThinkingContentPart.js';
+import { ChatSubagentContentPart } from './chatContentParts/chatSubagentContentPart.js';
+import { ChatTipContentPart } from './chatContentParts/chatTipContentPart.js';
 import { TreePool, ChatTreeContentPart } from './chatContentParts/chatTreeContentPart.js';
+import { ChatWorkspaceEditContentPart } from './chatContentParts/chatWorkspaceEditContentPart.js';
 import { ChatToolInvocationPart } from './chatContentParts/toolInvocationParts/chatToolInvocationPart.js';
 import { ChatMarkdownDecorationsRenderer } from './chatContentParts/chatMarkdownDecorationsRenderer.js';
 import { ChatCodeBlockContentProvider } from './chatContentParts/codeBlockPart.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { RunSubagentTool } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/runSubagentTool';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IChatTipService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatTipService.service';
+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';
 
 var ChatListItemRenderer_1;
 const $ = $$1;
-const COPILOT_USERNAME = 'GitHub Copilot';
-const mostRecentResponseClassName = 'chat-most-recent-response';
+const COPILOT_USERNAME = "GitHub Copilot";
+const mostRecentResponseClassName = "chat-most-recent-response";
 let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
-    static { ChatListItemRenderer_1 = this; }
-    static { this.ID = 'item'; }
-    constructor(editorOptions, rendererOptions, delegate, codeBlockModelCollection, overflowWidgetsDomNode, viewModel, instantiationService, configService, logService, contextKeyService, themeService, commandService, hoverService, chatWidgetService, chatEntitlementService) {
+    static {
+        ChatListItemRenderer_1 = this;
+    }
+    static {
+        this.ID = "item";
+    }
+    constructor(
+        editorOptions,
+        rendererOptions,
+        delegate,
+        codeBlockModelCollection,
+        overflowWidgetsDomNode,
+        viewModel,
+        instantiationService,
+        configService,
+        logService,
+        contextKeyService,
+        themeService,
+        commandService,
+        hoverService,
+        chatWidgetService,
+        chatEntitlementService,
+        chatService,
+        chatTipService
+    ) {
         super();
         this.rendererOptions = rendererOptions;
         this.delegate = delegate;
@@ -102,11 +136,14 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.hoverService = hoverService;
         this.chatWidgetService = chatWidgetService;
         this.chatEntitlementService = chatEntitlementService;
+        this.chatService = chatService;
+        this.chatTipService = chatTipService;
         this.codeBlocksByResponseId = ( new Map());
         this.codeBlocksByEditorUri = ( new ResourceMap());
         this.fileTreesByResponseId = ( new Map());
         this.focusedFileTreesByResponseId = ( new Map());
         this.templateDataByRequestId = ( new Map());
+        this.pendingQuestionCarousels = ( new ResourceMap());
         this._onDidClickFollowup = this._register(( new Emitter()));
         this.onDidClickFollowup = this._onDidClickFollowup.event;
         this._onDidClickRerunWithAgentOrCommandDetection = ( new Emitter());
@@ -121,22 +158,50 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.onDidFocusOutside = this._onDidFocusOutside.event;
         this._onDidChangeItemHeight = this._register(( new Emitter()));
         this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
-        this._currentLayoutWidth = 0;
+        this._onDidUpdateViewModel = this._register(( new Emitter()));
+        this._currentLayoutWidth = observableValue(this, 0);
         this._isVisible = true;
         this._onDidChangeVisibility = this._register(( new Emitter()));
         this._announcedToolProgressKeys = ( new Set());
         this.chatContentMarkdownRenderer = this.instantiationService.createInstance(ChatContentMarkdownRenderer);
         this.markdownDecorationsRenderer = this.instantiationService.createInstance(ChatMarkdownDecorationsRenderer);
-        this._editorPool = this._register(this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, false));
-        this._toolEditorPool = this._register(this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, true));
-        this._diffEditorPool = this._register(this.instantiationService.createInstance(DiffEditorPool, editorOptions, delegate, overflowWidgetsDomNode, false));
-        this._treePool = this._register(this.instantiationService.createInstance(TreePool, this._onDidChangeVisibility.event));
-        this._contentReferencesListPool = this._register(this.instantiationService.createInstance(CollapsibleListPool, this._onDidChangeVisibility.event, undefined, undefined));
+        this._editorPool = this._register(
+            this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, false)
+        );
+        this._toolEditorPool = this._register(
+            this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, true)
+        );
+        this._diffEditorPool = this._register(
+            this.instantiationService.createInstance(DiffEditorPool, editorOptions, delegate, overflowWidgetsDomNode, false)
+        );
+        this._treePool = this._register(
+            this.instantiationService.createInstance(TreePool, this._onDidChangeVisibility.event)
+        );
+        this._contentReferencesListPool = this._register(this.instantiationService.createInstance(
+            CollapsibleListPool,
+            this._onDidChangeVisibility.event,
+            undefined,
+            undefined
+        ));
         this._register(this.instantiationService.createInstance(ChatCodeBlockContentProvider));
-        this._toolInvocationCodeBlockCollection = this._register(this.instantiationService.createInstance(CodeBlockModelCollection, 'tools'));
+        this._toolInvocationCodeBlockCollection = this._register(
+            this.instantiationService.createInstance(CodeBlockModelCollection, "tools")
+        );
+        this._register(this.chatService.onDidSubmitRequest(e => {
+            const carousels = this.pendingQuestionCarousels.get(e.chatSessionResource);
+            if (carousels) {
+                for (const carousel of carousels) {
+                    carousel.skip();
+                }
+                carousels.clear();
+            }
+        }));
     }
     updateOptions(options) {
-        this.rendererOptions = { ...this.rendererOptions, ...options };
+        this.rendererOptions = {
+            ...this.rendererOptions,
+            ...options
+        };
     }
     get templateId() {
         return ChatListItemRenderer_1.ID;
@@ -151,21 +216,20 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     getProgressiveRenderRate(element) {
         let Rate;
-        (function (Rate) {
+        (function(Rate) {
             Rate[Rate["Min"] = 5] = "Min";
             Rate[Rate["Max"] = 2000] = "Max";
         })(Rate || (Rate = {}));
         const minAfterComplete = 80;
         const rate = element.contentUpdateTimings?.impliedWordLoadRate;
         if (element.isComplete) {
-            if (typeof rate === 'number') {
+            if (typeof rate === "number") {
                 return clamp(rate, minAfterComplete, Rate.Max);
-            }
-            else {
+            } else {
                 return minAfterComplete;
             }
         }
-        if (typeof rate === 'number') {
+        if (typeof rate === "number") {
             return clamp(rate, Rate.Min, Rate.Max);
         }
         return 8;
@@ -177,6 +241,16 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     updateViewModel(viewModel) {
         this.viewModel = viewModel;
         this._announcedToolProgressKeys.clear();
+        this.codeBlocksByEditorUri.clear();
+        this.codeBlocksByResponseId.clear();
+        this.fileTreesByResponseId.clear();
+        this.focusedFileTreesByResponseId.clear();
+        this._editorPool.clear();
+        this._toolEditorPool.clear();
+        this._diffEditorPool.clear();
+        this._treePool.clear();
+        this._contentReferencesListPool.clear();
+        this._onDidUpdateViewModel.fire();
     }
     getCodeBlockInfoForEditor(uri) {
         return this.codeBlocksByEditorUri.get(uri);
@@ -212,123 +286,142 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     layout(width) {
         const newWidth = width - 40;
-        if (newWidth !== this._currentLayoutWidth) {
-            this._currentLayoutWidth = newWidth;
+        if (newWidth !== this._currentLayoutWidth.get()) {
+            this._currentLayoutWidth.set(newWidth, undefined);
             for (const editor of this._editorPool.inUse()) {
-                editor.layout(this._currentLayoutWidth);
+                editor.layout(newWidth);
             }
             for (const toolEditor of this._toolEditorPool.inUse()) {
-                toolEditor.layout(this._currentLayoutWidth);
+                toolEditor.layout(newWidth);
             }
             for (const diffEditor of this._diffEditorPool.inUse()) {
-                diffEditor.layout(this._currentLayoutWidth);
+                diffEditor.layout(newWidth);
             }
         }
     }
     renderTemplate(container) {
         const templateDisposables = ( new DisposableStore());
-        const disabledOverlay = append(container, $('.chat-row-disabled-overlay'));
-        const rowContainer = append(container, $('.interactive-item-container'));
-        if (this.rendererOptions.renderStyle === 'compact') {
-            rowContainer.classList.add('interactive-item-compact');
+        const disabledOverlay = append(container, $(".chat-row-disabled-overlay"));
+        const rowContainer = append(container, $(".interactive-item-container"));
+        if (this.rendererOptions.renderStyle === "compact") {
+            rowContainer.classList.add("interactive-item-compact");
         }
         let headerParent = rowContainer;
         let valueParent = rowContainer;
         let detailContainerParent;
-        if (this.rendererOptions.renderStyle === 'minimal') {
-            rowContainer.classList.add('interactive-item-compact');
-            rowContainer.classList.add('minimal');
-            const lhsContainer = append(rowContainer, $('.column.left'));
-            const rhsContainer = append(rowContainer, $('.column.right'));
+        if (this.rendererOptions.renderStyle === "minimal") {
+            rowContainer.classList.add("interactive-item-compact");
+            rowContainer.classList.add("minimal");
+            const lhsContainer = append(rowContainer, $(".column.left"));
+            const rhsContainer = append(rowContainer, $(".column.right"));
             headerParent = lhsContainer;
             detailContainerParent = rhsContainer;
             valueParent = rhsContainer;
         }
-        const header = append(headerParent, $('.header'));
+        const header = append(headerParent, $(".header"));
         const contextKeyService = templateDisposables.add(this.contextKeyService.createScoped(rowContainer));
         const scopedInstantiationService = templateDisposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
-        const requestHover = append(rowContainer, $('.request-hover'));
+        const requestHover = append(rowContainer, $(".request-hover"));
         let titleToolbar;
         if (this.rendererOptions.noHeader) {
-            header.classList.add('hidden');
+            header.classList.add("hidden");
+        } else {
+            titleToolbar = templateDisposables.add(
+                scopedInstantiationService.createInstance(MenuWorkbenchToolBar, requestHover, MenuId.ChatMessageTitle, {
+                    menuOptions: {
+                        shouldForwardArgs: true
+                    },
+                    toolbarOptions: {
+                        shouldInlineSubmenu: submenu => submenu.actions.length <= 1
+                    }
+                })
+            );
         }
-        else {
-            titleToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, requestHover, MenuId.ChatMessageTitle, {
+        this.hoverHidden(requestHover);
+        const checkpointContainer = append(rowContainer, $(".checkpoint-container"));
+        const codiconContainer = append(checkpointContainer, $(".codicon-container"));
+        append(codiconContainer, $("span.codicon.codicon-bookmark"));
+        const checkpointToolbar = templateDisposables.add(
+            scopedInstantiationService.createInstance(MenuWorkbenchToolBar, checkpointContainer, MenuId.ChatMessageCheckpoint, {
+                actionViewItemProvider: (action, options) => {
+                    if (action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(CodiconActionViewItem, action, {
+                            hoverDelegate: options.hoverDelegate
+                        });
+                    }
+                    return undefined;
+                },
+                renderDropdownAsChildElement: true,
                 menuOptions: {
                     shouldForwardArgs: true
                 },
                 toolbarOptions: {
                     shouldInlineSubmenu: submenu => submenu.actions.length <= 1
-                },
-            }));
-        }
-        this.hoverHidden(requestHover);
-        const checkpointContainer = append(rowContainer, $('.checkpoint-container'));
-        const codiconContainer = append(checkpointContainer, $('.codicon-container'));
-        append(codiconContainer, $('span.codicon.codicon-bookmark'));
-        const checkpointToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, checkpointContainer, MenuId.ChatMessageCheckpoint, {
-            actionViewItemProvider: (action, options) => {
-                if (action instanceof MenuItemAction) {
-                    return this.instantiationService.createInstance(CodiconActionViewItem, action, { hoverDelegate: options.hoverDelegate });
                 }
-                return undefined;
-            },
-            renderDropdownAsChildElement: true,
-            menuOptions: {
-                shouldForwardArgs: true
-            },
-            toolbarOptions: {
-                shouldInlineSubmenu: submenu => submenu.actions.length <= 1
-            },
-        }));
-        append(checkpointContainer, $('.checkpoint-divider'));
-        const user = append(header, $('.user'));
-        const avatarContainer = append(user, $('.avatar-container'));
-        const username = append(user, $('h3.username'));
+            })
+        );
+        append(checkpointContainer, $(".checkpoint-divider"));
+        const user = append(header, $(".user"));
+        const avatarContainer = append(user, $(".avatar-container"));
+        const username = append(user, $("h3.username"));
         username.tabIndex = 0;
-        const detailContainer = append(detailContainerParent ?? user, $('span.detail-container'));
-        const detail = append(detailContainer, $('span.detail'));
-        append(detailContainer, $('span.chat-animated-ellipsis'));
-        const value = append(valueParent, $('.value'));
-        const elementDisposables = ( new DisposableStore());
-        const footerToolbarContainer = append(rowContainer, $('.chat-footer-toolbar'));
+        const detailContainer = append(detailContainerParent ?? user, $("span.detail-container"));
+        const detail = append(detailContainer, $("span.detail"));
+        append(detailContainer, $("span.chat-animated-ellipsis"));
+        const value = append(valueParent, $(".value"));
+        const elementDisposables = templateDisposables.add(( new DisposableStore()));
+        const footerToolbarContainer = append(rowContainer, $(".chat-footer-toolbar"));
         if (this.rendererOptions.noFooter) {
-            footerToolbarContainer.classList.add('hidden');
-        }
-        const footerToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, footerToolbarContainer, MenuId.ChatMessageFooter, {
-            eventDebounceDelay: 0,
-            menuOptions: { shouldForwardArgs: true, renderShortTitle: true },
-            toolbarOptions: { shouldInlineSubmenu: submenu => submenu.actions.length <= 1 },
-            actionViewItemProvider: (action, options) => {
-                if (action instanceof MenuItemAction && action.item.id === MarkUnhelpfulActionId) {
-                    return scopedInstantiationService.createInstance(ChatVoteDownButton, action, options);
+            footerToolbarContainer.classList.add("hidden");
+        }
+        const footerToolbar = templateDisposables.add(
+            scopedInstantiationService.createInstance(MenuWorkbenchToolBar, footerToolbarContainer, MenuId.ChatMessageFooter, {
+                eventDebounceDelay: 0,
+                menuOptions: {
+                    shouldForwardArgs: true,
+                    renderShortTitle: true
+                },
+                toolbarOptions: {
+                    shouldInlineSubmenu: submenu => submenu.actions.length <= 1
+                },
+                actionViewItemProvider: (action, options) => {
+                    if (action instanceof MenuItemAction && action.item.id === MarkUnhelpfulActionId) {
+                        return scopedInstantiationService.createInstance(ChatVoteDownButton, action, options);
+                    }
+                    return createActionViewItem(scopedInstantiationService, action, options);
                 }
-                return createActionViewItem(scopedInstantiationService, action, options);
-            }
-        }));
-        const footerDetailsContainer = append(footerToolbar.getElement(), $('.chat-footer-details'));
+            })
+        );
+        const footerDetailsContainer = append(footerToolbar.getElement(), $(".chat-footer-details"));
         footerDetailsContainer.tabIndex = 0;
-        const checkpointRestoreContainer = append(rowContainer, $('.checkpoint-restore-container'));
-        const codiconRestoreContainer = append(checkpointRestoreContainer, $('.codicon-container'));
-        append(codiconRestoreContainer, $('span.codicon.codicon-bookmark'));
-        const label = append(checkpointRestoreContainer, $('span.checkpoint-label-text'));
-        label.textContent = ( localize(5775, 'Checkpoint Restored'));
-        const checkpointRestoreToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, checkpointRestoreContainer, MenuId.ChatMessageRestoreCheckpoint, {
-            actionViewItemProvider: (action, options) => {
-                if (action instanceof MenuItemAction) {
-                    return this.instantiationService.createInstance(CodiconActionViewItem, action, { hoverDelegate: options.hoverDelegate });
+        const checkpointRestoreContainer = append(rowContainer, $(".checkpoint-restore-container"));
+        const codiconRestoreContainer = append(checkpointRestoreContainer, $(".codicon-container"));
+        append(codiconRestoreContainer, $("span.codicon.codicon-bookmark"));
+        const label = append(checkpointRestoreContainer, $("span.checkpoint-label-text"));
+        label.textContent = ( localize(6031, "Checkpoint Restored"));
+        const checkpointRestoreToolbar = templateDisposables.add(scopedInstantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            checkpointRestoreContainer,
+            MenuId.ChatMessageRestoreCheckpoint,
+            {
+                actionViewItemProvider: (action, options) => {
+                    if (action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(CodiconActionViewItem, action, {
+                            hoverDelegate: options.hoverDelegate
+                        });
+                    }
+                    return undefined;
+                },
+                renderDropdownAsChildElement: true,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                toolbarOptions: {
+                    shouldInlineSubmenu: submenu => submenu.actions.length <= 1
                 }
-                return undefined;
-            },
-            renderDropdownAsChildElement: true,
-            menuOptions: {
-                shouldForwardArgs: true
-            },
-            toolbarOptions: {
-                shouldInlineSubmenu: submenu => submenu.actions.length <= 1
-            },
-        }));
-        append(checkpointRestoreContainer, $('.checkpoint-divider'));
+            }
+        ));
+        append(checkpointRestoreContainer, $(".checkpoint-divider"));
         const agentHover = templateDisposables.add(this.instantiationService.createInstance(ChatAgentHover));
         const hoverContent = () => {
             if (isResponseVM(template.currentElement) && template.currentElement.agent && !template.currentElement.agent.isDefault) {
@@ -337,21 +430,61 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             }
             return undefined;
         };
-        const hoverOptions = getChatAgentHoverOptions(() => isResponseVM(template.currentElement) ? template.currentElement.agent : undefined, this.commandService);
-        templateDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), user, hoverContent, hoverOptions));
+        const hoverOptions = getChatAgentHoverOptions(
+            () => isResponseVM(template.currentElement) ? template.currentElement.agent : undefined,
+            this.commandService
+        );
+        templateDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), user, hoverContent, hoverOptions)
+        );
         templateDisposables.add(addDisposableListener(user, EventType.KEY_DOWN, e => {
             const ev = ( new StandardKeyboardEvent(e));
             if (ev.equals(KeyCode.Space) || ev.equals(KeyCode.Enter)) {
                 const content = hoverContent();
                 if (content) {
-                    this.hoverService.showInstantHover({ content, target: user, trapFocus: true, actions: hoverOptions.actions }, true);
+                    this.hoverService.showInstantHover({
+                        content,
+                        target: user,
+                        trapFocus: true,
+                        actions: hoverOptions.actions
+                    }, true);
                 }
-            }
-            else if (ev.equals(KeyCode.Escape)) {
+            } else if (ev.equals(KeyCode.Escape)) {
                 this.hoverService.hideHover();
             }
         }));
-        const template = { header, avatarContainer, requestHover, username, detail, value, rowContainer, elementDisposables, templateDisposables, contextKeyService, instantiationService: scopedInstantiationService, agentHover, titleToolbar, footerToolbar, footerDetailsContainer, disabledOverlay, checkpointToolbar, checkpointRestoreToolbar, checkpointContainer, checkpointRestoreContainer };
+        const connectionObserver = createElement("connection-observer");
+        append(container, connectionObserver);
+        const template = {
+            header,
+            avatarContainer,
+            requestHover,
+            username,
+            detail,
+            value,
+            rowContainer,
+            elementDisposables,
+            templateDisposables,
+            contextKeyService,
+            instantiationService: scopedInstantiationService,
+            agentHover,
+            titleToolbar,
+            footerToolbar,
+            footerDetailsContainer,
+            disabledOverlay,
+            checkpointToolbar,
+            checkpointRestoreToolbar,
+            checkpointContainer,
+            checkpointRestoreContainer
+        };
+        connectionObserver.onDidDisconnect = () => {
+            template.renderedPartsMounted = false;
+        };
+        templateDisposables.add(this._onDidUpdateViewModel.event(() => {
+            if (!template.currentElement || !this.viewModel?.sessionResource || !isEqual(template.currentElement.sessionResource, this.viewModel.sessionResource)) {
+                this.clearRenderedParts(template);
+            }
+        }));
         templateDisposables.add(addDisposableListener(disabledOverlay, EventType.CLICK, e => {
             if (!this.viewModel?.editing) {
                 return;
@@ -360,16 +493,42 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             if (!current || current.id === this.viewModel.editing.id) {
                 return;
             }
-            if (disabledOverlay.classList.contains('disabled')) {
+            if (disabledOverlay.classList.contains("disabled")) {
                 e.preventDefault();
                 e.stopPropagation();
                 this._onDidFocusOutside.fire();
             }
         }));
+        const resizeObserver = templateDisposables.add(new DisposableResizeObserver(entries => {
+            if (!template.currentElement) {
+                return;
+            }
+            const entry = entries[0];
+            if (entry) {
+                const height = entry.borderBoxSize.at(0)?.blockSize;
+                if (height === 0 || !height || !template.rowContainer.isConnected) {
+                    return;
+                }
+                const normalizedHeight = Math.ceil(height);
+                template.currentElement.currentRenderedHeight = normalizedHeight;
+                if (template.currentElement !== this._elementBeingRendered) {
+                    this._onDidChangeItemHeight.fire({
+                        element: template.currentElement,
+                        height: normalizedHeight
+                    });
+                }
+            }
+        }));
+        templateDisposables.add(resizeObserver.observe(rowContainer));
         return template;
     }
     renderElement(node, index, templateData) {
-        this.renderChatTreeItem(node.element, index, templateData);
+        this._elementBeingRendered = node.element;
+        try {
+            this.renderChatTreeItem(node.element, index, templateData);
+        } finally {
+            this._elementBeingRendered = undefined;
+        }
     }
     clearRenderedParts(templateData) {
         if (templateData.renderedParts) {
@@ -377,32 +536,40 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             templateData.renderedParts = undefined;
             clearNode(templateData.value);
         }
+        if (templateData.titleToolbar) {
+            templateData.titleToolbar.context = undefined;
+        }
+        templateData.footerToolbar.context = undefined;
+        templateData.checkpointToolbar.context = undefined;
+        templateData.checkpointRestoreToolbar.context = undefined;
     }
     renderChatTreeItem(element, index, templateData) {
         if (templateData.currentElement && templateData.currentElement.id !== element.id) {
-            this.traceLayout('renderChatTreeItem', `Rendering a different element into the template, index=${index}`);
-            this.clearRenderedParts(templateData);
+            this.traceLayout(
+                "renderChatTreeItem",
+                `Rendering a different element into the template, index=${index}`
+            );
             const mappedTemplateData = this.templateDataByRequestId.get(templateData.currentElement.id);
             if (mappedTemplateData && (mappedTemplateData.currentElement?.id !== templateData.currentElement.id)) {
                 this.templateDataByRequestId.delete(templateData.currentElement.id);
             }
+            this.clearRenderedParts(templateData);
         }
         templateData.currentElement = element;
         this.templateDataByRequestId.set(element.id, templateData);
-        const kind = isRequestVM(element) ? 'request' :
-            isResponseVM(element) ? 'response' :
-                'welcome';
-        this.traceLayout('renderElement', `${kind}, index=${index}`);
+        const kind = isRequestVM(element) ? "request" : isResponseVM(element) ? "response" : "welcome";
+        this.traceLayout("renderElement", `${kind}, index=${index}`);
         ChatContextKeys.isResponse.bindTo(templateData.contextKeyService).set(isResponseVM(element));
         ChatContextKeys.itemId.bindTo(templateData.contextKeyService).set(element.id);
         ChatContextKeys.isRequest.bindTo(templateData.contextKeyService).set(isRequestVM(element));
         ChatContextKeys.responseDetectedAgentCommand.bindTo(templateData.contextKeyService).set(isResponseVM(element) && element.agentOrSlashCommandDetected);
         if (isResponseVM(element)) {
             ChatContextKeys.responseSupportsIssueReporting.bindTo(templateData.contextKeyService).set(!!element.agent?.metadata.supportIssueReporting);
-            ChatContextKeys.responseVote.bindTo(templateData.contextKeyService).set(element.vote === ChatAgentVoteDirection.Up ? 'up' : element.vote === ChatAgentVoteDirection.Down ? 'down' : '');
-        }
-        else {
-            ChatContextKeys.responseVote.bindTo(templateData.contextKeyService).set('');
+            ChatContextKeys.responseVote.bindTo(templateData.contextKeyService).set(
+                element.vote === ChatAgentVoteDirection.Up ? "up" : element.vote === ChatAgentVoteDirection.Down ? "down" : ""
+            );
+        } else {
+            ChatContextKeys.responseVote.bindTo(templateData.contextKeyService).set("");
         }
         if (templateData.titleToolbar) {
             templateData.titleToolbar.context = element;
@@ -410,166 +577,188 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         templateData.footerToolbar.context = element;
         if (isResponseVM(element) && element.result?.details) {
             templateData.footerDetailsContainer.textContent = element.result.details;
-            templateData.footerDetailsContainer.classList.remove('hidden');
-        }
-        else {
-            templateData.footerDetailsContainer.classList.add('hidden');
+            templateData.footerDetailsContainer.classList.remove("hidden");
+        } else {
+            templateData.footerDetailsContainer.classList.add("hidden");
         }
         ChatContextKeys.responseHasError.bindTo(templateData.contextKeyService).set(isResponseVM(element) && !!element.errorDetails);
         const isFiltered = !!(isResponseVM(element) && element.errorDetails?.responseIsFiltered);
         ChatContextKeys.responseIsFiltered.bindTo(templateData.contextKeyService).set(isFiltered);
         const location = this.chatWidgetService.getWidgetBySessionResource(element.sessionResource)?.location;
-        templateData.rowContainer.classList.toggle('editing-session', location === ChatAgentLocation.Chat);
-        templateData.rowContainer.classList.toggle('interactive-request', isRequestVM(element));
-        templateData.rowContainer.classList.toggle('interactive-response', isResponseVM(element));
-        const progressMessageAtBottomOfResponse = checkModeOption(this.delegate.currentChatMode(), this.rendererOptions.progressMessageAtBottomOfResponse);
-        templateData.rowContainer.classList.toggle('show-detail-progress', isResponseVM(element) && !element.isComplete && !element.progressMessages.length && !progressMessageAtBottomOfResponse);
+        templateData.rowContainer.classList.toggle("editing-session", location === ChatAgentLocation.Chat);
+        templateData.rowContainer.classList.toggle("interactive-request", isRequestVM(element));
+        templateData.rowContainer.classList.toggle("interactive-response", isResponseVM(element));
+        const progressMessageAtBottomOfResponse = checkModeOption(
+            this.delegate.currentChatMode(),
+            this.rendererOptions.progressMessageAtBottomOfResponse
+        );
+        templateData.rowContainer.classList.toggle(
+            "show-detail-progress",
+            isResponseVM(element) && !element.isComplete && !element.progressMessages.length && !progressMessageAtBottomOfResponse
+        );
         if (!this.rendererOptions.noHeader) {
             this.renderAvatar(element, templateData);
         }
         templateData.username.textContent = element.username;
-        templateData.username.classList.toggle('hidden', element.username === COPILOT_USERNAME);
-        templateData.avatarContainer.classList.toggle('hidden', element.username === COPILOT_USERNAME);
+        templateData.username.classList.toggle("hidden", element.username === COPILOT_USERNAME);
+        templateData.avatarContainer.classList.toggle("hidden", element.username === COPILOT_USERNAME);
         this.hoverHidden(templateData.requestHover);
         clearNode(templateData.detail);
         if (isResponseVM(element)) {
             this.renderDetail(element, templateData);
         }
         templateData.checkpointToolbar.context = element;
-        const checkpointEnabled = this.configService.getValue(ChatConfiguration.CheckpointsEnabled)
-            && (this.rendererOptions.restorable ?? true);
-        templateData.checkpointContainer.classList.toggle('hidden', isResponseVM(element) || !(checkpointEnabled));
+        const checkpointEnabled = this.configService.getValue(ChatConfiguration.CheckpointsEnabled) && (this.rendererOptions.restorable ?? true);
+        templateData.checkpointContainer.classList.toggle("hidden", isResponseVM(element) || !checkpointEnabled);
         const shouldShowRestore = this.viewModel?.model.checkpoint && !this.viewModel?.editing && (index === this.delegate.getListLength() - 1);
-        templateData.checkpointRestoreContainer.classList.toggle('hidden', !(shouldShowRestore && checkpointEnabled));
+        templateData.checkpointRestoreContainer.classList.toggle("hidden", !(shouldShowRestore && checkpointEnabled));
         const editing = element.id === this.viewModel?.editing?.id;
-        const isInput = this.configService.getValue('chat.editRequests') === 'input';
-        templateData.disabledOverlay.classList.toggle('disabled', element.shouldBeBlocked && !editing && this.viewModel?.editing !== undefined);
-        templateData.rowContainer.classList.toggle('editing', editing && !isInput);
-        templateData.rowContainer.classList.toggle('editing-input', editing && isInput);
-        templateData.requestHover.classList.toggle('editing', editing && isInput);
-        templateData.requestHover.classList.toggle('hidden', (!!this.viewModel?.editing && !editing) || isResponseVM(element));
-        templateData.requestHover.classList.toggle('expanded', this.configService.getValue('chat.editRequests') === 'hover');
-        templateData.requestHover.classList.toggle('checkpoints-enabled', checkpointEnabled);
-        templateData.elementDisposables.add(addStandardDisposableListener(templateData.rowContainer, EventType.CLICK, (e) => {
-            const current = templateData.currentElement;
-            if (current && this.viewModel?.editing && current.id !== this.viewModel.editing.id) {
-                e.stopPropagation();
-                e.preventDefault();
-                this._onDidFocusOutside.fire();
-            }
+        const isInput = this.configService.getValue("chat.editRequests") === "input";
+        templateData.elementDisposables.add(autorun(r => {
+            const shouldBeBlocked = element.shouldBeBlocked.read(r);
+            templateData.disabledOverlay.classList.toggle(
+                "disabled",
+                shouldBeBlocked && !editing && this.viewModel?.editing !== undefined
+            );
         }));
-        templateData.rowContainer.parentElement?.parentElement?.parentElement?.classList.toggle('request', isRequestVM(element));
+        templateData.rowContainer.classList.toggle("editing", editing && !isInput);
+        templateData.rowContainer.classList.toggle("editing-input", editing && isInput);
+        templateData.requestHover.classList.toggle("editing", editing && isInput);
+        templateData.requestHover.classList.toggle(
+            "hidden",
+            (!!this.viewModel?.editing && !editing) || isResponseVM(element) || !this.rendererOptions.editable
+        );
+        templateData.requestHover.classList.toggle("expanded", this.configService.getValue("chat.editRequests") === "hover");
+        templateData.requestHover.classList.toggle("checkpoints-enabled", checkpointEnabled);
+        templateData.elementDisposables.add(
+            addStandardDisposableListener(templateData.rowContainer, EventType.CLICK, e => {
+                const current = templateData.currentElement;
+                if (current && this.viewModel?.editing && current.id !== this.viewModel.editing.id) {
+                    e.stopPropagation();
+                    e.preventDefault();
+                    this._onDidFocusOutside.fire();
+                }
+            })
+        );
+        templateData.rowContainer.parentElement?.parentElement?.parentElement?.classList.toggle("request", isRequestVM(element));
         templateData.rowContainer.classList.toggle(mostRecentResponseClassName, index === this.delegate.getListLength() - 1);
-        templateData.rowContainer.classList.toggle('confirmation-message', isRequestVM(element) && !!element.confirmation);
+        templateData.rowContainer.classList.toggle("confirmation-message", isRequestVM(element) && !!element.confirmation);
         const shouldShowHeader = isResponseVM(element) && !this.rendererOptions.noHeader;
-        templateData.header?.classList.toggle('header-disabled', !shouldShowHeader);
+        templateData.header?.classList.toggle("header-disabled", !shouldShowHeader);
         if (isRequestVM(element) && element.confirmation) {
             this.renderConfirmationAction(element, templateData);
         }
         if (isResponseVM(element) && index === this.delegate.getListLength() - 1 && (!element.isComplete || element.renderData)) {
-            this.traceLayout('renderElement', `start progressive render, index=${index}`);
+            this.traceLayout("renderElement", `start progressive render, index=${index}`);
             const timer = templateData.elementDisposables.add(new WindowIntervalTimer());
-            const runProgressiveRender = (initial) => {
+            const runProgressiveRender = initial => {
                 try {
                     if (this.doNextProgressiveRender(element, index, templateData, !!initial)) {
                         timer.cancel();
                     }
-                }
-                catch (err) {
+                } catch (err) {
                     timer.cancel();
                     this.logService.error(err);
                 }
             };
             timer.cancelAndSet(runProgressiveRender, 50, getWindow(templateData.rowContainer));
             runProgressiveRender(true);
-        }
-        else {
+        } else {
             if (isResponseVM(element)) {
                 this.renderChatResponseBasic(element, index, templateData);
-            }
-            else if (isRequestVM(element)) {
+            } else if (isRequestVM(element)) {
                 this.renderChatRequest(element, index, templateData);
             }
         }
+        templateData.renderedPartsMounted = true;
     }
     renderDetail(element, templateData) {
         clearNode(templateData.detail);
         if (element.agentOrSlashCommandDetected) {
             const msg = element.slashCommand ? ( localize(
-                5776,
+                6032,
                 "used {0} [[(rerun without)]]",
                 `${chatSubcommandLeader}${element.slashCommand.name}`
-            )) : ( localize(5777, "[[(rerun without)]]"));
+            )) : ( localize(6033, "[[(rerun without)]]"));
             reset(templateData.detail, renderFormattedText(msg, {
                 actionHandler: {
                     disposables: templateData.elementDisposables,
-                    callback: (content) => {
+                    callback: content => {
                         this._onDidClickRerunWithAgentOrCommandDetection.fire(element);
-                    },
+                    }
                 }
-            }, $('span.agentOrSlashCommandDetected')));
-        }
-        else if (this.rendererOptions.renderStyle !== 'minimal' && !element.isComplete && !checkModeOption(this.delegate.currentChatMode(), this.rendererOptions.progressMessageAtBottomOfResponse)) {
-            templateData.detail.textContent = ( localize(5778, "Working"));
+            }, $("span.agentOrSlashCommandDetected")));
+        } else if (this.rendererOptions.renderStyle !== "minimal" && !element.isComplete && !checkModeOption(
+            this.delegate.currentChatMode(),
+            this.rendererOptions.progressMessageAtBottomOfResponse
+        )) {
+            templateData.detail.textContent = ( localize(6034, "Working"));
         }
     }
     renderConfirmationAction(element, templateData) {
         clearNode(templateData.detail);
         if (element.confirmation) {
-            append(templateData.detail, $('span.codicon.codicon-check', { 'aria-hidden': 'true' }));
-            append(templateData.detail, $('span.confirmation-text', undefined, ( localize(5779, 'Selected "{0}"', element.confirmation))));
-            templateData.header?.classList.remove('header-disabled');
-            templateData.header?.classList.add('partially-disabled');
+            append(templateData.detail, $("span.codicon.codicon-check", {
+                "aria-hidden": "true"
+            }));
+            append(templateData.detail, $("span.confirmation-text", undefined, ( localize(6035, "Selected \"{0}\"", element.confirmation))));
+            templateData.header?.classList.remove("header-disabled");
+            templateData.header?.classList.add("partially-disabled");
         }
     }
     renderAvatar(element, templateData) {
-        const icon = isResponseVM(element) ?
-            this.getAgentIcon(element.agent?.metadata) :
-            (element.avatarIcon ?? Codicon.account);
+        const icon = isResponseVM(element) ? this.getAgentIcon(element.agent?.metadata) : (element.avatarIcon ?? Codicon.account);
         if (icon instanceof URI) {
-            const avatarIcon = $$1('img.icon');
+            const avatarIcon = $$1("img.icon");
             avatarIcon.src = ( FileAccess.uriToBrowserUri(icon).toString(true));
-            templateData.avatarContainer.replaceChildren($$1('.avatar', undefined, avatarIcon));
-        }
-        else {
+            templateData.avatarContainer.replaceChildren($$1(".avatar", undefined, avatarIcon));
+        } else {
             const avatarIcon = $$1(ThemeIcon.asCSSSelector(icon));
-            templateData.avatarContainer.replaceChildren($$1('.avatar.codicon-avatar', undefined, avatarIcon));
+            templateData.avatarContainer.replaceChildren($$1(".avatar.codicon-avatar", undefined, avatarIcon));
         }
     }
     getAgentIcon(agent) {
         if (agent?.themeIcon) {
             return agent.themeIcon;
-        }
-        else if (agent?.iconDark && isDark(this.themeService.getColorTheme().type)) {
+        } else if (agent?.iconDark && isDark(this.themeService.getColorTheme().type)) {
             return agent.iconDark;
-        }
-        else if (agent?.icon) {
+        } else if (agent?.icon) {
             return agent.icon;
-        }
-        else {
+        } else {
             return Codicon.chatSparkle;
         }
     }
     renderChatResponseBasic(element, index, templateData) {
-        templateData.rowContainer.classList.toggle('chat-response-loading', (isResponseVM(element) && !element.isComplete));
-        if (element.isCanceled) {
+        templateData.rowContainer.classList.toggle("chat-response-loading", (isResponseVM(element) && !element.isComplete));
+        if (element.isComplete || element.isCanceled) {
             const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-            if (lastThinking?.domNode) {
+            if (lastThinking?.domNode && lastThinking.getIsActive()) {
                 lastThinking.finalizeTitleIfDefault();
                 lastThinking.markAsInactive();
             }
+            this.finalizeAllSubagentParts(templateData);
         }
         const content = [];
         const isFiltered = !!element.errorDetails?.responseIsFiltered;
         if (!isFiltered) {
-            content.push({ kind: 'references', references: element.contentReferences });
+            content.push({
+                kind: "references",
+                references: element.contentReferences
+            });
             content.push(...annotateSpecialMarkdownContent(element.response.value));
             if (element.codeCitations.length) {
-                content.push({ kind: 'codeCitations', citations: element.codeCitations });
+                content.push({
+                    kind: "codeCitations",
+                    citations: element.codeCitations
+                });
             }
         }
         if (element.model.response === element.model.entireResponse && element.errorDetails?.message && element.errorDetails.message !== canceledName) {
-            content.push({ kind: 'errorDetails', errorDetails: element.errorDetails, isLast: index === this.delegate.getListLength() - 1 });
+            content.push({
+                kind: "errorDetails",
+                errorDetails: element.errorDetails,
+                isLast: index === this.delegate.getListLength() - 1
+            });
         }
         const fileChangesSummaryPart = this.getChatFileChangesSummaryPart(element);
         if (fileChangesSummaryPart) {
@@ -577,30 +766,42 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         const diff = this.diff(templateData.renderedParts ?? [], content, element);
         this.renderChatContentDiff(diff, content, element, index, templateData);
-        this.updateItemHeightOnRender(element, templateData);
     }
     shouldShowWorkingProgress(element, partsToRender, templateData) {
-        if (element.agentOrSlashCommandDetected || this.rendererOptions.renderStyle === 'minimal' || element.isComplete || !checkModeOption(this.delegate.currentChatMode(), this.rendererOptions.progressMessageAtBottomOfResponse)) {
+        if (element.agentOrSlashCommandDetected || this.rendererOptions.renderStyle === "minimal" || element.isComplete || !checkModeOption(
+            this.delegate.currentChatMode(),
+            this.rendererOptions.progressMessageAtBottomOfResponse
+        )) {
+            return false;
+        }
+        if (( partsToRender.some(
+            part => part.kind === "toolInvocation" && IChatToolInvocation.isStreaming(part)
+        ))) {
+            return false;
+        }
+        const lastPart = findLast(
+            partsToRender,
+            part => part.kind !== "markdownContent" || part.content.value.trim().length > 0
+        );
+        if (( partsToRender.some(part => part.kind === "thinking"))) {
             return false;
         }
-        const lastPart = findLast(partsToRender, part => part.kind !== 'markdownContent' || part.content.value.trim().length > 0);
-        const collapsedToolsMode = this.configService.getValue('chat.agent.thinking.collapsedTools');
         const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-        if (lastThinking &&
-            (collapsedToolsMode === CollapsedToolsDisplayMode.Always ||
-                collapsedToolsMode === CollapsedToolsDisplayMode.WithThinking)) {
-            if (!lastPart || lastPart.kind === 'thinking' || lastPart.kind === 'toolInvocation' || lastPart.kind === 'prepareToolInvocation' || lastPart.kind === 'textEditGroup' || lastPart.kind === 'notebookEditGroup') {
-                return false;
-            }
+        if (lastThinking) {
+            return false;
         }
-        if (!lastPart ||
-            lastPart.kind === 'references' ||
-            ((lastPart.kind === 'toolInvocation' || lastPart.kind === 'toolInvocationSerialized') && (IChatToolInvocation.isComplete(lastPart) || lastPart.presentation === 'hidden')) ||
-            ((lastPart.kind === 'textEditGroup' || lastPart.kind === 'notebookEditGroup') && lastPart.done && !( partsToRender.some(
-            part => part.kind === 'toolInvocation' && !IChatToolInvocation.isComplete(part)
-        ))) ||
-            (lastPart.kind === 'progressTask' && lastPart.deferred.isSettled) ||
-            lastPart.kind === 'prepareToolInvocation' || lastPart.kind === 'mcpServersStarting') {
+        const collapsedToolsMode = this.configService.getValue("chat.agent.thinking.collapsedTools");
+        if (collapsedToolsMode !== CollapsedToolsDisplayMode.Off && ( partsToRender.some(
+            part => (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.presentation !== "hidden" && this.shouldPinPart(part, element)
+        ))) {
+            return false;
+        }
+        if (this.getSubagentPart(templateData.renderedParts)) {
+            return false;
+        }
+        if (!lastPart || lastPart.kind === "references" || ((lastPart.kind === "toolInvocation" || lastPart.kind === "toolInvocationSerialized") && (IChatToolInvocation.isComplete(lastPart) || lastPart.presentation === "hidden")) || ((lastPart.kind === "textEditGroup" || lastPart.kind === "notebookEditGroup") && lastPart.done && !( partsToRender.some(
+            part => part.kind === "toolInvocation" && !IChatToolInvocation.isComplete(part)
+        ))) || (lastPart.kind === "progressTask" && lastPart.deferred.isSettled) || lastPart.kind === "mcpServersStarting") {
             return true;
         }
         return false;
@@ -609,45 +810,62 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (!this.shouldShowFileChangesSummary(element)) {
             return undefined;
         }
-        if (!( element.model.entireResponse.value.some(part => part.kind === 'textEditGroup' || part.kind === 'notebookEditGroup'))) {
+        if (!( element.model.entireResponse.value.some(part => part.kind === "textEditGroup" || part.kind === "notebookEditGroup"))) {
             return undefined;
         }
-        return { kind: 'changesSummary', requestId: element.requestId, sessionResource: element.sessionResource };
+        return {
+            kind: "changesSummary",
+            requestId: element.requestId,
+            sessionResource: element.sessionResource
+        };
     }
     renderChatRequest(element, index, templateData) {
-        templateData.rowContainer.classList.toggle('chat-response-loading', false);
+        templateData.rowContainer.classList.toggle("chat-response-loading", false);
         if (element.id === this.viewModel?.editing?.id) {
             this._onDidRerender.fire(templateData);
         }
-        if (this.configService.getValue('chat.editRequests') !== 'none' && this.rendererOptions.editable) {
-            templateData.elementDisposables.add(addDisposableListener(templateData.rowContainer, EventType.KEY_DOWN, e => {
-                const ev = ( new StandardKeyboardEvent(e));
-                if (ev.equals(KeyCode.Space) || ev.equals(KeyCode.Enter)) {
-                    if (this.viewModel?.editing?.id !== element.id) {
-                        ev.preventDefault();
-                        ev.stopPropagation();
-                        this._onDidClickRequest.fire(templateData);
+        if (this.configService.getValue("chat.editRequests") !== "none" && this.rendererOptions.editable) {
+            templateData.elementDisposables.add(
+                addDisposableListener(templateData.rowContainer, EventType.KEY_DOWN, e => {
+                    const ev = ( new StandardKeyboardEvent(e));
+                    if (ev.equals(KeyCode.Space) || ev.equals(KeyCode.Enter)) {
+                        if (this.viewModel?.editing?.id !== element.id) {
+                            ev.preventDefault();
+                            ev.stopPropagation();
+                            this._onDidClickRequest.fire(templateData);
+                        }
                     }
-                }
-            }));
+                })
+            );
         }
         let content = [];
         if (!element.confirmation) {
-            const markdown = isChatFollowup(element.message) ?
-                element.message.message :
-                this.markdownDecorationsRenderer.convertParsedRequestToMarkdown(element.sessionResource, element.message);
-            content = [{ content: ( new MarkdownString(markdown)), kind: 'markdownContent' }];
-            if (this.rendererOptions.renderStyle === 'minimal' && !element.isComplete) {
-                templateData.value.classList.add('inline-progress');
-                templateData.elementDisposables.add(toDisposable(() => templateData.value.classList.remove('inline-progress')));
-                content.push({ content: ( new MarkdownString('<span></span>', { supportHtml: true })), kind: 'markdownContent' });
-            }
-            else {
-                templateData.value.classList.remove('inline-progress');
+            const markdown = isChatFollowup(element.message) ? element.message.message : this.markdownDecorationsRenderer.convertParsedRequestToMarkdown(element.sessionResource, element.message);
+            content = [{
+                content: ( new MarkdownString(markdown)),
+                kind: "markdownContent"
+            }];
+            if (this.rendererOptions.renderStyle === "minimal" && !element.isComplete) {
+                templateData.value.classList.add("inline-progress");
+                templateData.elementDisposables.add(toDisposable(() => templateData.value.classList.remove("inline-progress")));
+                content.push({
+                    content: ( new MarkdownString("<span></span>", {
+                        supportHtml: true
+                    })),
+                    kind: "markdownContent"
+                });
+            } else {
+                templateData.value.classList.remove("inline-progress");
             }
         }
         clearNode(templateData.value);
         const parts = [];
+        const tip = this.chatTipService.getNextTip(element.id, element.timestamp, this.contextKeyService);
+        if (tip) {
+            const tipPart = ( new ChatTipContentPart(tip, this.chatContentMarkdownRenderer));
+            templateData.value.appendChild(tipPart.domNode);
+            templateData.elementDisposables.add(tipPart);
+        }
         let inlineSlashCommandRendered = false;
         content.forEach((data, contentIndex) => {
             const context = {
@@ -655,27 +873,34 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 elementIndex: index,
                 contentIndex: contentIndex,
                 content: content,
-                preceedingContentParts: parts,
                 container: templateData.rowContainer,
                 editorPool: this._editorPool,
                 diffEditorPool: this._diffEditorPool,
                 codeBlockModelCollection: this.codeBlockModelCollection,
-                currentWidth: () => this._currentLayoutWidth,
+                currentWidth: this._currentLayoutWidth,
+                onDidChangeVisibility: this._onDidChangeVisibility.event,
                 get codeBlockStartIndex() {
-                    return context.preceedingContentParts.reduce((acc, part) => acc + (part.codeblocks?.length ?? 0), 0);
+                    return parts.reduce((acc, part) => acc + (part.codeblocks?.length ?? 0), 0);
                 },
+                get treeStartIndex() {
+                    return parts.filter(part => part instanceof ChatTreeContentPart).length;
+                }
             };
             const newPart = this.renderChatContentPart(data, templateData, context);
             if (newPart) {
-                if (this.rendererOptions.renderDetectedCommandsWithRequest
-                    && !inlineSlashCommandRendered
-                    && element.agentOrSlashCommandDetected && element.slashCommand
-                    && data.kind === 'markdownContent'
-                ) {
+                if (
+                this.rendererOptions.renderDetectedCommandsWithRequest && !inlineSlashCommandRendered && element.agentOrSlashCommandDetected && element.slashCommand && data.kind === "markdownContent") {
                     if (newPart.domNode) {
-                        newPart.domNode.style.display = 'inline-flex';
+                        newPart.domNode.style.display = "inline-flex";
                     }
-                    const cmdPart = this.instantiationService.createInstance(ChatAgentCommandContentPart, element.slashCommand, () => this._onDidClickRerunWithAgentOrCommandDetection.fire({ sessionResource: element.sessionResource, requestId: element.id }));
+                    const cmdPart = this.instantiationService.createInstance(
+                        ChatAgentCommandContentPart,
+                        element.slashCommand,
+                        () => this._onDidClickRerunWithAgentOrCommandDetection.fire({
+                            sessionResource: element.sessionResource,
+                            requestId: element.id
+                        })
+                    );
                     templateData.value.appendChild(cmdPart.domNode);
                     parts.push(cmdPart);
                     inlineSlashCommandRendered = true;
@@ -697,93 +922,71 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             }
             templateData.elementDisposables.add(newPart);
         }
-        this.updateItemHeightOnRender(element, templateData);
-    }
-    updateItemHeightOnRender(element, templateData) {
-        const newHeight = templateData.rowContainer.offsetHeight;
-        const fireEvent = !element.currentRenderedHeight || element.currentRenderedHeight !== newHeight;
-        element.currentRenderedHeight = newHeight;
-        if (fireEvent) {
-            const disposable = templateData.elementDisposables.add(scheduleAtNextAnimationFrame(getWindow(templateData.value), () => {
-                if (templateData.rowContainer.isConnected) {
-                    element.currentRenderedHeight = templateData.rowContainer.offsetHeight;
-                    this._onDidChangeItemHeight.fire({ element, height: element.currentRenderedHeight });
-                }
-                disposable.dispose();
-            }));
-        }
-    }
-    updateItemHeight(templateData) {
-        if (!templateData.currentElement) {
-            return;
-        }
-        if (templateData.rowContainer.isConnected) {
-            const newHeight = templateData.rowContainer.offsetHeight;
-            templateData.currentElement.currentRenderedHeight = newHeight;
-            this._onDidChangeItemHeight.fire({ element: templateData.currentElement, height: newHeight });
-        }
     }
     doNextProgressiveRender(element, index, templateData, isInRenderElement) {
         if (!this._isVisible) {
             return true;
         }
         if (element.isCanceled) {
-            this.traceLayout('doNextProgressiveRender', `canceled, index=${index}`);
+            this.traceLayout("doNextProgressiveRender", `canceled, index=${index}`);
             element.renderData = undefined;
             this.renderChatResponseBasic(element, index, templateData);
             return true;
         }
-        templateData.rowContainer.classList.toggle('chat-response-loading', true);
-        this.traceLayout('doNextProgressiveRender', `START progressive render, index=${index}, renderData=${JSON.stringify(element.renderData)}`);
+        templateData.rowContainer.classList.toggle("chat-response-loading", true);
+        this.traceLayout("doNextProgressiveRender", `START progressive render, index=${index}`);
         const contentForThisTurn = this.getNextProgressiveRenderContent(element, templateData);
         const partsToRender = this.diff(templateData.renderedParts ?? [], contentForThisTurn.content, element);
         const contentIsAlreadyRendered = partsToRender.every(part => part === null);
         if (contentIsAlreadyRendered) {
             if (contentForThisTurn.moreContentAvailable) {
-                this.traceLayout('doNextProgressiveRender', 'not rendering any new content this tick, but more available');
+                this.traceLayout(
+                    "doNextProgressiveRender",
+                    "not rendering any new content this tick, but more available"
+                );
                 return false;
-            }
-            else if (element.isComplete) {
-                this.traceLayout('doNextProgressiveRender', `END progressive render, index=${index} and clearing renderData, response is complete`);
+            } else if (element.isComplete) {
+                this.traceLayout(
+                    "doNextProgressiveRender",
+                    `END progressive render, index=${index} and clearing renderData, response is complete`
+                );
                 element.renderData = undefined;
                 this.renderChatResponseBasic(element, index, templateData);
                 return true;
-            }
-            else {
-                this.traceLayout('doNextProgressiveRender', 'caught up with the stream- no new content to render');
-                if (!templateData.renderedParts) {
-                    const height = templateData.rowContainer.offsetHeight;
-                    element.currentRenderedHeight = height;
-                }
+            } else {
+                this.traceLayout(
+                    "doNextProgressiveRender",
+                    "caught up with the stream- no new content to render"
+                );
                 return true;
             }
         }
-        this.traceLayout('doNextProgressiveRender', `doing progressive render, ${partsToRender.length} parts to render`);
+        this.traceLayout(
+            "doNextProgressiveRender",
+            `doing progressive render, ${partsToRender.length} parts to render`
+        );
         this.renderChatContentDiff(partsToRender, contentForThisTurn.content, element, index, templateData);
-        const height = templateData.rowContainer.offsetHeight;
-        element.currentRenderedHeight = height;
-        if (!isInRenderElement) {
-            this._onDidChangeItemHeight.fire({ element, height });
-        }
         return false;
     }
     renderChatContentDiff(partsToRender, contentForThisTurn, element, elementIndex, templateData) {
         const renderedParts = templateData.renderedParts ?? [];
         templateData.renderedParts = renderedParts;
         partsToRender.forEach((partToRender, contentIndex) => {
+            const alreadyRenderedPart = templateData.renderedParts?.[contentIndex];
             if (!partToRender) {
+                if (!templateData.renderedPartsMounted) {
+                    alreadyRenderedPart?.onDidRemount?.();
+                }
                 return;
             }
-            const alreadyRenderedPart = templateData.renderedParts?.[contentIndex];
             if (alreadyRenderedPart) {
-                if (partToRender.kind === 'thinking' && alreadyRenderedPart instanceof ChatThinkingContentPart) {
+                if (partToRender.kind === "thinking" && alreadyRenderedPart instanceof ChatThinkingContentPart) {
                     if (!Array.isArray(partToRender.value)) {
                         alreadyRenderedPart.updateThinking(partToRender);
                     }
                     renderedParts[contentIndex] = alreadyRenderedPart;
                     return;
-                }
-                else if (alreadyRenderedPart instanceof ChatThinkingContentPart && this.shouldPinPart(partToRender, element)) {
+                } else if (alreadyRenderedPart instanceof ChatThinkingContentPart && this.shouldPinPart(partToRender, element)) {
                     renderedParts[contentIndex] = alreadyRenderedPart;
                     return;
                 }
@@ -794,19 +997,22 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 element,
                 elementIndex: elementIndex,
                 content: contentForThisTurn,
-                preceedingContentParts,
                 contentIndex: contentIndex,
                 container: templateData.rowContainer,
                 editorPool: this._editorPool,
                 diffEditorPool: this._diffEditorPool,
                 codeBlockModelCollection: this.codeBlockModelCollection,
-                currentWidth: () => this._currentLayoutWidth,
+                currentWidth: this._currentLayoutWidth,
+                onDidChangeVisibility: this._onDidChangeVisibility.event,
                 get codeBlockStartIndex() {
-                    return context.preceedingContentParts.reduce((acc, part) => acc + (part.codeblocks?.length ?? 0), 0);
+                    return preceedingContentParts.reduce((acc, part) => acc + (part.codeblocks?.length ?? 0), 0);
                 },
+                get treeStartIndex() {
+                    return preceedingContentParts.filter(part => part instanceof ChatTreeContentPart).length;
+                }
             };
             const lastThinking = this.getLastThinkingPart(renderedParts);
-            if (lastThinking && (partToRender.kind === 'toolInvocation' || partToRender.kind === 'toolInvocationSerialized') && this.shouldPinPart(partToRender, element)) {
+            if (lastThinking && (partToRender.kind === "toolInvocation" || partToRender.kind === "toolInvocationSerialized" || partToRender.kind === "markdownContent" || partToRender.kind === "textEditGroup") && this.shouldPinPart(partToRender, element)) {
                 const newPart = this.renderChatContentPart(partToRender, templateData, context);
                 if (newPart) {
                     renderedParts[contentIndex] = newPart;
@@ -823,20 +1029,16 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     if (alreadyRenderedPart?.domNode) {
                         if (newPart.domNode) {
                             alreadyRenderedPart.domNode.replaceWith(newPart.domNode);
-                        }
-                        else {
+                        } else {
                             alreadyRenderedPart.domNode.remove();
                         }
-                    }
-                    else if (newPart.domNode && !newPart.domNode.parentElement) {
+                    } else if (newPart.domNode && !newPart.domNode.parentElement) {
                         templateData.value.appendChild(newPart.domNode);
                     }
+                } catch (err) {
+                    this.logService.error("ChatListItemRenderer#renderChatContentDiff: error replacing part", err);
                 }
-                catch (err) {
-                    this.logService.error('ChatListItemRenderer#renderChatContentDiff: error replacing part', err);
-                }
-            }
-            else {
+            } else {
                 alreadyRenderedPart?.domNode?.remove();
             }
         });
@@ -851,69 +1053,90 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     getNextProgressiveRenderContent(element, templateData) {
         const data = this.getDataForProgressiveRender(element);
-        const renderImmediately = this.configService.getValue('chat.experimental.renderMarkdownImmediately') === true;
+        const renderImmediately = this.configService.getValue("chat.experimental.renderMarkdownImmediately") === true;
         const renderableResponse = annotateSpecialMarkdownContent(element.response.value);
-        this.traceLayout('getNextProgressiveRenderContent', `Want to render ${data.numWordsToRender} at ${data.rate} words/s, counting...`);
+        this.traceLayout(
+            "getNextProgressiveRenderContent",
+            `Want to render ${data.numWordsToRender} at ${data.rate} words/s, counting...`
+        );
         let numNeededWords = data.numWordsToRender;
         const partsToRender = [];
-        partsToRender.push({ kind: 'references', references: element.contentReferences });
+        partsToRender.push({
+            kind: "references",
+            references: element.contentReferences
+        });
         let moreContentAvailable = false;
         for (let i = 0; i < renderableResponse.length; i++) {
             const part = renderableResponse[i];
-            if (part.kind === 'markdownContent' && !renderImmediately) {
+            if (part.kind === "markdownContent" && !renderImmediately) {
                 const wordCountResult = getNWords(part.content.value, numNeededWords);
-                this.traceLayout('getNextProgressiveRenderContent', `  Chunk ${i}: Want to render ${numNeededWords} words and found ${wordCountResult.returnedWordCount} words. Total words in chunk: ${wordCountResult.totalWordCount}`);
+                this.traceLayout(
+                    "getNextProgressiveRenderContent",
+                    `  Chunk ${i}: Want to render ${numNeededWords} words and found ${wordCountResult.returnedWordCount} words. Total words in chunk: ${wordCountResult.totalWordCount}`
+                );
                 numNeededWords -= wordCountResult.returnedWordCount;
                 if (wordCountResult.isFullString) {
                     partsToRender.push(part);
                     for (const nextPart of renderableResponse.slice(i + 1)) {
-                        if (nextPart.kind !== 'markdownContent') {
+                        if (nextPart.kind !== "markdownContent") {
                             i++;
                             partsToRender.push(nextPart);
-                        }
-                        else {
+                        } else {
                             break;
                         }
                     }
-                }
-                else {
+                } else {
                     moreContentAvailable = true;
-                    partsToRender.push({ ...part, content: ( new MarkdownString(wordCountResult.value, part.content)) });
+                    partsToRender.push({
+                        ...part,
+                        content: ( new MarkdownString(wordCountResult.value, part.content))
+                    });
                 }
                 if (numNeededWords <= 0) {
-                    if (( renderableResponse.slice(i + 1).some(part => part.kind === 'markdownContent'))) {
+                    if (( renderableResponse.slice(i + 1).some(part => part.kind === "markdownContent"))) {
                         moreContentAvailable = true;
                     }
                     break;
                 }
-            }
-            else {
+            } else {
                 partsToRender.push(part);
             }
         }
         const lastWordCount = element.contentUpdateTimings?.lastWordCount ?? 0;
         const newRenderedWordCount = data.numWordsToRender - numNeededWords;
         const bufferWords = lastWordCount - newRenderedWordCount;
-        this.traceLayout('getNextProgressiveRenderContent', `Want to render ${data.numWordsToRender} words. Rendering ${newRenderedWordCount} words. Buffer: ${bufferWords} words`);
+        this.traceLayout(
+            "getNextProgressiveRenderContent",
+            `Want to render ${data.numWordsToRender} words. Rendering ${newRenderedWordCount} words. Buffer: ${bufferWords} words`
+        );
         if (newRenderedWordCount > 0 && newRenderedWordCount !== element.renderData?.renderedWordCount) {
-            element.renderData = { lastRenderTime: Date.now(), renderedWordCount: newRenderedWordCount, renderedParts: partsToRender };
+            element.renderData = {
+                lastRenderTime: Date.now(),
+                renderedWordCount: newRenderedWordCount,
+                renderedParts: partsToRender
+            };
         }
         if (this.shouldShowWorkingProgress(element, partsToRender, templateData)) {
-            partsToRender.push({ kind: 'working' });
+            partsToRender.push({
+                kind: "working"
+            });
         }
         const fileChangesSummaryPart = this.getChatFileChangesSummaryPart(element);
         if (fileChangesSummaryPart) {
             partsToRender.push(fileChangesSummaryPart);
         }
-        return { content: partsToRender, moreContentAvailable };
+        return {
+            content: partsToRender,
+            moreContentAvailable
+        };
     }
     shouldShowFileChangesSummary(element) {
         const isLocalSession = getChatSessionType(element.sessionResource) === localChatSessionType;
-        return element.isComplete && isLocalSession && this.configService.getValue('chat.checkpoints.showFileChanges');
+        return element.isComplete && isLocalSession && this.configService.getValue("chat.checkpoints.showFileChanges");
     }
     getDataForProgressiveRender(element) {
         const hasMarkdownParts = ( element.response.value.some(
-            part => part.kind === 'markdownContent' && part.content.value.trim().length > 0
+            part => part.kind === "markdownContent" && part.content.value.trim().length > 0
         ));
         if (!element.isComplete && hasMarkdownParts && (element.contentUpdateTimings ? element.contentUpdateTimings.lastWordCount : 0) === 0) {
             return {
@@ -921,12 +1144,13 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 rate: Number.MAX_SAFE_INTEGER
             };
         }
-        const renderData = element.renderData ?? { lastRenderTime: 0, renderedWordCount: 0 };
+        const renderData = element.renderData ?? {
+            lastRenderTime: 0,
+            renderedWordCount: 0
+        };
         const rate = this.getProgressiveRenderRate(element);
-        const numWordsToRender = renderData.lastRenderTime === 0 ?
-            1 :
-            renderData.renderedWordCount +
-                Math.floor((Date.now() - renderData.lastRenderTime) / 1000 * rate);
+        const numWordsToRender = renderData.lastRenderTime === 0 ? 1 : renderData.renderedWordCount +
+        Math.floor((Date.now() - renderData.lastRenderTime) / 1000 * rate);
         return {
             numWordsToRender,
             rate
@@ -939,56 +1163,78 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             const renderedPart = renderedParts[i];
             if (!renderedPart || !renderedPart.hasSameContent(content, contentToRender.slice(i + 1), element)) {
                 diff.push(content);
-            }
-            else {
+            } else {
                 diff.push(null);
             }
         }
         return diff;
     }
+    hasCodeblockUri(part) {
+        if (part.kind !== "markdownContent") {
+            return false;
+        }
+        return hasCodeblockUriTag(part.content.value);
+    }
+    isCodeblockComplete(part, element) {
+        if (part.kind !== "markdownContent") {
+            return true;
+        }
+        return !isResponseVM(element) || element.isComplete || codeblockHasClosingBackticks(part.content.value);
+    }
     shouldPinPart(part, element) {
-        const collapsedToolsMode = this.configService.getValue('chat.agent.thinking.collapsedTools');
+        const collapsedToolsMode = this.configService.getValue("chat.agent.thinking.collapsedTools");
+        if (part.kind === "thinking" || part.kind === "working") {
+            return true;
+        }
+        if (part.kind === "undoStop") {
+            return true;
+        }
         if (collapsedToolsMode === CollapsedToolsDisplayMode.Off) {
             return false;
         }
-        const isMcpTool = (part.kind === 'toolInvocation' || part.kind === 'toolInvocationSerialized') && part.source.type === 'mcp';
+        if (this.hasCodeblockUri(part) || part.kind === "textEditGroup") {
+            return true;
+        }
+        const isMcpTool = (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.source?.type === "mcp";
         if (isMcpTool) {
             return false;
         }
-        const isSubagentTool = (part.kind === 'toolInvocation' || part.kind === 'toolInvocationSerialized') && (part.fromSubAgent || part.toolId === 'runSubagent');
-        if (isSubagentTool) {
+        const isMermaidTool = (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.toolId.toLowerCase().includes("mermaid");
+        if (isMermaidTool) {
             return false;
         }
-        const isTerminalTool = (part.kind === 'toolInvocation' || part.kind === 'toolInvocationSerialized') && part.toolSpecificData?.kind === 'terminal';
-        const isContributedTerminalToolInvocation = element
-            && (element.sessionResource.scheme !== Schemas.vscodeChatInput && element.sessionResource.scheme !== Schemas.vscodeLocalChatSession)
-            && part.kind === 'toolInvocationSerialized' && part.toolSpecificData?.kind === 'terminal';
-        if (isTerminalTool && !isContributedTerminalToolInvocation) {
+        const isAskQuestionsTool = (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.toolId === "copilot_askQuestions";
+        if (isAskQuestionsTool) {
             return false;
         }
-        if (part.kind === 'toolInvocation') {
-            return !part.confirmationMessages;
-        }
-        if (part.kind === 'toolInvocationSerialized') {
-            return true;
-        }
-        return part.kind === 'prepareToolInvocation';
-    }
-    isCreateToolInvocationContent(content) {
-        if (!content || (content.kind !== 'toolInvocation' && content.kind !== 'toolInvocationSerialized')) {
+        const isSubagentTool = (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && (part.subAgentInvocationId || part.toolId === RunSubagentTool.Id);
+        if (isSubagentTool) {
             return false;
         }
-        const containsCreate = (value) => {
-            if (!value) {
+        const isTerminalTool = (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.toolSpecificData?.kind === "terminal";
+        const isContributedTerminalToolInvocation =
+        element && (element.sessionResource.scheme !== Schemas.vscodeChatInput && element.sessionResource.scheme !== Schemas.vscodeLocalChatSession) && part.kind === "toolInvocationSerialized" && part.toolSpecificData?.kind === "terminal";
+        if (isTerminalTool && !isContributedTerminalToolInvocation) {
+            if (part.kind === "toolInvocation" && IChatToolInvocation.getConfirmationMessages(part)) {
                 return false;
             }
-            const text = typeof value === 'string' ? value : value.value;
-            return text.toLowerCase().includes('create');
-        };
-        if (containsCreate(content.invocationMessage) || containsCreate(content.pastTenseMessage)) {
+            const terminalToolsInThinking = this.configService.getValue(ChatConfiguration.TerminalToolsInThinking);
+            return !!terminalToolsInThinking;
+        }
+        if (part.kind === "toolInvocation") {
+            if (IChatToolInvocation.isStreaming(part)) {
+                return true;
+            }
+            const state = part.state.get();
+            if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
+                return false;
+            }
+            return !IChatToolInvocation.getConfirmationMessages(part);
+        }
+        if (part.kind === "toolInvocationSerialized") {
             return true;
         }
-        return content.toolId.toLowerCase().includes('create');
+        return false;
     }
     getLastThinkingPart(renderedParts) {
         if (!renderedParts || renderedParts.length === 0) {
@@ -1002,12 +1248,77 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         return undefined;
     }
+    isThinkingLookAheadComplete(context, element) {
+        if (element?.isComplete) {
+            return true;
+        }
+        for (let i = context.contentIndex + 1; i < context.content.length; i++) {
+            const nextPart = context.content[i];
+            if (!this.shouldPinPart(nextPart, element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getSubagentPart(renderedParts, subAgentInvocationId) {
+        if (!renderedParts || renderedParts.length === 0) {
+            return undefined;
+        }
+        for (let i = renderedParts.length - 1; i >= 0; i--) {
+            const part = renderedParts[i];
+            if (part instanceof ChatSubagentContentPart) {
+                if (subAgentInvocationId && part.subAgentInvocationId === subAgentInvocationId) {
+                    return part;
+                }
+                if (!subAgentInvocationId && part.getIsActive()) {
+                    return part;
+                }
+            }
+        }
+        return undefined;
+    }
+    finalizeAllSubagentParts(templateData) {
+        if (!templateData.renderedParts) {
+            return;
+        }
+        for (const part of templateData.renderedParts) {
+            if (part instanceof ChatSubagentContentPart && part.getIsActive()) {
+                part.markAsInactive();
+            }
+        }
+    }
+    handleSubagentToolGrouping(toolInvocation, subagentId, context, templateData, codeBlockStartIndex) {
+        this.finalizeCurrentThinkingPart(context, templateData);
+        const lastSubagent = this.getSubagentPart(templateData.renderedParts, subagentId);
+        if (lastSubagent) {
+            if (toolInvocation.toolId !== RunSubagentTool.Id) {
+                lastSubagent.appendToolInvocation(toolInvocation, codeBlockStartIndex);
+            }
+            return lastSubagent;
+        }
+        const subagentPart = this.instantiationService.createInstance(
+            ChatSubagentContentPart,
+            subagentId,
+            toolInvocation,
+            context,
+            this.chatContentMarkdownRenderer,
+            this._contentReferencesListPool,
+            this._toolEditorPool,
+            () => this._currentLayoutWidth.get(),
+            this._toolInvocationCodeBlockCollection,
+            this._announcedToolProgressKeys
+        );
+        if (toolInvocation.toolId !== RunSubagentTool.Id) {
+            subagentPart.appendToolInvocation(toolInvocation, codeBlockStartIndex);
+        }
+        return subagentPart;
+    }
     finalizeCurrentThinkingPart(context, templateData) {
         const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
         if (!lastThinking) {
             return;
         }
-        const style = this.configService.getValue('chat.agent.thinkingStyle');
+        const style = this.configService.getValue("chat.agent.thinkingStyle");
         if (style === ThinkingDisplayMode.CollapsedPreview) {
             lastThinking.collapseContent();
         }
@@ -1017,110 +1328,113 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     renderChatContentPart(content, templateData, context) {
         try {
-            const collapsedToolsMode = this.configService.getValue('chat.agent.thinking.collapsedTools');
-            if (content.kind === 'thinking' && (Array.isArray(content.value) ? content.value.length === 0 : !content.value)) {
+            if (content.kind === "thinking" && (Array.isArray(content.value) ? content.value.length === 0 : content.value === "")) {
                 const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
                 lastThinking?.resetId();
                 return this.renderNoContent(other => content.kind === other.kind);
             }
-            const lastRenderedPart = context.preceedingContentParts.length ? context.preceedingContentParts[context.preceedingContentParts.length - 1] : undefined;
-            const previousContent = context.contentIndex > 0 ? context.content[context.contentIndex - 1] : undefined;
-            const shouldKeepThinkingForCreateTool = collapsedToolsMode !== CollapsedToolsDisplayMode.Off && lastRenderedPart instanceof ChatToolInvocationPart && this.isCreateToolInvocationContent(previousContent);
-            const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
             const isResponseElement = isResponseVM(context.element);
-            const isThinkingContent = content.kind === 'working' || content.kind === 'thinking';
-            const isToolStreamingContent = isResponseElement && this.shouldPinPart(content, isResponseElement ? context.element : undefined);
-            if (!shouldKeepThinkingForCreateTool && lastThinking && lastThinking.getIsActive()) {
-                if (!isThinkingContent && !isToolStreamingContent) {
-                    const followsThinkingPart = previousContent?.kind === 'thinking' || previousContent?.kind === 'toolInvocation' || previousContent?.kind === 'prepareToolInvocation' || previousContent?.kind === 'toolInvocationSerialized';
-                    if (content.kind !== 'textEditGroup' && (context.element.isComplete || followsThinkingPart)) {
-                        this.finalizeCurrentThinkingPart(context, templateData);
-                    }
-                }
-            }
-            if (context.element.isComplete && !isThinkingContent && !this.shouldPinPart(content, isResponseElement ? context.element : undefined)) {
+            const shouldPin = this.shouldPinPart(content, isResponseElement ? context.element : undefined);
+            if (context.element.isComplete && !shouldPin) {
                 for (const templateData of ( this.templateDataByRequestId.values())) {
                     if (templateData.renderedParts) {
                         const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-                        if (content.kind !== 'textEditGroup' && lastThinking?.getIsActive()) {
+                        if (lastThinking?.getIsActive()) {
                             this.finalizeCurrentThinkingPart(context, templateData);
                         }
                     }
                 }
             }
-            if (content.kind === 'treeData') {
-                return this.renderTreeData(content, templateData, context);
+            const isSubagentContent = (content.kind === "toolInvocation" || content.kind === "toolInvocationSerialized") && (content.subAgentInvocationId || content.toolId === RunSubagentTool.Id);
+            if (context.element.isComplete && !isSubagentContent) {
+                for (const templateData of ( this.templateDataByRequestId.values())) {
+                    this.finalizeAllSubagentParts(templateData);
+                }
             }
-            else if (content.kind === 'multiDiffData') {
+            if (content.kind === "treeData") {
+                return this.renderTreeData(content, templateData, context);
+            } else if (content.kind === "multiDiffData") {
                 return this.renderMultiDiffData(content, templateData, context);
-            }
-            else if (content.kind === 'progressMessage') {
-                return this.instantiationService.createInstance(ChatProgressContentPart, content, this.chatContentMarkdownRenderer, context, undefined, undefined, undefined, undefined);
-            }
-            else if (content.kind === 'working') {
-                return this.instantiationService.createInstance(ChatWorkingProgressContentPart, content, this.chatContentMarkdownRenderer, context);
-            }
-            else if (content.kind === 'progressTask' || content.kind === 'progressTaskSerialized') {
+            } else if (content.kind === "progressMessage") {
+                return this.instantiationService.createInstance(
+                    ChatProgressContentPart,
+                    content,
+                    this.chatContentMarkdownRenderer,
+                    context,
+                    undefined,
+                    undefined,
+                    undefined,
+                    undefined
+                );
+            } else if (content.kind === "working") {
+                return this.instantiationService.createInstance(
+                    ChatWorkingProgressContentPart,
+                    content,
+                    this.chatContentMarkdownRenderer,
+                    context
+                );
+            } else if (content.kind === "progressTask" || content.kind === "progressTaskSerialized") {
                 return this.renderProgressTask(content, templateData, context);
-            }
-            else if (content.kind === 'command') {
+            } else if (content.kind === "command") {
                 return this.instantiationService.createInstance(ChatCommandButtonContentPart, content, context);
-            }
-            else if (content.kind === 'textEditGroup') {
+            } else if (content.kind === "textEditGroup") {
                 return this.renderTextEdit(context, content, templateData);
-            }
-            else if (content.kind === 'confirmation') {
+            } else if (content.kind === "confirmation") {
                 return this.renderConfirmation(context, content, templateData);
-            }
-            else if (content.kind === 'warning') {
-                return this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Warning, content.content, content, this.chatContentMarkdownRenderer);
-            }
-            else if (content.kind === 'markdownContent') {
+            } else if (content.kind === "warning") {
+                return this.instantiationService.createInstance(
+                    ChatErrorContentPart,
+                    ChatErrorLevel.Warning,
+                    content.content,
+                    content,
+                    this.chatContentMarkdownRenderer
+                );
+            } else if (content.kind === "markdownContent") {
                 return this.renderMarkdown(content, templateData, context);
-            }
-            else if (content.kind === 'references') {
+            } else if (content.kind === "references") {
                 return this.renderContentReferencesListData(content, undefined, context, templateData);
-            }
-            else if (content.kind === 'codeCitations') {
+            } else if (content.kind === "codeCitations") {
                 return this.renderCodeCitations(content, context, templateData);
-            }
-            else if (content.kind === 'toolInvocation' || content.kind === 'toolInvocationSerialized') {
+            } else if (content.kind === "toolInvocation" || content.kind === "toolInvocationSerialized") {
                 return this.renderToolInvocation(content, context, templateData);
-            }
-            else if (content.kind === 'extensions') {
+            } else if (content.kind === "extensions") {
                 return this.renderExtensionsContent(content, context, templateData);
-            }
-            else if (content.kind === 'pullRequest') {
+            } else if (content.kind === "pullRequest") {
                 return this.renderPullRequestContent(content, context, templateData);
-            }
-            else if (content.kind === 'undoStop') {
+            } else if (content.kind === "undoStop") {
                 return this.renderUndoStop(content);
-            }
-            else if (content.kind === 'errorDetails') {
+            } else if (content.kind === "errorDetails") {
                 return this.renderChatErrorDetails(context, content, templateData);
-            }
-            else if (content.kind === 'elicitation2' || content.kind === 'elicitationSerialized') {
+            } else if (content.kind === "elicitation2" || content.kind === "elicitationSerialized") {
                 return this.renderElicitation(context, content, templateData);
-            }
-            else if (content.kind === 'changesSummary') {
+            } else if (content.kind === "questionCarousel") {
+                return this.renderQuestionCarousel(context, content, templateData);
+            } else if (content.kind === "changesSummary") {
                 return this.renderChangesSummary(content, context, templateData);
-            }
-            else if (content.kind === 'mcpServersStarting') {
+            } else if (content.kind === "mcpServersStarting") {
                 return this.renderMcpServersInteractionRequired(content, context, templateData);
-            }
-            else if (content.kind === 'thinking') {
+            } else if (content.kind === "thinking") {
                 return this.renderThinkingPart(content, context, templateData);
+            } else if (content.kind === "workspaceEdit") {
+                return this.instantiationService.createInstance(
+                    ChatWorkspaceEditContentPart,
+                    content,
+                    context,
+                    this.chatContentMarkdownRenderer
+                );
             }
             return this.renderNoContent(other => content.kind === other.kind);
-        }
-        catch (err) {
+        } catch (err) {
             alert(`Chat error: ${toErrorMessage(err, false)}`);
-            this.logService.error('ChatListItemRenderer#renderChatContentPart: error rendering content', toErrorMessage(err, true));
-            const errorPart = this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Error, ( new MarkdownString(( localize(5780, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
+            this.logService.error(
+                "ChatListItemRenderer#renderChatContentPart: error rendering content",
+                toErrorMessage(err, true)
+            );
+            const errorPart = this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Error, ( new MarkdownString(( localize(6036, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
             return {
                 dispose: () => errorPart.dispose(),
                 domNode: errorPart.domNode,
-                hasSameContent: (other => content.kind === other.kind),
+                hasSameContent: (other => content.kind === other.kind)
             };
         }
     }
@@ -1134,21 +1448,21 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         const isLast = context.elementIndex === this.delegate.getListLength() - 1;
         if (content.errorDetails.isQuotaExceeded) {
-            const renderedError = this.instantiationService.createInstance(ChatQuotaExceededPart, context.element, content, this.chatContentMarkdownRenderer);
-            renderedError.addDisposable(renderedError.onDidChangeHeight(() => this.updateItemHeight(templateData)));
+            const renderedError = this.instantiationService.createInstance(
+                ChatQuotaExceededPart,
+                context.element,
+                content,
+                this.chatContentMarkdownRenderer
+            );
             return renderedError;
-        }
-        else if (content.errorDetails.isRateLimited && this.chatEntitlementService.anonymous) {
+        } else if (content.errorDetails.isRateLimited && this.chatEntitlementService.anonymous) {
             const renderedError = this.instantiationService.createInstance(ChatAnonymousRateLimitedPart, content);
             return renderedError;
-        }
-        else if (content.errorDetails.confirmationButtons && isLast) {
+        } else if (content.errorDetails.confirmationButtons && isLast) {
             const level = content.errorDetails.level ?? ChatErrorLevel.Error;
             const errorConfirmation = this.instantiationService.createInstance(ChatErrorConfirmationContentPart, level, ( new MarkdownString(content.errorDetails.message)), content, content.errorDetails.confirmationButtons, this.chatContentMarkdownRenderer, context);
-            errorConfirmation.addDisposable(errorConfirmation.onDidChangeHeight(() => this.updateItemHeight(templateData)));
             return errorConfirmation;
-        }
-        else {
+        } else {
             const level = content.errorDetails.level ?? ChatErrorLevel.Error;
             return this.instantiationService.createInstance(ChatErrorContentPart, level, ( new MarkdownString(content.errorDetails.message)), content, this.chatContentMarkdownRenderer);
         }
@@ -1158,22 +1472,18 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     renderNoContent(equals) {
         return {
-            dispose: () => { },
+            dispose: () => {},
             domNode: undefined,
-            hasSameContent: equals,
+            hasSameContent: equals
         };
     }
     renderTreeData(content, templateData, context) {
         const data = content.treeData;
-        const treeDataIndex = context.preceedingContentParts.filter(part => part instanceof ChatTreeContentPart).length;
-        const treePart = this.instantiationService.createInstance(ChatTreeContentPart, data, context.element, this._treePool, treeDataIndex);
-        treePart.addDisposable(treePart.onDidChangeHeight(() => {
-            this.updateItemHeight(templateData);
-        }));
+        const treePart = this.instantiationService.createInstance(ChatTreeContentPart, data, this._treePool);
         if (isResponseVM(context.element)) {
             const fileTreeFocusInfo = {
                 treeDataId: ( data.uri.toString()),
-                treeIndex: treeDataIndex,
+                treeIndex: context.treeStartIndex,
                 focus() {
                     treePart.domFocus();
                 }
@@ -1183,23 +1493,31 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             }));
             const fileTrees = this.fileTreesByResponseId.get(context.element.id) ?? [];
             fileTrees.push(fileTreeFocusInfo);
-            this.fileTreesByResponseId.set(context.element.id, distinct(fileTrees, (v) => v.treeDataId));
-            treePart.addDisposable(toDisposable(() => this.fileTreesByResponseId.set(context.element.id, fileTrees.filter(v => v.treeDataId !== ( data.uri.toString())))));
+            this.fileTreesByResponseId.set(context.element.id, distinct(fileTrees, v => v.treeDataId));
+            treePart.addDisposable(toDisposable(
+                () => this.fileTreesByResponseId.set(context.element.id, fileTrees.filter(v => v.treeDataId !== ( data.uri.toString())))
+            ));
         }
         return treePart;
     }
     renderMultiDiffData(content, templateData, context) {
         const multiDiffPart = this.instantiationService.createInstance(ChatMultiDiffContentPart, content, context.element);
-        multiDiffPart.addDisposable(multiDiffPart.onDidChangeHeight(() => {
-            this.updateItemHeight(templateData);
-        }));
         return multiDiffPart;
     }
     renderContentReferencesListData(references, labelOverride, context, templateData) {
-        const referencesPart = this.instantiationService.createInstance(ChatUsedReferencesListContentPart, references.references, labelOverride, context, this._contentReferencesListPool, { expandedWhenEmptyResponse: checkModeOption(this.delegate.currentChatMode(), this.rendererOptions.referencesExpandedWhenEmptyResponse) });
-        referencesPart.addDisposable(referencesPart.onDidChangeHeight(() => {
-            this.updateItemHeight(templateData);
-        }));
+        const referencesPart = this.instantiationService.createInstance(
+            ChatUsedReferencesListContentPart,
+            references.references,
+            labelOverride,
+            context,
+            this._contentReferencesListPool,
+            {
+                expandedWhenEmptyResponse: checkModeOption(
+                    this.delegate.currentChatMode(),
+                    this.rendererOptions.referencesExpandedWhenEmptyResponse
+                )
+            }
+        );
         return referencesPart;
     }
     renderCodeCitations(citations, context, templateData) {
@@ -1240,76 +1558,206 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         });
     }
     renderToolInvocation(toolInvocation, context, templateData) {
+        if (this.configService.getValue("chat.agent.thinking.collapsedTools") === CollapsedToolsDisplayMode.Off) {
+            this.finalizeCurrentThinkingPart(context, templateData);
+        }
         const codeBlockStartIndex = context.codeBlockStartIndex;
-        const part = this.instantiationService.createInstance(ChatToolInvocationPart, toolInvocation, context, this.chatContentMarkdownRenderer, this._contentReferencesListPool, this._toolEditorPool, () => this._currentLayoutWidth, this._toolInvocationCodeBlockCollection, this._announcedToolProgressKeys, codeBlockStartIndex);
-        part.addDisposable(part.onDidChangeHeight(() => {
-            this.updateItemHeight(templateData);
-        }));
-        this.handleRenderedCodeblocks(context.element, part, codeBlockStartIndex);
-        const collapsedToolsMode = this.configService.getValue('chat.agent.thinking.collapsedTools');
+        let lazilyCreatedPart = undefined;
+        const createToolPart = () => {
+            lazilyCreatedPart = this.instantiationService.createInstance(
+                ChatToolInvocationPart,
+                toolInvocation,
+                context,
+                this.chatContentMarkdownRenderer,
+                this._contentReferencesListPool,
+                this._toolEditorPool,
+                () => this._currentLayoutWidth.get(),
+                this._toolInvocationCodeBlockCollection,
+                this._announcedToolProgressKeys,
+                codeBlockStartIndex
+            );
+            this.handleRenderedCodeblocks(context.element, lazilyCreatedPart, codeBlockStartIndex);
+            return {
+                domNode: lazilyCreatedPart.domNode,
+                part: lazilyCreatedPart
+            };
+        };
+        const collapsedToolsMode = this.configService.getValue("chat.agent.thinking.collapsedTools");
         if (isResponseVM(context.element) && collapsedToolsMode !== CollapsedToolsDisplayMode.Off) {
             const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-            if (!lastThinking && part?.domNode && toolInvocation.presentation !== 'hidden' && this.shouldPinPart(toolInvocation, context.element) && collapsedToolsMode === CollapsedToolsDisplayMode.Always) {
+            if (!lastThinking && toolInvocation.presentation !== "hidden" && this.shouldPinPart(toolInvocation, context.element) && collapsedToolsMode === CollapsedToolsDisplayMode.Always) {
                 const thinkingPart = this.renderThinkingPart({
-                    kind: 'thinking',
+                    kind: "thinking"
                 }, context, templateData);
                 if (thinkingPart instanceof ChatThinkingContentPart) {
-                    thinkingPart.appendItem(part?.domNode, toolInvocation.toolId, toolInvocation, templateData.value);
-                    thinkingPart.addDisposable(part);
-                    thinkingPart.addDisposable(thinkingPart.onDidChangeHeight(() => {
-                        this.updateItemHeight(templateData);
-                    }));
+                    thinkingPart.appendItem(createToolPart, toolInvocation.toolId, toolInvocation, templateData.value);
+                    this.setupConfirmationTransitionWatcher(
+                        toolInvocation,
+                        thinkingPart,
+                        () => lazilyCreatedPart,
+                        createToolPart,
+                        context,
+                        templateData
+                    );
                 }
                 return thinkingPart;
             }
             if (this.shouldPinPart(toolInvocation, context.element)) {
-                if (lastThinking && part?.domNode && toolInvocation.presentation !== 'hidden') {
-                    lastThinking.appendItem(part?.domNode, toolInvocation.toolId, toolInvocation, templateData.value);
-                    lastThinking.addDisposable(part);
+                if (lastThinking && toolInvocation.presentation !== "hidden") {
+                    lastThinking.appendItem(createToolPart, toolInvocation.toolId, toolInvocation, templateData.value);
+                    this.setupConfirmationTransitionWatcher(
+                        toolInvocation,
+                        lastThinking,
+                        () => lazilyCreatedPart,
+                        createToolPart,
+                        context,
+                        templateData
+                    );
+                    return this.renderNoContent(
+                        (other, followingContent, element) => lazilyCreatedPart ? lazilyCreatedPart.hasSameContent(other, followingContent, element) : toolInvocation.kind === other.kind
+                    );
                 }
-            }
-            else {
+            } else {
                 this.finalizeCurrentThinkingPart(context, templateData);
             }
         }
+        const subagentId = toolInvocation.toolId === RunSubagentTool.Id ? toolInvocation.toolCallId : toolInvocation.subAgentInvocationId;
+        if (subagentId && isResponseVM(context.element) && toolInvocation.presentation !== "hidden") {
+            return this.handleSubagentToolGrouping(toolInvocation, subagentId, context, templateData, codeBlockStartIndex);
+        }
+        const {
+            part
+        } = createToolPart();
         return part;
     }
+    setupConfirmationTransitionWatcher(
+        toolInvocation,
+        thinkingPart,
+        getCreatedPart,
+        createToolPart,
+        context,
+        templateData
+    ) {
+        if (toolInvocation.kind !== "toolInvocation") {
+            return;
+        }
+        const removeConfirmationWidget = () => {
+            const createdPart = getCreatedPart();
+            if (createdPart?.domNode) {
+                const wrapper = createdPart.domNode.parentElement;
+                if (wrapper?.classList.contains("chat-thinking-tool-wrapper")) {
+                    wrapper.remove();
+                }
+                templateData.value.appendChild(createdPart.domNode);
+            } else {
+                thinkingPart.removeLazyItem(toolInvocation.toolId);
+                const {
+                    domNode
+                } = createToolPart();
+                templateData.value.appendChild(domNode);
+            }
+            this.finalizeCurrentThinkingPart(context, templateData);
+        };
+        const currentState = toolInvocation.state.get();
+        if (currentState.type === IChatToolInvocation.StateKind.WaitingForConfirmation || currentState.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
+            removeConfirmationWidget();
+            return;
+        }
+        const isWorkingState = type => type === IChatToolInvocation.StateKind.Streaming || type === IChatToolInvocation.StateKind.Executing;
+        if (!isWorkingState(currentState.type)) {
+            return;
+        }
+        let didRemoveConfirmationWidget = false;
+        const disposable = autorun(reader => {
+            const state = toolInvocation.state.read(reader);
+            if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
+                if (didRemoveConfirmationWidget) {
+                    return;
+                }
+                didRemoveConfirmationWidget = true;
+                disposable.dispose();
+                removeConfirmationWidget();
+            }
+        });
+        thinkingPart.addDisposable(disposable);
+    }
     renderExtensionsContent(extensionsContent, context, templateData) {
         const part = this.instantiationService.createInstance(ChatExtensionsContentPart, extensionsContent);
-        part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
         return part;
     }
     renderPullRequestContent(pullRequestContent, context, templateData) {
         const part = this.instantiationService.createInstance(ChatPullRequestContentPart, pullRequestContent);
-        part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
         return part;
     }
     renderProgressTask(task, templateData, context) {
         if (!isResponseVM(context.element)) {
             return;
         }
-        const taskPart = this.instantiationService.createInstance(ChatTaskContentPart, task, this._contentReferencesListPool, this.chatContentMarkdownRenderer, context);
-        taskPart.addDisposable(taskPart.onDidChangeHeight(() => {
-            this.updateItemHeight(templateData);
-        }));
+        const taskPart = this.instantiationService.createInstance(
+            ChatTaskContentPart,
+            task,
+            this._contentReferencesListPool,
+            this.chatContentMarkdownRenderer,
+            context
+        );
         return taskPart;
     }
     renderConfirmation(context, confirmation, templateData) {
         const part = this.instantiationService.createInstance(ChatConfirmationContentPart, confirmation, context);
-        part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
         return part;
     }
     renderElicitation(context, elicitation, templateData) {
-        if (elicitation.kind === 'elicitationSerialized' ? elicitation.isHidden : elicitation.isHidden?.get()) {
+        if (elicitation.kind === "elicitationSerialized" ? elicitation.isHidden : elicitation.isHidden?.get()) {
             return this.renderNoContent(other => elicitation.kind === other.kind);
         }
+        this.finalizeCurrentThinkingPart(context, templateData);
         const part = this.instantiationService.createInstance(ChatElicitationContentPart, elicitation, context);
-        part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
         return part;
     }
+    renderQuestionCarousel(context, carousel, templateData) {
+        this.finalizeCurrentThinkingPart(context, templateData);
+        const widget = isResponseVM(context.element) ? this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource) : undefined;
+        const shouldAutoFocus = widget ? widget.getInput() === "" : true;
+        const part = this.instantiationService.createInstance(ChatQuestionCarouselPart, carousel, context, {
+            shouldAutoFocus,
+            onSubmit: async answers => {
+                const answersRecord = answers ? Object.fromEntries(answers) : undefined;
+                if (answersRecord) {
+                    carousel.data = answersRecord;
+                }
+                carousel.isUsed = true;
+                if (isResponseVM(context.element) && carousel.resolveId) {
+                    this.chatService.notifyQuestionCarouselAnswer(context.element.requestId, carousel.resolveId, answersRecord);
+                }
+                this.removeCarouselFromTracking(context, part);
+            }
+        });
+        if (!carousel.isUsed && this.configService.getValue(ChatConfiguration.GlobalAutoApprove)) {
+            part.skip();
+        }
+        if (isResponseVM(context.element) && carousel.allowSkip && !carousel.isUsed) {
+            let carousels = this.pendingQuestionCarousels.get(context.element.sessionResource);
+            if (!carousels) {
+                carousels = ( new Set());
+                this.pendingQuestionCarousels.set(context.element.sessionResource, carousels);
+            }
+            carousels.add(part);
+            part.addDisposable({
+                dispose: () => this.removeCarouselFromTracking(context, part)
+            });
+        }
+        return part;
+    }
+    removeCarouselFromTracking(context, part) {
+        if (isResponseVM(context.element)) {
+            const carousels = this.pendingQuestionCarousels.get(context.element.sessionResource);
+            if (carousels) {
+                carousels.delete(part);
+            }
+        }
+    }
     renderChangesSummary(content, context, templateData) {
         const part = this.instantiationService.createInstance(ChatCheckpointFileChangesSummaryContentPart, content, context);
-        part.addDisposable(part.onDidChangeHeight(() => { this.updateItemHeight(templateData); }));
         return part;
     }
     renderAttachments(variables, contentReferences, templateData) {
@@ -1320,66 +1768,130 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         });
     }
     renderTextEdit(context, chatTextEdit, templateData) {
-        const textEditPart = this.instantiationService.createInstance(ChatTextEditContentPart, chatTextEdit, context, this.rendererOptions, this._diffEditorPool, this._currentLayoutWidth);
-        textEditPart.addDisposable(textEditPart.onDidChangeHeight(() => {
-            textEditPart.layout(this._currentLayoutWidth);
-            this.updateItemHeight(templateData);
-        }));
+        const textEditPart = this.instantiationService.createInstance(
+            ChatTextEditContentPart,
+            chatTextEdit,
+            context,
+            this.rendererOptions,
+            this._diffEditorPool,
+            this._currentLayoutWidth.get()
+        );
         return textEditPart;
     }
     renderMarkdown(markdown, templateData, context) {
-        this.finalizeCurrentThinkingPart(context, templateData);
         const element = context.element;
+        const isFinalAnswerPart = isResponseVM(element) && element.isComplete && context.contentIndex === context.content.length - 1;
+        if (!this.hasCodeblockUri(markdown) || isFinalAnswerPart) {
+            this.finalizeCurrentThinkingPart(context, templateData);
+        }
         const fillInIncompleteTokens = isResponseVM(element) && (!element.isComplete || element.isCanceled || element.errorDetails?.responseIsFiltered || element.errorDetails?.responseIsIncomplete || !!element.renderData);
         const codeBlockStartIndex = context.codeBlockStartIndex;
-        const markdownPart = templateData.instantiationService.createInstance(ChatMarkdownContentPart, markdown, context, this._editorPool, fillInIncompleteTokens, codeBlockStartIndex, this.chatContentMarkdownRenderer, undefined, this._currentLayoutWidth, this.codeBlockModelCollection, {});
+        const markdownPart = templateData.instantiationService.createInstance(
+            ChatMarkdownContentPart,
+            markdown,
+            context,
+            this._editorPool,
+            fillInIncompleteTokens,
+            codeBlockStartIndex,
+            this.chatContentMarkdownRenderer,
+            undefined,
+            this._currentLayoutWidth.get(),
+            this.codeBlockModelCollection,
+            {}
+        );
         if (isRequestVM(element)) {
             markdownPart.domNode.tabIndex = 0;
-            if (this.configService.getValue('chat.editRequests') === 'inline' && this.rendererOptions.editable) {
-                markdownPart.domNode.classList.add('clickable');
-                markdownPart.addDisposable(addDisposableListener(markdownPart.domNode, EventType.CLICK, (e) => {
-                    if (this.viewModel?.editing?.id === element.id) {
-                        return;
-                    }
-                    const clickedElement = e.target;
-                    if (clickedElement.tagName === 'A') {
-                        return;
-                    }
-                    const selection = getWindow(templateData.rowContainer).getSelection();
-                    if (selection && !selection.isCollapsed && ( selection.toString()).length > 0) {
-                        return;
-                    }
-                    const monacoEditor = findParentWithClass(clickedElement, 'monaco-editor');
-                    if (monacoEditor) {
-                        const editorPart = Array.from(this.editorsInUse()).find(editor => editor.element.contains(monacoEditor));
-                        if (editorPart?.editor.getSelection()?.isEmpty() === false) {
+            if (this.configService.getValue("chat.editRequests") === "inline" && this.rendererOptions.editable) {
+                markdownPart.domNode.classList.add("clickable");
+                markdownPart.addDisposable(
+                    addDisposableListener(markdownPart.domNode, EventType.CLICK, e => {
+                        if (this.viewModel?.editing?.id === element.id) {
                             return;
                         }
-                    }
-                    e.preventDefault();
-                    e.stopPropagation();
-                    this._onDidClickRequest.fire(templateData);
-                }));
-                markdownPart.addDisposable(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), markdownPart.domNode, ( localize(5781, "Click to Edit")), { trapFocus: true }));
-            }
-            markdownPart.addDisposable(addDisposableListener(markdownPart.domNode, EventType.FOCUS, () => {
-                this.hoverVisible(templateData.requestHover);
-            }));
-            markdownPart.addDisposable(addDisposableListener(markdownPart.domNode, EventType.BLUR, () => {
-                this.hoverHidden(templateData.requestHover);
-            }));
+                        const clickedElement = e.target;
+                        if (clickedElement.tagName === "A") {
+                            return;
+                        }
+                        const selection = getWindow(templateData.rowContainer).getSelection();
+                        if (selection && !selection.isCollapsed && ( selection.toString()).length > 0) {
+                            return;
+                        }
+                        const monacoEditor = findParentWithClass(clickedElement, "monaco-editor");
+                        if (monacoEditor) {
+                            const editorPart = Array.from(this.editorsInUse()).find(editor => editor.element.contains(monacoEditor));
+                            if (editorPart?.editor.getSelection()?.isEmpty() === false) {
+                                return;
+                            }
+                        }
+                        e.preventDefault();
+                        e.stopPropagation();
+                        this._onDidClickRequest.fire(templateData);
+                    })
+                );
+                markdownPart.addDisposable(
+                    this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), markdownPart.domNode, ( localize(6037, "Click to Edit")), {
+                        trapFocus: true
+                    })
+                );
+            }
+            markdownPart.addDisposable(
+                addDisposableListener(markdownPart.domNode, EventType.FOCUS, () => {
+                    this.hoverVisible(templateData.requestHover);
+                })
+            );
+            markdownPart.addDisposable(
+                addDisposableListener(markdownPart.domNode, EventType.BLUR, () => {
+                    this.hoverHidden(templateData.requestHover);
+                })
+            );
         }
-        markdownPart.addDisposable(markdownPart.onDidChangeHeight(() => {
-            markdownPart.layout(this._currentLayoutWidth);
-            this.updateItemHeight(templateData);
-        }));
         this.handleRenderedCodeblocks(element, markdownPart, codeBlockStartIndex);
+        const collapsedToolsMode = this.configService.getValue("chat.agent.thinking.collapsedTools");
+        if (isResponseVM(context.element) && collapsedToolsMode !== CollapsedToolsDisplayMode.Off && !isFinalAnswerPart) {
+            const isComplete = this.isCodeblockComplete(markdown, context.element);
+            const subAgentInvocationId = extractSubAgentInvocationIdFromText(markdown.content.value);
+            if (subAgentInvocationId) {
+                const subagentPart = this.getSubagentPart(templateData.renderedParts, subAgentInvocationId);
+                if (subagentPart && markdownPart?.domNode && isComplete) {
+                    subagentPart.appendMarkdownItem(() => ({
+                        domNode: markdownPart.domNode,
+                        disposable: markdownPart
+                    }), markdownPart.codeblocksPartId, markdown, templateData.value);
+                    return subagentPart;
+                }
+            }
+            const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+            if (!lastThinking && markdownPart?.domNode && this.shouldPinPart(markdown, context.element) && collapsedToolsMode === CollapsedToolsDisplayMode.Always && isComplete) {
+                const thinkingPart = this.renderThinkingPart({
+                    kind: "thinking"
+                }, context, templateData);
+                if (thinkingPart instanceof ChatThinkingContentPart) {
+                    thinkingPart.appendItem(() => ({
+                        domNode: markdownPart.domNode,
+                        disposable: markdownPart
+                    }), markdownPart.codeblocksPartId, markdown, templateData.value);
+                }
+                return thinkingPart;
+            }
+            if (this.shouldPinPart(markdown, context.element) && isComplete) {
+                if (lastThinking && markdownPart?.domNode) {
+                    lastThinking.appendItem(() => ({
+                        domNode: markdownPart.domNode,
+                        disposable: markdownPart
+                    }), markdownPart.codeblocksPartId, markdown, templateData.value);
+                }
+            } else if (!this.shouldPinPart(markdown, context.element)) {
+                this.finalizeCurrentThinkingPart(context, templateData);
+            }
+        }
         return markdownPart;
     }
     renderThinkingPart(content, context, templateData) {
         if (!content.id) {
             content.id = ( Date.now().toString());
         }
+        const element = isResponseVM(context.element) ? context.element : undefined;
+        const streamingCompleted = this.isThinkingLookAheadComplete(context, element);
         if (Array.isArray(content.value)) {
             if (content.value.length < 1) {
                 const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
@@ -1391,33 +1903,46 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 if (item) {
                     const lastThinkingPart = lastPart instanceof ChatThinkingContentPart && lastPart.getIsActive() ? lastPart : undefined;
                     if (lastThinkingPart) {
-                        lastThinkingPart.setupThinkingContainer({ ...content, value: item }, context);
-                    }
-                    else {
-                        const itemContent = { ...content, value: item };
-                        const itemPart = templateData.instantiationService.createInstance(ChatThinkingContentPart, itemContent, context, this.chatContentMarkdownRenderer);
-                        itemPart.addDisposable(itemPart.onDidChangeHeight(() => this.updateItemHeight(templateData)));
+                        lastThinkingPart.setupThinkingContainer({
+                            ...content,
+                            value: item
+                        });
+                    } else {
+                        const itemContent = {
+                            ...content,
+                            value: item
+                        };
+                        const itemPart = templateData.instantiationService.createInstance(
+                            ChatThinkingContentPart,
+                            itemContent,
+                            context,
+                            this.chatContentMarkdownRenderer,
+                            streamingCompleted
+                        );
                         lastPart = itemPart;
                     }
                 }
             }
             return lastPart ?? this.renderNoContent(other => content.kind === other.kind);
-        }
-        else {
+        } else {
             const lastActiveThinking = this.getLastThinkingPart(templateData.renderedParts);
             if (lastActiveThinking) {
-                lastActiveThinking.setupThinkingContainer(content, context);
+                lastActiveThinking.setupThinkingContainer(content);
                 return lastActiveThinking;
-            }
-            else {
-                const part = templateData.instantiationService.createInstance(ChatThinkingContentPart, content, context, this.chatContentMarkdownRenderer);
-                part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
+            } else {
+                const part = templateData.instantiationService.createInstance(
+                    ChatThinkingContentPart,
+                    content,
+                    context,
+                    this.chatContentMarkdownRenderer,
+                    streamingCompleted
+                );
                 return part;
             }
         }
     }
     disposeElement(node, index, templateData, details) {
-        this.traceLayout('disposeElement', `Disposing element, index=${index}`);
+        this.traceLayout("disposeElement", `Disposing element, index=${index}`);
         templateData.elementDisposables.clear();
         if (templateData.currentElement && !this.viewModel?.editing) {
             this.templateDataByRequestId.delete(templateData.currentElement.id);
@@ -1429,46 +1954,31 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             templateData.titleToolbar.context = undefined;
         }
         templateData.footerToolbar.context = undefined;
+        templateData.checkpointToolbar.context = undefined;
+        templateData.checkpointRestoreToolbar.context = undefined;
     }
     renderMcpServersInteractionRequired(content, context, templateData) {
         return this.instantiationService.createInstance(ChatMcpServersInteractionContentPart, content, context);
     }
     disposeTemplate(templateData) {
+        this.clearRenderedParts(templateData);
         templateData.templateDisposables.dispose();
     }
     hoverVisible(requestHover) {
-        requestHover.style.opacity = '1';
+        requestHover.style.opacity = "1";
     }
     hoverHidden(requestHover) {
-        requestHover.style.opacity = '0';
+        requestHover.style.opacity = "0";
     }
 };
-ChatListItemRenderer = ChatListItemRenderer_1 = ( __decorate([
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, IThemeService)),
-    ( __param(11, ICommandService)),
-    ( __param(12, IHoverService)),
-    ( __param(13, IChatWidgetService)),
-    ( __param(14, IChatEntitlementService))
-], ChatListItemRenderer));
-let ChatListDelegate = class ChatListDelegate {
-    constructor(defaultElementHeight, logService) {
+ChatListItemRenderer = ChatListItemRenderer_1 = ( __decorate([( __param(6, IInstantiationService)), ( __param(7, IConfigurationService)), ( __param(8, ILogService)), ( __param(9, IContextKeyService)), ( __param(10, IThemeService)), ( __param(11, ICommandService)), ( __param(12, IHoverService)), ( __param(13, IChatWidgetService)), ( __param(14, IChatEntitlementService)), ( __param(15, IChatService)), ( __param(16, IChatTipService))], ChatListItemRenderer));
+class ChatListDelegate extends CachedListVirtualDelegate {
+    constructor(defaultElementHeight) {
+        super();
         this.defaultElementHeight = defaultElementHeight;
-        this.logService = logService;
     }
-    _traceLayout(method, message) {
-        {
-            this.logService.trace(`ChatListDelegate#${method}: ${message}`);
-        }
-    }
-    getHeight(element) {
-        const kind = isRequestVM(element) ? 'request' : 'response';
-        const height = element.currentRenderedHeight ?? this.defaultElementHeight;
-        this._traceLayout('getHeight', `${kind}, height=${height}`);
-        return height;
+    estimateHeight(element) {
+        return element.currentRenderedHeight ?? this.defaultElementHeight;
     }
     getTemplateId(element) {
         return ChatListItemRenderer.ID;
@@ -1476,26 +1986,32 @@ let ChatListDelegate = class ChatListDelegate {
     hasDynamicHeight(element) {
         return true;
     }
-};
-ChatListDelegate = ( __decorate([
-    ( __param(1, ILogService))
-], ChatListDelegate));
+}
 const voteDownDetailLabels = {
-    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(5782, "Suggested incorrect code")),
-    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(5783, "Didn't follow instructions")),
-    [ChatAgentVoteDownReason.MissingContext]: ( localize(5784, "Missing context")),
-    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(5785, "Offensive or unsafe")),
-    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(5786, "Poorly written or formatted")),
-    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(5787, "Refused a valid request")),
-    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(5788, "Incomplete code")),
-    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(5789, "Report an issue")),
-    [ChatAgentVoteDownReason.Other]: ( localize(5790, "Other")),
+    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(6038, "Suggested incorrect code")),
+    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(6039, "Didn't follow instructions")),
+    [ChatAgentVoteDownReason.MissingContext]: ( localize(6040, "Missing context")),
+    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(6041, "Offensive or unsafe")),
+    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(6042, "Poorly written or formatted")),
+    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(6043, "Refused a valid request")),
+    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(6044, "Incomplete code")),
+    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(6045, "Report an issue")),
+    [ChatAgentVoteDownReason.Other]: ( localize(6046, "Other"))
 };
 let ChatVoteDownButton = class ChatVoteDownButton extends DropdownMenuActionViewItem {
-    constructor(action, options, commandService, issueService, logService, contextMenuService) {
-        super(action, { getActions: () => this.getActions(), }, contextMenuService, {
+    constructor(
+        action,
+        options,
+        commandService,
+        issueService,
+        logService,
+        contextMenuService
+    ) {
+        super(action, {
+            getActions: () => this.getActions()
+        }, contextMenuService, {
             ...options,
-            classNames: ThemeIcon.asClassNameArray(Codicon.thumbsdown),
+            classNames: ThemeIcon.asClassNameArray(Codicon.thumbsdown)
         });
         this.commandService = commandService;
         this.issueService = issueService;
@@ -1512,38 +2028,40 @@ let ChatVoteDownButton = class ChatVoteDownButton extends DropdownMenuActionView
             this.getVoteDownDetailAction(ChatAgentVoteDownReason.OffensiveOrUnsafe),
             this.getVoteDownDetailAction(ChatAgentVoteDownReason.Other),
             {
-                id: 'reportIssue',
+                id: "reportIssue",
                 label: voteDownDetailLabels[ChatAgentVoteDownReason.WillReportIssue],
-                tooltip: '',
+                tooltip: "",
                 enabled: true,
                 class: undefined,
-                run: async (context) => {
+                run: async context => {
                     if (!isResponseVM(context)) {
-                        this.logService.error('ChatVoteDownButton#run: invalid context');
+                        this.logService.error("ChatVoteDownButton#run: invalid context");
                         return;
                     }
                     await this.commandService.executeCommand(MarkUnhelpfulActionId, context, ChatAgentVoteDownReason.WillReportIssue);
-                    await this.issueService.openReporter({ extensionId: context.agent?.extensionId.value });
+                    await this.issueService.openReporter({
+                        extensionId: context.agent?.extensionId.value
+                    });
                 }
             }
         ];
     }
     render(container) {
         super.render(container);
-        this.element?.classList.toggle('checked', this.action.checked);
+        this.element?.classList.toggle("checked", this.action.checked);
     }
     getVoteDownDetailAction(reason) {
         const label = voteDownDetailLabels[reason];
         return {
             id: MarkUnhelpfulActionId,
             label,
-            tooltip: '',
+            tooltip: "",
             enabled: true,
             checked: this._context.voteDownReason === reason,
             class: undefined,
-            run: async (context) => {
+            run: async context => {
                 if (!isResponseVM(context)) {
-                    this.logService.error('ChatVoteDownButton#getVoteDownDetailAction: invalid context');
+                    this.logService.error("ChatVoteDownButton#getVoteDownDetailAction: invalid context");
                     return;
                 }
                 await this.commandService.executeCommand(MarkUnhelpfulActionId, context, reason);
@@ -1551,11 +2069,6 @@ let ChatVoteDownButton = class ChatVoteDownButton extends DropdownMenuActionView
         };
     }
 };
-ChatVoteDownButton = ( __decorate([
-    ( __param(2, ICommandService)),
-    ( __param(3, IWorkbenchIssueService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IContextMenuService))
-], ChatVoteDownButton));
+ChatVoteDownButton = ( __decorate([( __param(2, ICommandService)), ( __param(3, IWorkbenchIssueService)), ( __param(4, ILogService)), ( __param(5, IContextMenuService))], ChatVoteDownButton));
 
 export { ChatListDelegate, ChatListItemRenderer, ChatVoteDownButton };