@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,1573 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+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 { 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 { 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';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { canceledName } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore, dispose, toDisposable, thenIfNotDisposed } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { FileAccess, Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { createActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isDark } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/theme';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+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/annotations';
+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/chatContextKeys';
+import { chatSubcommandLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatAgentVoteDirection, IChatToolInvocation, isChatFollowup, ChatErrorLevel, ChatAgentVoteDownReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { isResponseVM, isRequestVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { getNWords } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatWordCounter';
+import { CodeBlockModelCollection } from '../common/codeBlockModelCollection.js';
+import { ChatAgentLocation, ChatConfiguration, CollapsedToolsDisplayMode, ThinkingDisplayMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+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/chatUri';
+import { MarkUnhelpfulActionId } from './actions/chatTitleActions.js';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatAgentHover, getChatAgentHoverOptions } from './chatAgentHover.js';
+import { ChatContentMarkdownRenderer } from './chatContentMarkdownRenderer.js';
+import { ChatAgentCommandContentPart } from './chatContentParts/chatAgentCommandContentPart.js';
+import { ChatAnonymousRateLimitedPart } from './chatContentParts/chatAnonymousRateLimitedPart.js';
+import { ChatAttachmentsContentPart } from './chatContentParts/chatAttachmentsContentPart.js';
+import { ChatCheckpointFileChangesSummaryContentPart } from './chatContentParts/chatChangesSummaryPart.js';
+import { ChatCodeCitationContentPart } from './chatContentParts/chatCodeCitationContentPart.js';
+import { ChatCommandButtonContentPart } from './chatContentParts/chatCommandContentPart.js';
+import { ChatConfirmationContentPart } from './chatContentParts/chatConfirmationContentPart.js';
+import { EditorPool, DiffEditorPool } from './chatContentParts/chatContentCodePools.js';
+import { ChatElicitationContentPart } from './chatContentParts/chatElicitationContentPart.js';
+import { ChatErrorConfirmationContentPart } from './chatContentParts/chatErrorConfirmationPart.js';
+import { ChatErrorContentPart } from './chatContentParts/chatErrorContentPart.js';
+import { ChatExtensionsContentPart } from './chatContentParts/chatExtensionsContentPart.js';
+import { ChatMarkdownContentPart } from './chatContentParts/chatMarkdownContentPart.js';
+import { ChatMcpServersInteractionContentPart } from './chatContentParts/chatMcpServersInteractionContentPart.js';
+import { ChatMultiDiffContentPart } from './chatContentParts/chatMultiDiffContentPart.js';
+import { ChatWorkingProgressContentPart, ChatProgressContentPart } from './chatContentParts/chatProgressContentPart.js';
+import { ChatPullRequestContentPart } from './chatContentParts/chatPullRequestContentPart.js';
+import { ChatQuotaExceededPart } from './chatContentParts/chatQuotaExceededPart.js';
+import { CollapsibleListPool, ChatUsedReferencesListContentPart } from './chatContentParts/chatReferencesContentPart.js';
+import { ChatTaskContentPart } from './chatContentParts/chatTaskContentPart.js';
+import { ChatTextEditContentPart } from './chatContentParts/chatTextEditContentPart.js';
+import { ChatThinkingContentPart } from './chatContentParts/chatThinkingContentPart.js';
+import { TreePool, ChatTreeContentPart } from './chatContentParts/chatTreeContentPart.js';
+import * as chatMcpServersInteractionContent from './chatContentParts/media/chatMcpServersInteractionContent.css';
+import { ChatToolInvocationPart } from './chatContentParts/toolInvocationParts/chatToolInvocationPart.js';
+import { ChatMarkdownDecorationsRenderer } from './chatMarkdownDecorationsRenderer.js';
+import { ChatCodeBlockContentProvider } from './codeBlockPart.js';
+
+var ChatListItemRenderer_1;
+registerCss(chatMcpServersInteractionContent);
+const $ = $$1;
+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) {
+        super();
+        this.rendererOptions = rendererOptions;
+        this.delegate = delegate;
+        this.codeBlockModelCollection = codeBlockModelCollection;
+        this.viewModel = viewModel;
+        this.instantiationService = instantiationService;
+        this.configService = configService;
+        this.logService = logService;
+        this.contextKeyService = contextKeyService;
+        this.themeService = themeService;
+        this.commandService = commandService;
+        this.hoverService = hoverService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.codeBlocksByResponseId = ( new Map());
+        this.codeBlocksByEditorUri = ( new ResourceMap());
+        this.fileTreesByResponseId = ( new Map());
+        this.focusedFileTreesByResponseId = ( new Map());
+        this.templateDataByRequestId = ( new Map());
+        this._onDidClickFollowup = this._register(( new Emitter()));
+        this.onDidClickFollowup = this._onDidClickFollowup.event;
+        this._onDidClickRerunWithAgentOrCommandDetection = ( new Emitter());
+        this.onDidClickRerunWithAgentOrCommandDetection = this._onDidClickRerunWithAgentOrCommandDetection.event;
+        this._onDidClickRequest = this._register(( new Emitter()));
+        this.onDidClickRequest = this._onDidClickRequest.event;
+        this._onDidRerender = this._register(( new Emitter()));
+        this.onDidRerender = this._onDidRerender.event;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._onDidFocusOutside = this._register(( new Emitter()));
+        this.onDidFocusOutside = this._onDidFocusOutside.event;
+        this._onDidChangeItemHeight = this._register(( new Emitter()));
+        this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
+        this._currentLayoutWidth = 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._register(this.instantiationService.createInstance(ChatCodeBlockContentProvider));
+        this._toolInvocationCodeBlockCollection = this._register(this.instantiationService.createInstance(CodeBlockModelCollection, 'tools'));
+    }
+    updateOptions(options) {
+        this.rendererOptions = { ...this.rendererOptions, ...options };
+    }
+    get templateId() {
+        return ChatListItemRenderer_1.ID;
+    }
+    editorsInUse() {
+        return Iterable.concat(this._editorPool.inUse(), this._toolEditorPool.inUse());
+    }
+    traceLayout(method, message) {
+        {
+            this.logService.trace(`ChatListItemRenderer#${method}: ${message}`);
+        }
+    }
+    getProgressiveRenderRate(element) {
+        let 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') {
+                return clamp(rate, minAfterComplete, Rate.Max);
+            }
+            else {
+                return minAfterComplete;
+            }
+        }
+        if (typeof rate === 'number') {
+            return clamp(rate, Rate.Min, Rate.Max);
+        }
+        return 8;
+    }
+    getCodeBlockInfosForResponse(response) {
+        const codeBlocks = this.codeBlocksByResponseId.get(response.id);
+        return codeBlocks ?? [];
+    }
+    updateViewModel(viewModel) {
+        this.viewModel = viewModel;
+        this._announcedToolProgressKeys.clear();
+    }
+    getCodeBlockInfoForEditor(uri) {
+        return this.codeBlocksByEditorUri.get(uri);
+    }
+    getFileTreeInfosForResponse(response) {
+        const fileTrees = this.fileTreesByResponseId.get(response.id);
+        return fileTrees ?? [];
+    }
+    getLastFocusedFileTreeForResponse(response) {
+        const fileTrees = this.fileTreesByResponseId.get(response.id);
+        const lastFocusedFileTreeIndex = this.focusedFileTreesByResponseId.get(response.id);
+        if (fileTrees?.length && lastFocusedFileTreeIndex !== undefined && lastFocusedFileTreeIndex < fileTrees.length) {
+            return fileTrees[lastFocusedFileTreeIndex];
+        }
+        return undefined;
+    }
+    getTemplateDataForRequestId(requestId) {
+        if (!requestId) {
+            return undefined;
+        }
+        const templateData = this.templateDataByRequestId.get(requestId);
+        if (templateData && templateData.currentElement?.id === requestId) {
+            return templateData;
+        }
+        if (templateData) {
+            this.templateDataByRequestId.delete(requestId);
+        }
+        return undefined;
+    }
+    setVisible(visible) {
+        this._isVisible = visible;
+        this._onDidChangeVisibility.fire(visible);
+    }
+    layout(width) {
+        const newWidth = width - 40;
+        if (newWidth !== this._currentLayoutWidth) {
+            this._currentLayoutWidth = newWidth;
+            for (const editor of this._editorPool.inUse()) {
+                editor.layout(this._currentLayoutWidth);
+            }
+            for (const toolEditor of this._toolEditorPool.inUse()) {
+                toolEditor.layout(this._currentLayoutWidth);
+            }
+            for (const diffEditor of this._diffEditorPool.inUse()) {
+                diffEditor.layout(this._currentLayoutWidth);
+            }
+        }
+    }
+    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');
+        }
+        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'));
+            headerParent = lhsContainer;
+            detailContainerParent = rhsContainer;
+            valueParent = rhsContainer;
+        }
+        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'));
+        let titleToolbar;
+        if (this.rendererOptions.noHeader) {
+            header.classList.add('hidden');
+        }
+        else {
+            titleToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, requestHover, MenuId.ChatMessageTitle, {
+                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'));
+        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'));
+        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);
+                }
+                return createActionViewItem(scopedInstantiationService, action, options);
+            }
+        }));
+        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(5326, '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
+            },
+        }));
+        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) {
+                agentHover.setAgent(template.currentElement.agent.id);
+                return agentHover.domNode;
+            }
+            return undefined;
+        };
+        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);
+                }
+            }
+            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 };
+        templateDisposables.add(addDisposableListener(disabledOverlay, EventType.CLICK, e => {
+            if (!this.viewModel?.editing) {
+                return;
+            }
+            const current = template.currentElement;
+            if (!current || current.id === this.viewModel.editing.id) {
+                return;
+            }
+            if (disabledOverlay.classList.contains('disabled')) {
+                e.preventDefault();
+                e.stopPropagation();
+                this._onDidFocusOutside.fire();
+            }
+        }));
+        return template;
+    }
+    renderElement(node, index, templateData) {
+        this.renderChatTreeItem(node.element, index, templateData);
+    }
+    clearRenderedParts(templateData) {
+        if (templateData.renderedParts) {
+            dispose(coalesce(templateData.renderedParts));
+            templateData.renderedParts = undefined;
+            clearNode(templateData.value);
+        }
+    }
+    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);
+            const mappedTemplateData = this.templateDataByRequestId.get(templateData.currentElement.id);
+            if (mappedTemplateData && (mappedTemplateData.currentElement?.id !== templateData.currentElement.id)) {
+                this.templateDataByRequestId.delete(templateData.currentElement.id);
+            }
+        }
+        templateData.currentElement = element;
+        this.templateDataByRequestId.set(element.id, templateData);
+        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('');
+        }
+        if (templateData.titleToolbar) {
+            templateData.titleToolbar.context = element;
+        }
+        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');
+        }
+        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);
+        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);
+        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 shouldShowRestore = this.viewModel?.model.checkpoint && !this.viewModel?.editing && (index === this.delegate.getListLength() - 1);
+        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();
+            }
+        }));
+        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);
+        const shouldShowHeader = isResponseVM(element) && !this.rendererOptions.noHeader;
+        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}`);
+            const timer = templateData.elementDisposables.add(new WindowIntervalTimer());
+            const runProgressiveRender = (initial) => {
+                try {
+                    if (this.doNextProgressiveRender(element, index, templateData, !!initial)) {
+                        timer.cancel();
+                    }
+                }
+                catch (err) {
+                    timer.cancel();
+                    this.logService.error(err);
+                }
+            };
+            timer.cancelAndSet(runProgressiveRender, 50, getWindow(templateData.rowContainer));
+            runProgressiveRender(true);
+        }
+        else {
+            if (isResponseVM(element)) {
+                this.renderChatResponseBasic(element, index, templateData);
+            }
+            else if (isRequestVM(element)) {
+                this.renderChatRequest(element, index, templateData);
+            }
+        }
+    }
+    renderDetail(element, templateData) {
+        clearNode(templateData.detail);
+        if (element.agentOrSlashCommandDetected) {
+            const msg = element.slashCommand ? ( localize(
+                5327,
+                "used {0} [[(rerun without)]]",
+                `${chatSubcommandLeader}${element.slashCommand.name}`
+            )) : ( localize(5328, "[[(rerun without)]]"));
+            reset(templateData.detail, renderFormattedText(msg, {
+                actionHandler: {
+                    disposables: templateData.elementDisposables,
+                    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(5329, "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(5330, '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);
+        if (icon instanceof URI) {
+            const avatarIcon = $$1('img.icon');
+            avatarIcon.src = ( FileAccess.uriToBrowserUri(icon).toString(true));
+            templateData.avatarContainer.replaceChildren($$1('.avatar', undefined, avatarIcon));
+        }
+        else {
+            const avatarIcon = $$1(ThemeIcon.asCSSSelector(icon));
+            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)) {
+            return agent.iconDark;
+        }
+        else if (agent?.icon) {
+            return agent.icon;
+        }
+        else {
+            return Codicon.chatSparkle;
+        }
+    }
+    renderChatResponseBasic(element, index, templateData) {
+        templateData.rowContainer.classList.toggle('chat-response-loading', (isResponseVM(element) && !element.isComplete));
+        if (element.isCanceled) {
+            const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+            if (lastThinking?.domNode) {
+                lastThinking.finalizeTitleIfDefault();
+                lastThinking.markAsInactive();
+            }
+        }
+        const content = [];
+        const isFiltered = !!element.errorDetails?.responseIsFiltered;
+        if (!isFiltered) {
+            content.push({ kind: 'references', references: element.contentReferences });
+            content.push(...annotateSpecialMarkdownContent(element.response.value));
+            if (element.codeCitations.length) {
+                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 });
+        }
+        const fileChangesSummaryPart = this.getChatFileChangesSummaryPart(element);
+        if (fileChangesSummaryPart) {
+            content.push(fileChangesSummaryPart);
+        }
+        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)) {
+            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 (!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') {
+            return true;
+        }
+        return false;
+    }
+    getChatFileChangesSummaryPart(element) {
+        if (!this.shouldShowFileChangesSummary(element)) {
+            return undefined;
+        }
+        const consideredFiles = ( new Set());
+        const fileChanges = [];
+        for (const part of element.model.entireResponse.value) {
+            if ((part.kind === 'textEditGroup' || part.kind === 'notebookEditGroup') && !( consideredFiles.has(( part.uri.toString(true))))) {
+                fileChanges.push({
+                    kind: 'changesSummary',
+                    reference: part.uri,
+                    sessionId: element.sessionId,
+                    requestId: element.requestId,
+                });
+                consideredFiles.add(( part.uri.toString(true)));
+            }
+        }
+        if (!fileChanges.length) {
+            return undefined;
+        }
+        return { kind: 'changesSummary', fileChanges };
+    }
+    renderChatRequest(element, index, templateData) {
+        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);
+                    }
+                }
+            }));
+        }
+        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');
+            }
+        }
+        clearNode(templateData.value);
+        const parts = [];
+        let inlineSlashCommandRendered = false;
+        content.forEach((data, contentIndex) => {
+            const context = {
+                element,
+                elementIndex: index,
+                contentIndex: contentIndex,
+                content: content,
+                preceedingContentParts: parts,
+                container: templateData.rowContainer,
+                editorPool: this._editorPool,
+                diffEditorPool: this._diffEditorPool,
+                codeBlockModelCollection: this.codeBlockModelCollection,
+                currentWidth: () => this._currentLayoutWidth,
+                get codeBlockStartIndex() {
+                    return context.preceedingContentParts.reduce((acc, part) => acc + (part.codeblocks?.length ?? 0), 0);
+                },
+            };
+            const newPart = this.renderChatContentPart(data, templateData, context);
+            if (newPart) {
+                if (this.rendererOptions.renderDetectedCommandsWithRequest
+                    && !inlineSlashCommandRendered
+                    && element.agentOrSlashCommandDetected && element.slashCommand
+                    && data.kind === 'markdownContent'
+                ) {
+                    if (newPart.domNode) {
+                        newPart.domNode.style.display = 'inline-flex';
+                    }
+                    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;
+                }
+                if (newPart.domNode) {
+                    templateData.value.appendChild(newPart.domNode);
+                }
+                parts.push(newPart);
+            }
+        });
+        if (templateData.renderedParts) {
+            dispose(templateData.renderedParts);
+        }
+        templateData.renderedParts = parts;
+        if (element.variables.length) {
+            const newPart = this.renderAttachments(element.variables, element.contentReferences, templateData);
+            if (newPart.domNode) {
+                templateData.value.appendChild(newPart.domNode);
+            }
+            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), () => {
+                element.currentRenderedHeight = templateData.rowContainer.offsetHeight;
+                disposable.dispose();
+                this._onDidChangeItemHeight.fire({ element, height: element.currentRenderedHeight });
+            }));
+        }
+    }
+    updateItemHeight(templateData) {
+        if (!templateData.currentElement) {
+            return;
+        }
+        const newHeight = Math.max(templateData.rowContainer.offsetHeight, 1);
+        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}`);
+            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)}`);
+        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');
+                return false;
+            }
+            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;
+                }
+                return true;
+            }
+        }
+        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) => {
+            if (!partToRender) {
+                return;
+            }
+            const alreadyRenderedPart = templateData.renderedParts?.[contentIndex];
+            if (alreadyRenderedPart) {
+                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)) {
+                    renderedParts[contentIndex] = alreadyRenderedPart;
+                    return;
+                }
+                alreadyRenderedPart.dispose();
+            }
+            const preceedingContentParts = renderedParts.slice(0, contentIndex);
+            const context = {
+                element,
+                elementIndex: elementIndex,
+                content: contentForThisTurn,
+                preceedingContentParts,
+                contentIndex: contentIndex,
+                container: templateData.rowContainer,
+                editorPool: this._editorPool,
+                diffEditorPool: this._diffEditorPool,
+                codeBlockModelCollection: this.codeBlockModelCollection,
+                currentWidth: () => this._currentLayoutWidth,
+                get codeBlockStartIndex() {
+                    return context.preceedingContentParts.reduce((acc, part) => acc + (part.codeblocks?.length ?? 0), 0);
+                },
+            };
+            const lastThinking = this.getLastThinkingPart(renderedParts);
+            if (lastThinking && (partToRender.kind === 'toolInvocation' || partToRender.kind === 'toolInvocationSerialized') && this.shouldPinPart(partToRender, element)) {
+                const newPart = this.renderChatContentPart(partToRender, templateData, context);
+                if (newPart) {
+                    renderedParts[contentIndex] = newPart;
+                    if (alreadyRenderedPart instanceof ChatWorkingProgressContentPart && alreadyRenderedPart?.domNode) {
+                        alreadyRenderedPart.domNode.remove();
+                    }
+                }
+                return;
+            }
+            const newPart = this.renderChatContentPart(partToRender, templateData, context);
+            if (newPart) {
+                renderedParts[contentIndex] = newPart;
+                try {
+                    if (alreadyRenderedPart?.domNode) {
+                        if (newPart.domNode) {
+                            alreadyRenderedPart.domNode.replaceWith(newPart.domNode);
+                        }
+                        else {
+                            alreadyRenderedPart.domNode.remove();
+                        }
+                    }
+                    else if (newPart.domNode && !newPart.domNode.parentElement) {
+                        templateData.value.appendChild(newPart.domNode);
+                    }
+                }
+                catch (err) {
+                    this.logService.error('ChatListItemRenderer#renderChatContentDiff: error replacing part', err);
+                }
+            }
+            else {
+                alreadyRenderedPart?.domNode?.remove();
+            }
+        });
+        for (let i = partsToRender.length; i < renderedParts.length; i++) {
+            const part = renderedParts[i];
+            if (part) {
+                part.dispose();
+                part.domNode?.remove();
+                delete renderedParts[i];
+            }
+        }
+    }
+    getNextProgressiveRenderContent(element, templateData) {
+        const data = this.getDataForProgressiveRender(element);
+        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...`);
+        let numNeededWords = data.numWordsToRender;
+        const partsToRender = [];
+        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) {
+                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}`);
+                numNeededWords -= wordCountResult.returnedWordCount;
+                if (wordCountResult.isFullString) {
+                    partsToRender.push(part);
+                    for (const nextPart of renderableResponse.slice(i + 1)) {
+                        if (nextPart.kind !== 'markdownContent') {
+                            i++;
+                            partsToRender.push(nextPart);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+                else {
+                    moreContentAvailable = true;
+                    partsToRender.push({ ...part, content: ( new MarkdownString(wordCountResult.value, part.content)) });
+                }
+                if (numNeededWords <= 0) {
+                    if (( renderableResponse.slice(i + 1).some(part => part.kind === 'markdownContent'))) {
+                        moreContentAvailable = true;
+                    }
+                    break;
+                }
+            }
+            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`);
+        if (newRenderedWordCount > 0 && newRenderedWordCount !== element.renderData?.renderedWordCount) {
+            element.renderData = { lastRenderTime: Date.now(), renderedWordCount: newRenderedWordCount, renderedParts: partsToRender };
+        }
+        if (this.shouldShowWorkingProgress(element, partsToRender, templateData)) {
+            partsToRender.push({ kind: 'working' });
+        }
+        const fileChangesSummaryPart = this.getChatFileChangesSummaryPart(element);
+        if (fileChangesSummaryPart) {
+            partsToRender.push(fileChangesSummaryPart);
+        }
+        return { content: partsToRender, moreContentAvailable };
+    }
+    shouldShowFileChangesSummary(element) {
+        const isLocalSession = getChatSessionType(element.sessionResource) === localChatSessionType;
+        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
+        ));
+        if (!element.isComplete && hasMarkdownParts && (element.contentUpdateTimings ? element.contentUpdateTimings.lastWordCount : 0) === 0) {
+            return {
+                numWordsToRender: Number.MAX_SAFE_INTEGER,
+                rate: Number.MAX_SAFE_INTEGER
+            };
+        }
+        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);
+        return {
+            numWordsToRender,
+            rate
+        };
+    }
+    diff(renderedParts, contentToRender, element) {
+        const diff = [];
+        for (let i = 0; i < contentToRender.length; i++) {
+            const content = contentToRender[i];
+            const renderedPart = renderedParts[i];
+            if (!renderedPart || !renderedPart.hasSameContent(content, contentToRender.slice(i + 1), element)) {
+                diff.push(content);
+            }
+            else {
+                diff.push(null);
+            }
+        }
+        return diff;
+    }
+    shouldPinPart(part, element) {
+        const collapsedToolsMode = this.configService.getValue('chat.agent.thinking.collapsedTools');
+        if (collapsedToolsMode === CollapsedToolsDisplayMode.Off) {
+            return false;
+        }
+        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) {
+            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) {
+            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')) {
+            return false;
+        }
+        const containsCreate = (value) => {
+            if (!value) {
+                return false;
+            }
+            const text = typeof value === 'string' ? value : value.value;
+            return text.toLowerCase().includes('create');
+        };
+        if (containsCreate(content.invocationMessage) || containsCreate(content.pastTenseMessage)) {
+            return true;
+        }
+        return content.toolId.toLowerCase().includes('create');
+    }
+    getLastThinkingPart(renderedParts) {
+        if (!renderedParts || renderedParts.length === 0) {
+            return undefined;
+        }
+        for (let i = renderedParts.length - 1; i >= 0; i--) {
+            const part = renderedParts[i];
+            if (part instanceof ChatThinkingContentPart && part.getIsActive()) {
+                return part;
+            }
+        }
+        return undefined;
+    }
+    finalizeCurrentThinkingPart(context, templateData) {
+        const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+        if (!lastThinking) {
+            return;
+        }
+        const style = this.configService.getValue('chat.agent.thinkingStyle');
+        if (style === ThinkingDisplayMode.CollapsedPreview) {
+            lastThinking.collapseContent();
+        }
+        lastThinking.finalizeTitleIfDefault();
+        lastThinking.resetId();
+        lastThinking.markAsInactive();
+    }
+    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)) {
+                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)) {
+                for (const templateData of ( this.templateDataByRequestId.values())) {
+                    if (templateData.renderedParts) {
+                        const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+                        if (content.kind !== 'textEditGroup' && lastThinking?.getIsActive()) {
+                            this.finalizeCurrentThinkingPart(context, templateData);
+                        }
+                    }
+                }
+            }
+            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') {
+                return this.renderProgressTask(content, templateData, context);
+            }
+            else if (content.kind === 'command') {
+                return this.instantiationService.createInstance(ChatCommandButtonContentPart, content, context);
+            }
+            else if (content.kind === 'textEditGroup') {
+                return this.renderTextEdit(context, content, templateData);
+            }
+            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') {
+                return this.renderMarkdown(content, templateData, context);
+            }
+            else if (content.kind === 'references') {
+                return this.renderContentReferencesListData(content, undefined, context, templateData);
+            }
+            else if (content.kind === 'codeCitations') {
+                return this.renderCodeCitations(content, context, templateData);
+            }
+            else if (content.kind === 'toolInvocation' || content.kind === 'toolInvocationSerialized') {
+                return this.renderToolInvocation(content, context, templateData);
+            }
+            else if (content.kind === 'extensions') {
+                return this.renderExtensionsContent(content, context, templateData);
+            }
+            else if (content.kind === 'pullRequest') {
+                return this.renderPullRequestContent(content, context, templateData);
+            }
+            else if (content.kind === 'undoStop') {
+                return this.renderUndoStop(content);
+            }
+            else if (content.kind === 'errorDetails') {
+                return this.renderChatErrorDetails(context, content, templateData);
+            }
+            else if (content.kind === 'elicitation2' || content.kind === 'elicitationSerialized') {
+                return this.renderElicitation(context, content, templateData);
+            }
+            else if (content.kind === 'changesSummary') {
+                return this.renderChangesSummary(content, context, templateData);
+            }
+            else if (content.kind === 'mcpServersStarting') {
+                return this.renderMcpServersInteractionRequired(content, context, templateData);
+            }
+            else if (content.kind === 'thinking') {
+                return this.renderThinkingPart(content, context, templateData);
+            }
+            return this.renderNoContent(other => content.kind === other.kind);
+        }
+        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(5331, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
+            return {
+                dispose: () => errorPart.dispose(),
+                domNode: errorPart.domNode,
+                hasSameContent: (other => content.kind === other.kind),
+            };
+        }
+    }
+    dispose() {
+        this._announcedToolProgressKeys.clear();
+        super.dispose();
+    }
+    renderChatErrorDetails(context, content, templateData) {
+        if (!isResponseVM(context.element)) {
+            return this.renderNoContent(other => content.kind === other.kind);
+        }
+        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)));
+            return renderedError;
+        }
+        else if (content.errorDetails.isRateLimited && this.chatEntitlementService.anonymous) {
+            const renderedError = this.instantiationService.createInstance(ChatAnonymousRateLimitedPart, content);
+            return renderedError;
+        }
+        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 {
+            const level = content.errorDetails.level ?? ChatErrorLevel.Error;
+            return this.instantiationService.createInstance(ChatErrorContentPart, level, ( new MarkdownString(content.errorDetails.message)), content, this.chatContentMarkdownRenderer);
+        }
+    }
+    renderUndoStop(content) {
+        return this.renderNoContent(other => other.kind === content.kind && other.id === content.id);
+    }
+    renderNoContent(equals) {
+        return {
+            dispose: () => { },
+            domNode: undefined,
+            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);
+        }));
+        if (isResponseVM(context.element)) {
+            const fileTreeFocusInfo = {
+                treeDataId: ( data.uri.toString()),
+                treeIndex: treeDataIndex,
+                focus() {
+                    treePart.domFocus();
+                }
+            };
+            treePart.addDisposable(treePart.onDidFocus(() => {
+                this.focusedFileTreesByResponseId.set(context.element.id, fileTreeFocusInfo.treeIndex);
+            }));
+            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())))));
+        }
+        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);
+        }));
+        return referencesPart;
+    }
+    renderCodeCitations(citations, context, templateData) {
+        const citationsPart = this.instantiationService.createInstance(ChatCodeCitationContentPart, citations, context);
+        return citationsPart;
+    }
+    handleRenderedCodeblocks(element, part, codeBlockStartIndex) {
+        if (!part.addDisposable || part.codeblocksPartId === undefined) {
+            return;
+        }
+        const codeBlocksByResponseId = this.codeBlocksByResponseId.get(element.id) ?? [];
+        this.codeBlocksByResponseId.set(element.id, codeBlocksByResponseId);
+        part.addDisposable(toDisposable(() => {
+            const codeBlocksByResponseId = this.codeBlocksByResponseId.get(element.id);
+            if (codeBlocksByResponseId) {
+                part.codeblocks?.forEach((info, i) => {
+                    const codeblock = codeBlocksByResponseId[codeBlockStartIndex + i];
+                    if (codeblock?.ownerMarkdownPartId === part.codeblocksPartId) {
+                        delete codeBlocksByResponseId[codeBlockStartIndex + i];
+                    }
+                });
+            }
+        }));
+        part.codeblocks?.forEach((info, i) => {
+            codeBlocksByResponseId[codeBlockStartIndex + i] = info;
+            part.addDisposable(thenIfNotDisposed(info.uriPromise, uri => {
+                if (!uri) {
+                    return;
+                }
+                this.codeBlocksByEditorUri.set(uri, info);
+                part.addDisposable(toDisposable(() => {
+                    const codeblock = this.codeBlocksByEditorUri.get(uri);
+                    if (codeblock?.ownerMarkdownPartId === part.codeblocksPartId) {
+                        this.codeBlocksByEditorUri.delete(uri);
+                    }
+                }));
+            }));
+        });
+    }
+    renderToolInvocation(toolInvocation, 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');
+        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) {
+                const thinkingPart = this.renderThinkingPart({
+                    kind: 'thinking',
+                }, context, templateData);
+                if (thinkingPart instanceof ChatThinkingContentPart) {
+                    thinkingPart.appendItem(part?.domNode, toolInvocation.toolId, toolInvocation);
+                    thinkingPart.addDisposable(part);
+                    thinkingPart.addDisposable(thinkingPart.onDidChangeHeight(() => {
+                        this.updateItemHeight(templateData);
+                    }));
+                }
+                return thinkingPart;
+            }
+            if (this.shouldPinPart(toolInvocation, context.element)) {
+                if (lastThinking && part?.domNode && toolInvocation.presentation !== 'hidden') {
+                    lastThinking.appendItem(part?.domNode, toolInvocation.toolId, toolInvocation);
+                    lastThinking.addDisposable(part);
+                }
+            }
+            else {
+                this.finalizeCurrentThinkingPart(context, templateData);
+            }
+        }
+        return part;
+    }
+    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);
+        }));
+        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()) {
+            return this.renderNoContent(other => elicitation.kind === other.kind);
+        }
+        const part = this.instantiationService.createInstance(ChatElicitationContentPart, elicitation, context);
+        part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
+        return 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) {
+        return this.instantiationService.createInstance(ChatAttachmentsContentPart, {
+            variables,
+            contentReferences,
+            domNode: undefined
+        });
+    }
+    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);
+        }));
+        return textEditPart;
+    }
+    renderMarkdown(markdown, templateData, context) {
+        this.finalizeCurrentThinkingPart(context, templateData);
+        const element = context.element;
+        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, {});
+        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) {
+                            return;
+                        }
+                    }
+                    e.preventDefault();
+                    e.stopPropagation();
+                    this._onDidClickRequest.fire(templateData);
+                }));
+                this._register(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), markdownPart.domNode, ( localize(5332, "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);
+        return markdownPart;
+    }
+    renderThinkingPart(content, context, templateData) {
+        if (!content.id) {
+            content.id = ( Date.now().toString());
+        }
+        if (Array.isArray(content.value)) {
+            if (content.value.length < 1) {
+                const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+                lastThinking?.finalizeTitleIfDefault();
+                return this.renderNoContent(other => content.kind === other.kind);
+            }
+            let lastPart;
+            for (const item of content.value) {
+                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)));
+                        lastPart = itemPart;
+                    }
+                }
+            }
+            return lastPart ?? this.renderNoContent(other => content.kind === other.kind);
+        }
+        else {
+            const lastActiveThinking = this.getLastThinkingPart(templateData.renderedParts);
+            if (lastActiveThinking) {
+                lastActiveThinking.setupThinkingContainer(content, context);
+                return lastActiveThinking;
+            }
+            else {
+                const part = templateData.instantiationService.createInstance(ChatThinkingContentPart, content, context, this.chatContentMarkdownRenderer);
+                part.addDisposable(part.onDidChangeHeight(() => this.updateItemHeight(templateData)));
+                return part;
+            }
+        }
+    }
+    disposeElement(node, index, templateData, details) {
+        this.traceLayout('disposeElement', `Disposing element, index=${index}`);
+        templateData.elementDisposables.clear();
+        if (templateData.currentElement && !this.viewModel?.editing) {
+            this.templateDataByRequestId.delete(templateData.currentElement.id);
+        }
+        if (isRequestVM(node.element) && node.element.id === this.viewModel?.editing?.id && details?.onScroll) {
+            this._onDidDispose.fire(templateData);
+        }
+        if (templateData.titleToolbar) {
+            templateData.titleToolbar.context = undefined;
+        }
+        templateData.footerToolbar.context = undefined;
+    }
+    renderMcpServersInteractionRequired(content, context, templateData) {
+        return this.instantiationService.createInstance(ChatMcpServersInteractionContentPart, content, context);
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+    hoverVisible(requestHover) {
+        requestHover.style.opacity = '1';
+    }
+    hoverHidden(requestHover) {
+        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) {
+        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;
+    }
+    getTemplateId(element) {
+        return ChatListItemRenderer.ID;
+    }
+    hasDynamicHeight(element) {
+        return true;
+    }
+};
+ChatListDelegate = ( __decorate([
+    ( __param(1, ILogService))
+], ChatListDelegate));
+const voteDownDetailLabels = {
+    [ChatAgentVoteDownReason.IncorrectCode]: ( localize(5333, "Suggested incorrect code")),
+    [ChatAgentVoteDownReason.DidNotFollowInstructions]: ( localize(5334, "Didn't follow instructions")),
+    [ChatAgentVoteDownReason.MissingContext]: ( localize(5335, "Missing context")),
+    [ChatAgentVoteDownReason.OffensiveOrUnsafe]: ( localize(5336, "Offensive or unsafe")),
+    [ChatAgentVoteDownReason.PoorlyWrittenOrFormatted]: ( localize(5337, "Poorly written or formatted")),
+    [ChatAgentVoteDownReason.RefusedAValidRequest]: ( localize(5338, "Refused a valid request")),
+    [ChatAgentVoteDownReason.IncompleteCode]: ( localize(5339, "Incomplete code")),
+    [ChatAgentVoteDownReason.WillReportIssue]: ( localize(5340, "Report an issue")),
+    [ChatAgentVoteDownReason.Other]: ( localize(5341, "Other")),
+};
+let ChatVoteDownButton = class ChatVoteDownButton extends DropdownMenuActionViewItem {
+    constructor(action, options, commandService, issueService, logService, contextMenuService) {
+        super(action, { getActions: () => this.getActions(), }, contextMenuService, {
+            ...options,
+            classNames: ThemeIcon.asClassNameArray(Codicon.thumbsdown),
+        });
+        this.commandService = commandService;
+        this.issueService = issueService;
+        this.logService = logService;
+    }
+    getActions() {
+        return [
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.IncorrectCode),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.DidNotFollowInstructions),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.IncompleteCode),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.MissingContext),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.PoorlyWrittenOrFormatted),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.RefusedAValidRequest),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.OffensiveOrUnsafe),
+            this.getVoteDownDetailAction(ChatAgentVoteDownReason.Other),
+            {
+                id: 'reportIssue',
+                label: voteDownDetailLabels[ChatAgentVoteDownReason.WillReportIssue],
+                tooltip: '',
+                enabled: true,
+                class: undefined,
+                run: async (context) => {
+                    if (!isResponseVM(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 });
+                }
+            }
+        ];
+    }
+    render(container) {
+        super.render(container);
+        this.element?.classList.toggle('checked', this.action.checked);
+    }
+    getVoteDownDetailAction(reason) {
+        const label = voteDownDetailLabels[reason];
+        return {
+            id: MarkUnhelpfulActionId,
+            label,
+            tooltip: '',
+            enabled: true,
+            checked: this._context.voteDownReason === reason,
+            class: undefined,
+            run: async (context) => {
+                if (!isResponseVM(context)) {
+                    this.logService.error('ChatVoteDownButton#getVoteDownDetailAction: invalid context');
+                    return;
+                }
+                await this.commandService.executeCommand(MarkUnhelpfulActionId, context, reason);
+            }
+        };
+    }
+};
+ChatVoteDownButton = ( __decorate([
+    ( __param(2, ICommandService)),
+    ( __param(3, IWorkbenchIssueService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IContextMenuService))
+], ChatVoteDownButton));
+
+export { ChatListDelegate, ChatListItemRenderer, ChatVoteDownButton };