@codingame/monaco-vscode-api 37.2.0 → 37.3.1

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

@@ -0,0 +1,2187 @@
+
+import { registerCss } from '../../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { $, addDisposableListener, EventType, EventHelper, scheduleAtNextAnimationFrame, getWindow, DisposableResizeObserver, clearNode, isHTMLElement, hide } from '../../../../../../base/browser/dom.js';
+import { alert } from '../../../../../../base/browser/ui/aria/aria.js';
+import { Button } from '../../../../../../base/browser/ui/button/button.js';
+import { HoverStyle } from '../../../../../../base/browser/ui/hover/hover.js';
+import { DomScrollableElement } from '../../../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { ScrollbarVisibility } from '../../../../../../base/common/scrollable.js';
+import { IChatToolInvocation } from '../../../common/chatService/chatService.js';
+import { ThinkingDisplayMode, ChatConfiguration } from '../../../common/constants.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../../../platform/contextkey/common/contextkey.service.js';
+import { AccessibilityWorkbenchSettingId } from '../../../../accessibility/browser/accessibilityConfiguration.js';
+import { markdownStringEqual, MarkdownString } from '../../../../../../base/common/htmlContent.js';
+import { extractCodeblockUrisFromText } from '../../../common/widget/annotations.js';
+import { getComparisonKey, basename } from '../../../../../../base/common/resources.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { ChatThinkingStyleContentPart, createThinkingIcon } from './chatThinkingStyleContentPart.js';
+import { renderFileWidgets } from './chatInlineAnchorWidget.js';
+import { localize } from '../../../../../../nls.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../../../base/common/themables.js';
+import { Lazy } from '../../../../../../base/common/lazy.js';
+import { Emitter } from '../../../../../../base/common/event.js';
+import { MutableDisposable, DisposableMap, DisposableStore, toDisposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { CancellationTokenSource } from '../../../../../../base/common/cancellation.js';
+import { IChatMarkdownAnchorService } from './chatMarkdownAnchorService.service.js';
+import { ChatMessageRole } from '../../../common/languageModels.js';
+import { ILanguageModelsService } from '../../../common/languageModels.service.js';
+import * as chatThinkingContent from './media/chatThinkingContent.css';
+import { IHoverService } from '../../../../../../platform/hover/browser/hover.service.js';
+import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.service.js';
+import { getCompactCodicon } from '../../chatIcons.js';
+import { StorageScope, StorageTarget } from '../../../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../../../platform/storage/common/storage.service.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.service.js';
+import { extractImagesFromToolInvocationOutputDetails } from '../../../common/chatImageExtraction.js';
+import { ChatThinkingExternalResourceWidget } from './chatThinkingExternalResourcesWidget.js';
+import { LocalChatSessionUri, chatSessionResourceToId } from '../../../common/model/chatUri.js';
+import { mainWindow } from '../../../../../../base/browser/window.js';
+import { autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
+
+var ChatThinkingContentPart_1;
+registerCss(chatThinkingContent, 1);
+const SESSIONS_IS_PHONE_LAYOUT_KEY = "sessionsIsPhoneLayout";
+function getEffectiveThinkingDisplayMode(configurationService, contextKeyService, readOnly = false) {
+    if (readOnly || contextKeyService.getContextKeyValue(SESSIONS_IS_PHONE_LAYOUT_KEY) === true) {
+        return ThinkingDisplayMode.CollapsedPreview;
+    }
+    return configurationService.getValue("chat.agent.thinkingStyle") ?? ThinkingDisplayMode.Collapsed;
+}
+function extractTextFromPart(content) {
+    const raw = Array.isArray(content.value) ? content.value.join("") : (content.value || "");
+    return raw.trim();
+}
+function isEditToolId(toolId) {
+    const lowerToolId = toolId.toLowerCase();
+    return lowerToolId.includes("edit") || lowerToolId.includes("create") || lowerToolId.includes("replace") || lowerToolId.includes("patch");
+}
+function isGenericEditToolId(toolId) {
+    const lowerToolId = toolId.toLowerCase();
+    if (lowerToolId.includes("create") || lowerToolId.includes("notebook")) {
+        return false;
+    }
+    return lowerToolId.includes("replace") || lowerToolId.includes("patch") || lowerToolId.includes("insertedit") || lowerToolId.includes("insert_edit") || lowerToolId.includes("editfile");
+}
+function isProblemsToolId(toolId) {
+    switch (toolId?.toLowerCase()) {
+    case "problems":
+    case "get_errors":
+    case "copilot_geterrors":
+        return true;
+    default:
+        return false;
+    }
+}
+function isNoProblemsFoundResult(toolId, resultText) {
+    return isProblemsToolId(toolId) && resultText?.toLowerCase().includes("no problems found") === true;
+}
+function getToolInvocationIcon(toolId, registeredIcon, resultText) {
+    if (isNoProblemsFoundResult(toolId, resultText)) {
+        return Codicon.search;
+    }
+    if (registeredIcon) {
+        return registeredIcon;
+    }
+    const lowerToolId = toolId.toLowerCase();
+    if (lowerToolId.includes("comment")) {
+        return Codicon.comment;
+    }
+    if (lowerToolId.includes("search") || lowerToolId.includes("grep") || lowerToolId.includes("find") || lowerToolId.includes("list") || lowerToolId.includes("semantic") || lowerToolId.includes("changes") || lowerToolId.includes("codebase") || lowerToolId.includes("checked")) {
+        return Codicon.search;
+    }
+    if (lowerToolId.includes("read") || lowerToolId.includes("get_file") || lowerToolId.includes("problems")) {
+        return Codicon.book;
+    }
+    if (isEditToolId(toolId)) {
+        return Codicon.pencil;
+    }
+    if (lowerToolId.includes("terminal")) {
+        return Codicon.terminal;
+    }
+    return Codicon.tools;
+}
+function setThinkingIcon(iconElement, icon) {
+    iconElement.className = "chat-thinking-icon";
+    iconElement.classList.add(...ThemeIcon.asClassNameArray(getCompactCodicon(icon)));
+}
+function extractTitleFromThinkingContent(content) {
+    const headerMatch = content.match(/^\*\*([^*]+)\*\*/);
+    return headerMatch ? headerMatch[1] : undefined;
+}
+function isThinkingHeaderLine(line) {
+    return /^\s*\*\*.+\*\*\s*$/.test(line);
+}
+function stripStandaloneBold(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("**") && trimmed.indexOf("**", 2) === trimmed.length - 2) {
+        return trimmed.slice(2, -2);
+    }
+    return text;
+}
+function splitReasoningSummaryRows(text, dropLeadingHeader = true) {
+    const sections = [];
+    for (const line of text.split("\n")) {
+        if (isThinkingHeaderLine(line)) {
+            sections.push({
+                isHeader: true,
+                lines: [line]
+            });
+        } else if (sections.length === 0) {
+            sections.push({
+                isHeader: false,
+                lines: [line]
+            });
+        } else {
+            sections[sections.length - 1].lines.push(line);
+        }
+    }
+    if (sections.filter(section => section.isHeader).length < 2) {
+        return undefined;
+    }
+    const dropFirst = dropLeadingHeader && sections[0].isHeader;
+    const rows = [];
+    sections.forEach((section, index) => {
+        const lines = index === 0 && dropFirst ? section.lines.slice(1) : section.lines;
+        const markdown = lines.join("\n").trim();
+        if (markdown) {
+            rows.push(markdown);
+        }
+    });
+    return rows.length ? rows : undefined;
+}
+function getThinkingTitleValue(title) {
+    return typeof title === "string" ? title : title.value;
+}
+function thinkingTitleEqual(first, second) {
+    if (typeof first === "string" || typeof second === "string") {
+        return first === second;
+    }
+    return markdownStringEqual(first, second);
+}
+const THINKING_SCROLL_MAX_HEIGHT = 200;
+const TITLE_CACHE_STORAGE_KEY = "chat.thinkingTitleCache";
+const TITLE_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const TITLE_CACHE_MAX_ENTRIES = 1000;
+var WorkingMessageCategory;
+(function(WorkingMessageCategory) {
+    WorkingMessageCategory["Thinking"] = "thinking";
+    WorkingMessageCategory["Terminal"] = "terminal";
+    WorkingMessageCategory["Tool"] = "tool";
+})(WorkingMessageCategory || (WorkingMessageCategory = {}));
+const defaultThinkingMessages = [( localize(11594, "Thinking")), ( localize(11595, "Reasoning")), ( localize(11596, "Considering")), ( localize(11597, "Analyzing")), ( localize(11598, "Evaluating")), ( localize(11599, "Working"))];
+const terminalMessages = [( localize(11600, "Executing")), ( localize(11601, "Running")), ( localize(11602, "Processing"))];
+const toolMessages = [( localize(11603, "Processing")), ( localize(11604, "Preparing")), ( localize(11605, "Loading")), ( localize(11606, "Analyzing")), ( localize(11607, "Evaluating"))];
+const funWorkingMessages = [(
+localize(11608, "Bribing the hamster")), ( localize(11609, "Reticulating splines")), ( localize(11610, "Untangling the spaghetti")), ( localize(11611, "Communing with the codebase")), (
+localize(11612, "Mining diamonds")), (
+localize(11613, "Summoning Clippy"))];
+const FUN_WORKING_MESSAGE_RATE = 50;
+function getCustomThinkingPhrases(configurationService) {
+    const config = configurationService.getValue(ChatConfiguration.ThinkingPhrases);
+    const customPhrases = Array.isArray(config?.phrases) ? config.phrases.filter(phrase => typeof phrase === "string").map(phrase => phrase.trim()).filter(phrase => phrase.length > 0) : [];
+    return {
+        customPhrases,
+        replaceDefaults: config?.mode === "replace" && customPhrases.length > 0
+    };
+}
+function maybePickFunWorkingMessage(configurationService, random = Math.random) {
+    if (getCustomThinkingPhrases(configurationService).replaceDefaults) {
+        return undefined;
+    }
+    if (Math.floor(random() * FUN_WORKING_MESSAGE_RATE) === 0) {
+        return funWorkingMessages[Math.floor(random() * funWorkingMessages.length)];
+    }
+    return undefined;
+}
+function buildPhrasePool(defaults, configurationService) {
+    const {
+        customPhrases,
+        replaceDefaults
+    } = getCustomThinkingPhrases(configurationService);
+    if (customPhrases.length > 0) {
+        return replaceDefaults ? [...customPhrases] : [...defaults, ...customPhrases];
+    }
+    return [...defaults];
+}
+let ChatThinkingContentPart = ChatThinkingContentPart_1 = class ChatThinkingContentPart extends ChatThinkingStyleContentPart {
+    static _codeBlockRendererSync(_languageId, text, _raw) {
+        const codeElement = $("code");
+        codeElement.textContent = text;
+        return codeElement;
+    }
+    get aggregatedDiff() {
+        return this._aggregatedDiff;
+    }
+    getRandomWorkingMessage(category = WorkingMessageCategory.Tool) {
+        const fun = maybePickFunWorkingMessage(this.configurationService);
+        if (fun) {
+            return fun;
+        }
+        let pool = this.availableMessagesByCategory.get(category);
+        if (!pool || pool.length === 0) {
+            let defaults;
+            switch (category) {
+            case WorkingMessageCategory.Thinking:
+                defaults = defaultThinkingMessages;
+                break;
+            case WorkingMessageCategory.Terminal:
+                defaults = terminalMessages;
+                break;
+            case WorkingMessageCategory.Tool:
+            default:
+                defaults = toolMessages;
+                break;
+            }
+            pool = buildPhrasePool(defaults, this.configurationService);
+            this.availableMessagesByCategory.set(category, pool);
+        }
+        const index = Math.floor(Math.random() * pool.length);
+        return pool.splice(index, 1)[0];
+    }
+    constructor(
+        content,
+        context,
+        chatContentMarkdownRenderer,
+        streamingCompleted,
+        instantiationService,
+        configurationService,
+        chatMarkdownAnchorService,
+        languageModelsService,
+        hoverService,
+        telemetryService,
+        storageService,
+        contextKeyService,
+        editorService
+    ) {
+        const initialText = extractTextFromPart(content);
+        const containsReasoning = initialText.trim().length > 0;
+        const extractedTitle = extractTitleFromThinkingContent(initialText) ?? ( localize(11614, "Thinking"));
+        super(
+            extractedTitle,
+            context,
+            undefined,
+            hoverService,
+            configurationService,
+            telemetryService
+        );
+        this.chatContentMarkdownRenderer = chatContentMarkdownRenderer;
+        this.streamingCompleted = streamingCompleted;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+        this.languageModelsService = languageModelsService;
+        this.storageService = storageService;
+        this.editorService = editorService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this._asyncRenderCallback = () => this._onDidChangeHeight.fire();
+        this.defaultTitle = ( localize(11615, "Thinking"));
+        this.workingTitle = ( localize(11616, "Working"));
+        this._markdownResult = this._register(( new MutableDisposable()));
+        this.summaryRowItems = [];
+        this.summaryRowResults = [];
+        this.summaryRowTexts = [];
+        this.retiredSummaryRowResults = [];
+        this.fixedScrollingMode = false;
+        this.autoScrollEnabled = true;
+        this.extractedTitles = [];
+        this.toolInvocationCount = 0;
+        this.appendedItemCount = 0;
+        this.isActive = true;
+        this.toolInvocations = [];
+        this.allThinkingParts = [];
+        this.hookCount = 0;
+        this.lazyItems = [];
+        this.hasExpandedOnce = false;
+        this.availableMessagesByCategory = ( new Map());
+        this.toolWrappersByCallId = ( new Map());
+        this.toolIconsByCallId = ( new Map());
+        this.toolLabelsByCallId = ( new Map());
+        this.toolDisposables = this._register(( new DisposableMap()));
+        this.ownedToolParts = ( new Map());
+        this.pendingRemovals = [];
+        this.isUpdatingDimensions = false;
+        this.lastKnownContentHeight = 0;
+        this.lastKnownScrollTop = 0;
+        this._pendingExternalResources = ( new Map());
+        this._titleDetailRendered = this._register(( new MutableDisposable()));
+        this._pendingAppendRefresh = this._register(( new MutableDisposable()));
+        this.diffDataByPartId = ( new Map());
+        this._aggregatedDiff = {
+            added: 0,
+            removed: 0
+        };
+        this.diffButtonStore = this._register(( new DisposableStore()));
+        this.containsGroupedItems = false;
+        this.containsReasoning = containsReasoning;
+        this.reasoningDurationMs = content.reasoningDurationMs;
+        this.id = content.id;
+        this.content = content;
+        this.allThinkingParts.push(content);
+        const configuredMode = getEffectiveThinkingDisplayMode(this.configurationService, contextKeyService, context.readOnly);
+        this.thinkingDisplayMode = configuredMode;
+        this.fixedScrollingMode = configuredMode === ThinkingDisplayMode.FixedScrolling;
+        this.currentTitle = extractedTitle;
+        if (extractedTitle !== this.defaultTitle) {
+            this.lastExtractedTitle = extractedTitle;
+            this.extractedTitles.push(extractedTitle);
+        }
+        this.currentThinkingValue = initialText;
+        this.trackDroppedSummaryHeader(initialText);
+        if (initialText.trim()) {
+            this.appendedItemCount++;
+        }
+        if (this.configurationService.getValue(AccessibilityWorkbenchSettingId.VerboseChatProgressUpdates)) {
+            alert(( localize(11617, "Thinking")));
+        }
+        if (configuredMode === ThinkingDisplayMode.Collapsed) {
+            this.setExpanded(false);
+        } else if (configuredMode === ThinkingDisplayMode.CollapsedPreview) {
+            this.setExpanded(!this.streamingCompleted && !this.element.isComplete);
+        } else {
+            this.setExpanded(false);
+        }
+        const node = this.domNode;
+        if (this._hoverChevron) {
+            this._register(addDisposableListener(this._hoverChevron, EventType.CLICK, event => {
+                EventHelper.stop(event, true);
+                this.toggleExpanded();
+            }));
+        }
+        this._externalResourceWidget = this._register(
+            this.instantiationService.createInstance(ChatThinkingExternalResourceWidget)
+        );
+        this._register(
+            this._externalResourceWidget.onDidChangeHeight(() => this._onDidChangeHeight.fire())
+        );
+        node.appendChild(this._externalResourceWidget.domNode);
+        if (!this.streamingCompleted && !this.element.isComplete) {
+            if (!this.fixedScrollingMode) {
+                node.classList.add("chat-thinking-active");
+            }
+        }
+        if (!this.fixedScrollingMode && !this.streamingCompleted && !this.element.isComplete && this._collapseButton) {
+            this.setShimmerTitle(extractedTitle);
+        }
+        if (this.fixedScrollingMode) {
+            node.classList.add("chat-thinking-fixed-mode");
+            this.currentTitle = this.defaultTitle;
+        }
+        this._register(toDisposable(() => {
+            for (const d of ( this.ownedToolParts.values())) {
+                d.dispose();
+            }
+            this.ownedToolParts.clear();
+        }));
+        this._register(toDisposable(() => {
+            for (const result of this.summaryRowResults) {
+                result?.dispose();
+            }
+            for (const result of this.retiredSummaryRowResults) {
+                result.dispose();
+            }
+        }));
+        this._register(autorun(r => {
+            const isExpanded = this._isExpanded.read(r);
+            if (isExpanded && !this.hasExpandedOnce && this.lazyItems.length > 0) {
+                this.hasExpandedOnce = true;
+                this.processPendingRemovals();
+                for (const item of this.lazyItems) {
+                    this.materializeLazyItem(item);
+                }
+            }
+            if (isExpanded && !this.shouldAllowExpansion() && (this.streamingCompleted || this.element.isComplete)) {
+                this.setExpanded(false);
+                return;
+            }
+            this._externalResourceWidget.setCollapsed(!isExpanded);
+            this._onDidChangeHeight.fire();
+        }));
+        const label = this.lastExtractedTitle ?? "";
+        if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+            this.setTitle(label);
+        }
+        if (this._collapseButton) {
+            this._register(this._collapseButton.onDidClick(() => {
+                if (this.fixedScrollingMode) {
+                    if (this.streamingCompleted) {
+                        this.domNode.classList.add("chat-thinking-fixed-mode-animated");
+                    }
+                    return;
+                }
+                if (this.streamingCompleted) {
+                    return;
+                }
+                const expanded = this.isExpanded();
+                if (expanded) {
+                    this.collapsedTitleBeforeExpansion = this.lastRenderedTitle ?? this.lastExtractedTitle;
+                    this.setTitle(this.defaultTitle, true);
+                    this.currentTitle = this.defaultTitle;
+                } else {
+                    const collapsedTitle = this.collapsedTitleBeforeExpansion ?? this.lastRenderedTitle ?? this.lastExtractedTitle;
+                    this.collapsedTitleBeforeExpansion = undefined;
+                    if (collapsedTitle) {
+                        this.setTitle(collapsedTitle);
+                    } else {
+                        this.setTitle(this.defaultTitle, true);
+                        this.currentTitle = this.defaultTitle;
+                    }
+                }
+            }));
+        }
+    }
+    shouldInitEarly() {
+        return this.fixedScrollingMode && !this.streamingCompleted;
+    }
+    shouldAnimateContent() {
+        return !this.fixedScrollingMode;
+    }
+    shouldPrepareContentAnimation() {
+        return !this.fixedScrollingMode;
+    }
+    contentDidInitialize() {
+        if (this.fixedScrollingMode && this.streamingCompleted && this.scrollableElement) {
+            const scrollableDomNode = this.scrollableElement.getDomNode();
+            scrollableDomNode.style.maxHeight = "0px";
+            scrollableDomNode.getBoundingClientRect();
+        }
+    }
+    get collapsibleKind() {
+        return "thinking";
+    }
+    expansionDidChange(expanded) {
+        if (this.fixedScrollingMode && this.streamingCompleted) {
+            if (expanded) {
+                this.syncDimensionsAndScheduleScroll();
+            } else {
+                this.updateCompletedScrollAnimationState(false);
+            }
+        }
+    }
+    getThinkingIcon(_active, expanded) {
+        if (this.streamingCompleted || this.element.isComplete) {
+            return Codicon.checkCompact;
+        }
+        return !this.fixedScrollingMode && expanded ? Codicon.chevronDownCompact : Codicon.circleFilledCompact;
+    }
+    initContent() {
+        this.wrapper = this.createThinkingBody();
+        if (!this.streamingCompleted) {
+            this.wrapper.classList.add("chat-thinking-streaming");
+        }
+        const hasLazyThinkingItems = ( this.lazyItems.some(item => item.kind === "thinking"));
+        if (this.currentThinkingValue && !hasLazyThinkingItems) {
+            this.textContainer = $(".chat-thinking-item.markdown-content");
+            this.wrapper.appendChild(this.textContainer);
+            this.renderMarkdown(this.currentThinkingValue);
+        }
+        if (!this.streamingCompleted && !this.element.isComplete) {
+            const spinner = this.createThinkingSpinnerRow(this.getRandomWorkingMessage(WorkingMessageCategory.Thinking));
+            this.workingSpinnerElement = spinner.row;
+            this.workingSpinnerLabel = spinner.label;
+            this.wrapper.appendChild(spinner.row);
+            this.updateWorkingSpinnerVisibility();
+        }
+        if (this.fixedScrollingMode) {
+            this.scrollableElement = this._register(( new DomScrollableElement(this.wrapper, {
+                vertical: ScrollbarVisibility.Auto,
+                horizontal: ScrollbarVisibility.Hidden,
+                handleMouseWheel: true,
+                alwaysConsumeMouseWheel: false
+            })));
+            this._register(this.scrollableElement.onScroll(e => this.handleScroll(e.scrollTop)));
+            let pendingMutationRefresh;
+            const mutationObserver = new mainWindow.MutationObserver(() => {
+                if (pendingMutationRefresh) {
+                    return;
+                }
+                pendingMutationRefresh = scheduleAtNextAnimationFrame(getWindow(this.wrapper), () => {
+                    pendingMutationRefresh = undefined;
+                    if (this.streamingCompleted || !this.domNode.classList.contains("chat-used-context-collapsed")) {
+                        return;
+                    }
+                    this.refreshContentHeight();
+                    this.updateScrollDimensionsFromCache();
+                });
+            });
+            mutationObserver.observe(this.wrapper, {
+                childList: true,
+                subtree: true
+            });
+            this._register({
+                dispose: () => {
+                    mutationObserver.disconnect();
+                    pendingMutationRefresh?.dispose();
+                }
+            });
+            this.childResizeObserver = this._register(( new DisposableResizeObserver("ChatThinkingContentPart.child", () => {
+                if (this.streamingCompleted || !this.domNode.classList.contains("chat-used-context-collapsed")) {
+                    return;
+                }
+                this.syncDimensionsAndScheduleScroll();
+            })));
+            if (this.textContainer) {
+                this._register(this.childResizeObserver.observe(this.textContainer));
+            }
+            if (this.workingSpinnerElement) {
+                this._register(this.childResizeObserver.observe(this.workingSpinnerElement));
+            }
+            const wrapperResizeObserver = this._register(( new DisposableResizeObserver("ChatThinkingContentPart.wrapper", entries => {
+                if (entries[0]) {
+                    this.lastKnownContentHeight = this.wrapper.scrollHeight;
+                    if (this.streamingCompleted && this.isExpanded()) {
+                        this.updateScrollDimensionsForCompletion();
+                    } else if (!this.streamingCompleted && this.domNode.classList.contains("chat-used-context-collapsed")) {
+                        this.updateScrollDimensionsFromCache();
+                    }
+                }
+            })));
+            this.wrapperResizeObserverDisposable = this._register(wrapperResizeObserver.observe(this.wrapper));
+            this._register(this._onDidChangeHeight.event(() => {
+                if (!this.streamingCompleted && this.wrapperResizeObserverDisposable) {
+                    this.refreshContentHeight();
+                    this.updateScrollDimensionsFromCache();
+                    return;
+                }
+                this.syncDimensionsAndScheduleScroll();
+            }));
+            this.syncDimensionsAndScheduleScroll();
+            this.updateDropdownClickability();
+            return this.scrollableElement.getDomNode();
+        }
+        this.updateDropdownClickability();
+        return this.wrapper;
+    }
+    handleScroll(scrollTop) {
+        if (!this.scrollableElement || this.isUpdatingDimensions) {
+            return;
+        }
+        this.lastKnownScrollTop = scrollTop;
+        const contentHeight = this.lastKnownContentHeight;
+        const viewportHeight = Math.min(contentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        const maxScrollTop = contentHeight - viewportHeight;
+        this.autoScrollEnabled = maxScrollTop <= 0 || scrollTop >= maxScrollTop - 10;
+        this.updateFadeClasses(scrollTop, contentHeight, viewportHeight);
+    }
+    updateFadeClasses(scrollTop, contentHeight, viewportHeight) {
+        if (!this.fixedScrollingMode || this.streamingCompleted) {
+            this.domNode.classList.remove("chat-thinking-fade-top", "chat-thinking-fade-bottom");
+            return;
+        }
+        const currentScrollTop = scrollTop ?? this.lastKnownScrollTop;
+        const currentContentHeight = contentHeight ?? this.lastKnownContentHeight;
+        const currentViewportHeight = viewportHeight ?? Math.min(currentContentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        const maxScrollTop = currentContentHeight - currentViewportHeight;
+        this.domNode.classList.toggle("chat-thinking-fade-top", currentScrollTop > 5);
+        this.domNode.classList.toggle(
+            "chat-thinking-fade-bottom",
+            maxScrollTop > 0 && currentScrollTop < maxScrollTop - 5
+        );
+    }
+    syncDimensionsAndScheduleScroll() {
+        if (this.pendingScrollDisposable) {
+            return;
+        }
+        this.pendingScrollDisposable = scheduleAtNextAnimationFrame(getWindow(this.domNode), () => {
+            this.pendingScrollDisposable = undefined;
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (this.streamingCompleted) {
+                this.updateScrollDimensionsForCompletion();
+                return;
+            }
+            this.refreshContentHeight();
+            this.updateScrollDimensionsFromCache();
+        });
+    }
+    refreshContentHeight() {
+        if (!this.wrapper || !this.scrollableElement) {
+            return;
+        }
+        const newHeight = this.wrapper.scrollHeight;
+        if (newHeight && newHeight !== this.lastKnownContentHeight) {
+            this.lastKnownContentHeight = newHeight;
+        }
+    }
+    updateScrollDimensionsFromCache() {
+        if (!this.scrollableElement || this._store.isDisposed) {
+            return;
+        }
+        const isCollapsed = this.domNode.classList.contains("chat-used-context-collapsed");
+        if (!isCollapsed) {
+            return;
+        }
+        const contentHeight = this.lastKnownContentHeight;
+        if (!contentHeight) {
+            return;
+        }
+        const viewportHeight = Math.min(contentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        this.isUpdatingDimensions = true;
+        try {
+            const viewportWidth = this.scrollableElement.getDomNode().clientWidth;
+            this.scrollableElement.setScrollDimensions({
+                width: viewportWidth,
+                scrollWidth: viewportWidth,
+                height: viewportHeight,
+                scrollHeight: contentHeight
+            });
+            if (this.autoScrollEnabled) {
+                this.scrollToBottom(contentHeight);
+            }
+        } finally {
+            this.isUpdatingDimensions = false;
+        }
+        this.updateFadeClasses(this.lastKnownScrollTop, this.lastKnownContentHeight);
+        this.updateDropdownClickability(contentHeight);
+    }
+    scrollToBottom(contentHeight) {
+        if (!this.scrollableElement) {
+            return;
+        }
+        const viewportHeight = Math.min(contentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        if (contentHeight > viewportHeight) {
+            const newScrollTop = contentHeight - viewportHeight;
+            this.lastKnownScrollTop = newScrollTop;
+            this.scrollableElement.setRevealOnScroll(false);
+            this.scrollableElement.setScrollPosition({
+                scrollTop: newScrollTop
+            });
+            this.scrollableElement.setRevealOnScroll(true);
+        }
+    }
+    updateScrollDimensionsForCompletion() {
+        if (!this.scrollableElement || !this.fixedScrollingMode) {
+            return;
+        }
+        const contentHeight = this.wrapper.scrollHeight;
+        this.lastKnownContentHeight = contentHeight;
+        const scrollableDomNode = this.scrollableElement.getDomNode();
+        scrollableDomNode.style.maxHeight = `${contentHeight}px`;
+        const viewportWidth = scrollableDomNode.clientWidth;
+        this.scrollableElement.setScrollDimensions({
+            width: viewportWidth,
+            scrollWidth: viewportWidth,
+            height: contentHeight,
+            scrollHeight: contentHeight
+        });
+        this.lastKnownScrollTop = 0;
+        this.scrollableElement.setRevealOnScroll(false);
+        this.scrollableElement.setScrollPosition({
+            scrollTop: 0
+        });
+        this.scrollableElement.setRevealOnScroll(true);
+        this.updateCompletedScrollAnimationState(this.isExpanded());
+    }
+    updateCompletedScrollAnimationState(expanded) {
+        if (!this.scrollableElement) {
+            return;
+        }
+        const scrollableDomNode = this.scrollableElement.getDomNode();
+        scrollableDomNode.style.maxHeight = expanded ? `${this.lastKnownContentHeight}px` : "0px";
+        scrollableDomNode.inert = !expanded;
+    }
+    renderMarkdown(content, reuseExisting) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        if (this.summaryRowItems.length && this.summaryRowItems[0] !== this.textContainer) {
+            this.retireSummaryRows();
+        }
+        const cleanedContent = content.trim();
+        if (!cleanedContent) {
+            this._markdownResult.clear();
+            this.clearSummaryRows();
+            if (this.textContainer) {
+                clearNode(this.textContainer);
+            }
+            return;
+        }
+        const dropLeadingHeader = this.droppedSummaryHeader !== undefined && extractTitleFromThinkingContent(cleanedContent) === this.droppedSummaryHeader;
+        const summaryRows = splitReasoningSummaryRows(cleanedContent, dropLeadingHeader);
+        if (summaryRows && this.textContainer?.parentNode) {
+            this.renderSummaryRows(summaryRows);
+            return;
+        }
+        this.clearSummaryRows();
+        const contentToRender = stripStandaloneBold(cleanedContent);
+        const target = reuseExisting ? this._markdownResult.value?.element : undefined;
+        const rendered = this.chatContentMarkdownRenderer.render(( new MarkdownString(contentToRender)), {
+            fillInIncompleteTokens: true,
+            asyncRenderCallback: this._asyncRenderCallback,
+            codeBlockRendererSync: ChatThinkingContentPart_1._codeBlockRendererSync
+        }, target);
+        this._markdownResult.value = rendered;
+        if (!target) {
+            if (this.textContainer) {
+                clearNode(this.textContainer);
+                this.textContainer.appendChild(createThinkingIcon(Codicon.circleFilled));
+                this.textContainer.appendChild(rendered.element);
+            }
+        }
+    }
+    renderSummaryRow(container, index, markdown) {
+        const previous = this.summaryRowResults[index];
+        const reuse = !!previous && markdown.startsWith(this.summaryRowTexts[index] ?? "");
+        const rendered = this.chatContentMarkdownRenderer.render(( new MarkdownString(stripStandaloneBold(markdown))), {
+            fillInIncompleteTokens: true,
+            asyncRenderCallback: this._asyncRenderCallback,
+            codeBlockRendererSync: ChatThinkingContentPart_1._codeBlockRendererSync
+        }, reuse ? previous?.element : undefined);
+        if (!reuse) {
+            clearNode(container);
+            container.appendChild(createThinkingIcon(Codicon.circleFilled));
+            container.appendChild(rendered.element);
+        }
+        previous?.dispose();
+        this.summaryRowResults[index] = rendered;
+        this.summaryRowTexts[index] = markdown;
+    }
+    renderSummaryRows(rows) {
+        this._markdownResult.clear();
+        for (let i = 0; i < rows.length; i++) {
+            let container = this.summaryRowItems[i];
+            if (!container) {
+                container = i === 0 ? this.textContainer : $(".chat-thinking-item.markdown-content");
+                this.summaryRowItems[i] = container;
+                this.summaryRowTexts[i] = "";
+                if (i === 0) {
+                    clearNode(container);
+                } else {
+                    this.summaryRowItems[i - 1].after(container);
+                }
+            }
+            if (this.summaryRowTexts[i] !== rows[i]) {
+                this.renderSummaryRow(container, i, rows[i]);
+            }
+        }
+        for (let i = this.summaryRowItems.length - 1; i >= rows.length; i--) {
+            this.summaryRowResults[i]?.dispose();
+            if (this.summaryRowItems[i] !== this.textContainer) {
+                this.summaryRowItems[i].remove();
+            }
+        }
+        this.summaryRowItems.length = rows.length;
+        this.summaryRowResults.length = rows.length;
+        this.summaryRowTexts.length = rows.length;
+    }
+    clearSummaryRows() {
+        if (!this.summaryRowItems.length) {
+            return;
+        }
+        for (let i = 0; i < this.summaryRowItems.length; i++) {
+            this.summaryRowResults[i]?.dispose();
+            if (i !== 0) {
+                this.summaryRowItems[i].remove();
+            }
+        }
+        this.summaryRowItems = [];
+        this.summaryRowResults = [];
+        this.summaryRowTexts = [];
+    }
+    retireSummaryRows() {
+        for (const result of this.summaryRowResults) {
+            if (result) {
+                this.retiredSummaryRowResults.push(result);
+            }
+        }
+        this.summaryRowItems = [];
+        this.summaryRowResults = [];
+        this.summaryRowTexts = [];
+    }
+    trackDroppedSummaryHeader(value) {
+        if (this.droppedSummaryHeader) {
+            return;
+        }
+        const trimmed = value.trim();
+        if (splitReasoningSummaryRows(trimmed, true)) {
+            this.droppedSummaryHeader = extractTitleFromThinkingContent(trimmed);
+            if (this.fixedScrollingMode && this.droppedSummaryHeader && this.currentTitle !== this.droppedSummaryHeader) {
+                this.setTitle(this.droppedSummaryHeader);
+            }
+        }
+    }
+    setFinalizedTitle(title) {
+        if (!this._collapseButton) {
+            return;
+        }
+        const displayTitle = this.getFinalizedDisplayTitle(title);
+        this.clearTitleDetail();
+        const labelElement = this._collapseButton.labelElement;
+        labelElement.textContent = "";
+        this.forgetShimmerTitle();
+        const firstSpaceIndex = displayTitle.indexOf(" ");
+        if (firstSpaceIndex === -1) {
+            labelElement.textContent = displayTitle;
+        } else {
+            const verb = displayTitle.substring(0, firstSpaceIndex);
+            const rest = displayTitle.substring(firstSpaceIndex);
+            const verbSpan = $("span");
+            verbSpan.textContent = verb;
+            labelElement.appendChild(verbSpan);
+            const restSpan = $("span.chat-thinking-title-detail-text");
+            restSpan.textContent = rest;
+            labelElement.appendChild(restSpan);
+        }
+        if (this.diffDataByPartId.size > 0) {
+            const {
+                added,
+                removed
+            } = this._aggregatedDiff;
+            if (added > 0 || removed > 0) {
+                this.renderDiffButton(added, removed);
+                const insertionsFragment = added === 1 ? ( localize(11618, "1 insertion")) : ( localize(11619, "{0} insertions", added));
+                const deletionsFragment = removed === 1 ? ( localize(11620, "1 deletion")) : ( localize(11621, "{0} deletions", removed));
+                this.setAriaLabel(( localize(
+                    11622,
+                    "{0}, {1}, {2}",
+                    displayTitle,
+                    insertionsFragment,
+                    deletionsFragment
+                )));
+            } else {
+                this.clearDiffButton();
+                this.setAriaLabel(displayTitle);
+            }
+        } else {
+            this.clearDiffButton();
+            this.setAriaLabel(displayTitle);
+        }
+    }
+    renderDiffButton(added, removed) {
+        const resources = this.getAggregatedDiffResources();
+        if (resources.length === 0) {
+            this.clearDiffButton();
+            return;
+        }
+        if (!this.diffButton) {
+            const collapseButton = this._collapseButton;
+            const container = collapseButton?.element.parentElement;
+            if (!container) {
+                return;
+            }
+            collapseButton.element.classList.add("chat-thinking-title-with-diff");
+            const button = this.diffButtonStore.add(( new Button(container, {})));
+            button.element.classList.add("chat-thinking-title-diff");
+            this.diffButtonStore.add(button.onDidClick(event => {
+                EventHelper.stop(event, true);
+                this.openDiffs();
+            }));
+            this.diffButtonStore.add(this.hoverService.setupDelayedHover(button.element, {
+                content: ( localize(11623, "View File Changes")),
+                style: HoverStyle.Pointer
+            }));
+            this.diffButton = button;
+            if (this._hoverChevron) {
+                container.appendChild(this._hoverChevron);
+            }
+        }
+        this.diffButton.element.replaceChildren(
+            $("span.label-added", {}, `+${added}`),
+            $("span.label-removed", {}, `-${removed}`)
+        );
+        this.diffButton.setAriaLabel(( localize(
+            11624,
+            "View file changes, {0} lines added, {1} lines deleted",
+            added,
+            removed
+        )));
+    }
+    clearDiffButton() {
+        this.diffButtonStore.clear();
+        this.diffButton = undefined;
+        const collapseButton = this._collapseButton;
+        collapseButton?.element.classList.remove("chat-thinking-title-with-diff");
+        const container = collapseButton?.element.parentElement;
+        if (collapseButton && container && this._hoverChevron) {
+            if (this.titleDetailContainer?.parentElement === container) {
+                container.appendChild(this._hoverChevron);
+            } else {
+                collapseButton.element.appendChild(this._hoverChevron);
+            }
+        }
+    }
+    getAggregatedDiffResources() {
+        const result = ( new Map());
+        for (const data of ( this.diffDataByPartId.values())) {
+            for (const resource of data.resources) {
+                const key = getComparisonKey(resource.resource);
+                const existing = result.get(key);
+                if (existing) {
+                    existing.resource = resource.resource;
+                    existing.modifiedURI = resource.modifiedURI;
+                } else {
+                    result.set(key, {
+                        ...resource
+                    });
+                }
+            }
+        }
+        return [...( result.values())].filter(
+            resource => resource.originalURI !== undefined || resource.modifiedURI !== undefined
+        );
+    }
+    openDiffs() {
+        const resources = this.getAggregatedDiffResources();
+        if (resources.length === 0) {
+            return;
+        }
+        const source = ( URI.parse(`multi-diff-editor:${( Date.now().toString())}-${( Math.random().toString(36)).slice(2)}`));
+        this.editorService.openEditor({
+            multiDiffSource: source,
+            label: ( localize(11625, "Section File Changes")),
+            resources: resources.map(resource => ({
+                original: {
+                    resource: resource.originalURI
+                },
+                modified: {
+                    resource: resource.modifiedURI
+                },
+                goToFileResource: resource.resource
+            }))
+        });
+    }
+    getFinalizedDisplayTitle(title) {
+        if (this.thinkingDisplayMode !== ThinkingDisplayMode.Collapsed || !this.containsReasoning || this.containsGroupedItems || !this.reasoningDurationMs) {
+            return title;
+        }
+        const seconds = Math.ceil(this.reasoningDurationMs / 1000);
+        const duration = ( localize(11626, "{0}s", seconds));
+        return localize(11627, "{0} - {1}", title, duration);
+    }
+    hasReasoningContent() {
+        return this.containsReasoning;
+    }
+    hasGroupedItems() {
+        return this.containsGroupedItems;
+    }
+    recordReasoningContent(content) {
+        if (!content.trim()) {
+            return;
+        }
+        this.containsReasoning = true;
+    }
+    setDropdownClickable(clickable) {
+        if (this._collapseButton) {
+            this._collapseButton.element.style.pointerEvents = clickable ? "auto" : "none";
+        }
+        if (!clickable && this.streamingCompleted) {
+            this.setFinalizedTitle(this.lastExtractedTitle ?? this.currentTitle);
+        }
+    }
+    shouldAllowExpansion() {
+        if (this.toolInvocationCount > 0 || this.lazyItems.length > 0) {
+            return true;
+        }
+        if (this.wrapper) {
+            const meaningfulChildren = Array.from(this.wrapper.children).filter(child => child !== this.workingSpinnerElement).length;
+            if (meaningfulChildren > 1) {
+                return true;
+            }
+        }
+        const contentWithoutTitle = this.currentThinkingValue.trim();
+        const titleToCompare = this.lastExtractedTitle ?? this.currentTitle;
+        const stripMarkdown = text => {
+            return text.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").trim();
+        };
+        const strippedContent = stripMarkdown(contentWithoutTitle);
+        return !(!strippedContent || strippedContent === titleToCompare);
+    }
+    updateDropdownClickability(knownContentHeight) {
+        let allowExpansion = this.shouldAllowExpansion();
+        if (allowExpansion && this.fixedScrollingMode && !this.streamingCompleted && !this.element.isComplete && this.wrapper) {
+            const contentHeight = knownContentHeight ?? this.lastKnownContentHeight;
+            if (!contentHeight || contentHeight <= THINKING_SCROLL_MAX_HEIGHT) {
+                allowExpansion = false;
+            }
+        }
+        if (!allowExpansion && this.isExpanded() && (this.streamingCompleted || this.element.isComplete)) {
+            this.setExpanded(false);
+        }
+        this.setDropdownClickable(allowExpansion);
+    }
+    appendToWrapper(element) {
+        if (!this.wrapper) {
+            return;
+        }
+        if (this.workingSpinnerElement && this.workingSpinnerElement.parentNode === this.wrapper) {
+            this.wrapper.insertBefore(element, this.workingSpinnerElement);
+        } else {
+            this.wrapper.appendChild(element);
+        }
+    }
+    updateWorkingSpinnerVisibility(reader) {
+        if (!this.wrapper || !this.workingSpinnerElement) {
+            return;
+        }
+        const hasRunningTerminalTool = ( this.toolInvocations.some(toolInvocation => {
+            const terminalData = toolInvocation.toolSpecificData;
+            if (terminalData?.kind !== "terminal" || terminalData.terminalCommandState?.exitCode !== undefined) {
+                return false;
+            }
+            return !IChatToolInvocation.isComplete(toolInvocation, reader);
+        }));
+        const isAttached = this.workingSpinnerElement.parentNode === this.wrapper;
+        if (hasRunningTerminalTool && isAttached) {
+            this.workingSpinnerElement.remove();
+            this._onDidChangeHeight.fire();
+        } else if (!hasRunningTerminalTool && !isAttached && !this.streamingCompleted && !this.element.isComplete) {
+            this.wrapper.appendChild(this.workingSpinnerElement);
+            this._onDidChangeHeight.fire();
+        }
+    }
+    resetId() {
+        this.id = undefined;
+    }
+    collapseContent() {
+        this.setExpanded(false);
+    }
+    updateThinking(content) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.content = content;
+        this.reasoningDurationMs = content.reasoningDurationMs;
+        for (const lazyItem of this.lazyItems) {
+            if (lazyItem.kind === "thinking" && lazyItem.content.id === content.id) {
+                lazyItem.content = content;
+                break;
+            }
+        }
+        const raw = extractTextFromPart(content);
+        this.recordReasoningContent(raw);
+        const next = raw;
+        if (next === this.currentThinkingValue) {
+            return;
+        }
+        const previousValue = this.currentThinkingValue;
+        const reuseExisting = !!(this._markdownResult.value && next.startsWith(previousValue) && next.length > previousValue.length);
+        this.currentThinkingValue = next;
+        this.trackDroppedSummaryHeader(next);
+        this.renderMarkdown(next, reuseExisting);
+        if (this.fixedScrollingMode && this.scrollableElement) {
+            this.refreshContentHeight();
+            this.updateScrollDimensionsFromCache();
+        }
+        const extractedTitle = extractTitleFromThinkingContent(raw);
+        if (extractedTitle && extractedTitle !== this.currentTitle) {
+            if (!this.extractedTitles.includes(extractedTitle)) {
+                this.extractedTitles.push(extractedTitle);
+            }
+            this.lastExtractedTitle = extractedTitle;
+        }
+        if (!extractedTitle || extractedTitle === this.currentTitle) {
+            return;
+        }
+        const label = this.lastExtractedTitle ?? "";
+        if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+            this.setTitle(label);
+        }
+        this.updateDropdownClickability();
+    }
+    getIsActive() {
+        return this.isActive;
+    }
+    isEffectivelyEmpty() {
+        this.processPendingRemovals();
+        if (this.toolInvocationCount > 0 || this.lazyItems.length > 0 || this.hookCount > 0) {
+            return false;
+        }
+        if (this.currentThinkingValue.trim().length > 0) {
+            return false;
+        }
+        return true;
+    }
+    markAsInactive() {
+        this.isActive = false;
+        this.domNode.classList.remove("chat-thinking-active");
+        this.domNode.classList.remove("chat-thinking-fade-top", "chat-thinking-fade-bottom");
+        this.processPendingRemovals();
+        if (this.workingSpinnerElement) {
+            this.workingSpinnerElement.remove();
+            this.workingSpinnerElement = undefined;
+            this.workingSpinnerLabel = undefined;
+        }
+        for (const toolInvocation of this.toolInvocations) {
+            toolInvocation.isAttachedToThinking = false;
+        }
+    }
+    finalizeTitleIfDefault() {
+        this.processPendingRemovals();
+        if (this.wrapper) {
+            this.wrapper.classList.remove("chat-thinking-streaming");
+        }
+        this.domNode.classList.remove("chat-thinking-active");
+        this.domNode.classList.remove("chat-thinking-fade-top", "chat-thinking-fade-bottom");
+        this.streamingCompleted = true;
+        this.setContentAnimationEnabled(!this.fixedScrollingMode);
+        this.flushPendingExternalResources();
+        if (this.workingSpinnerElement) {
+            this.workingSpinnerElement.remove();
+            this.workingSpinnerElement = undefined;
+            this.workingSpinnerLabel = undefined;
+        }
+        if (this._collapseButton) {
+            this._collapseButton.icon = Codicon.checkCompact;
+        }
+        this.updateScrollDimensionsForCompletion();
+        this.updateDropdownClickability();
+        if (this.droppedSummaryHeader) {
+            this.currentTitle = this.droppedSummaryHeader;
+            this.content.generatedTitle = this.droppedSummaryHeader;
+            this.setGeneratedTitleOnAllParts(this.droppedSummaryHeader);
+            this.setFinalizedTitle(this.droppedSummaryHeader);
+            return;
+        }
+        if (this.content.generatedTitle) {
+            this.currentTitle = this.content.generatedTitle;
+            this.setGeneratedTitleOnAllParts(this.content.generatedTitle);
+            this.setFinalizedTitle(this.content.generatedTitle);
+            return;
+        }
+        const existingTitle = this.toolInvocations.find(t => t.generatedTitle)?.generatedTitle ?? this.allThinkingParts.find(t => t.generatedTitle)?.generatedTitle;
+        if (existingTitle) {
+            this.currentTitle = existingTitle;
+            this.content.generatedTitle = existingTitle;
+            this.setGeneratedTitleOnAllParts(existingTitle);
+            this.setFinalizedTitle(existingTitle);
+            return;
+        }
+        const allToolsSerialized = this.toolInvocations.every(t => t.kind === "toolInvocationSerialized");
+        if (allToolsSerialized && !LocalChatSessionUri.isLocalSession(this.element.sessionResource)) {
+            const cacheId = this.getTitleCacheId();
+            if (cacheId) {
+                const cachedTitle = this.getCachedTitle(cacheId);
+                if (cachedTitle) {
+                    this.currentTitle = cachedTitle;
+                    this.content.generatedTitle = cachedTitle;
+                    this.setGeneratedTitleOnAllParts(cachedTitle);
+                    this.setFinalizedTitle(cachedTitle);
+                    return;
+                }
+            }
+        }
+        if (this.toolInvocationCount === 1 && this.hookCount === 0 && this.currentThinkingValue.trim() === "") {
+            if (!this.singleItemInfo) {
+                const lazyItem = this.lazyItems.find(item => item.kind === "tool" && item.originalParent);
+                if (lazyItem && lazyItem.kind === "tool") {
+                    const toolInvocation = lazyItem.toolInvocationOrMarkdown && (lazyItem.toolInvocationOrMarkdown.kind === "toolInvocation" || lazyItem.toolInvocationOrMarkdown.kind === "toolInvocationSerialized") ? lazyItem.toolInvocationOrMarkdown : undefined;
+                    const result = lazyItem.lazy.value;
+                    this.appendItemToDOM(
+                        result.domNode,
+                        lazyItem.toolInvocationId,
+                        lazyItem.toolInvocationOrMarkdown,
+                        lazyItem.originalParent
+                    );
+                    if (result.disposable) {
+                        const toolCallId = toolInvocation?.toolCallId;
+                        if (toolCallId) {
+                            this.ownedToolParts.set(toolCallId, result.disposable);
+                        } else {
+                            this._register(result.disposable);
+                        }
+                    }
+                }
+            }
+            if (this.singleItemInfo && this.restoreSingleItemToOriginalPosition()) {
+                return;
+            }
+        }
+        if (this.extractedTitles.length === 1 && this.toolInvocationCount === 0) {
+            const title = this.extractedTitles[0];
+            this.currentTitle = title;
+            this.content.generatedTitle = title;
+            this.setGeneratedTitleOnAllParts(title);
+            this.setFinalizedTitle(title);
+            return;
+        }
+        const generateTitles = this.configurationService.getValue(ChatConfiguration.ThinkingGenerateTitles) ?? true;
+        if (!generateTitles) {
+            this.setFallbackTitle();
+            return;
+        }
+        this.generateTitleViaLLM();
+    }
+    setGeneratedTitleOnAllParts(title) {
+        for (const toolInvocation of this.toolInvocations) {
+            toolInvocation.generatedTitle = title;
+        }
+        for (const thinkingPart of this.allThinkingParts) {
+            thinkingPart.generatedTitle = title;
+        }
+    }
+    loadTitleCache() {
+        return this.storageService.getObject(TITLE_CACHE_STORAGE_KEY, StorageScope.PROFILE) ?? {};
+    }
+    saveTitleCache(cache) {
+        if (( Object.keys(cache)).length === 0) {
+            this.storageService.remove(TITLE_CACHE_STORAGE_KEY, StorageScope.PROFILE);
+        } else {
+            this.storageService.store(
+                TITLE_CACHE_STORAGE_KEY,
+                JSON.stringify(cache),
+                StorageScope.PROFILE,
+                StorageTarget.MACHINE
+            );
+        }
+    }
+    getTitleCacheKey(id) {
+        return `${chatSessionResourceToId(this.element.sessionResource)}:${id}`;
+    }
+    getTitleCacheId() {
+        const lastTool = this.toolInvocations[this.toolInvocations.length - 1];
+        if (lastTool) {
+            return lastTool.toolCallId;
+        }
+        return this.allThinkingParts.find(t => t.id)?.id ?? this.content.id;
+    }
+    getCachedTitle(id) {
+        const entry = this.loadTitleCache()[this.getTitleCacheKey(id)];
+        if (!entry || (Date.now() - entry.storedAt) > TITLE_CACHE_TTL_MS) {
+            return undefined;
+        }
+        return entry.title;
+    }
+    setCachedTitle(id, title) {
+        const cache = this.loadTitleCache();
+        const now = Date.now();
+        for (const key of ( Object.keys(cache))) {
+            if ((now - cache[key].storedAt) > TITLE_CACHE_TTL_MS) {
+                delete cache[key];
+            }
+        }
+        cache[this.getTitleCacheKey(id)] = {
+            title,
+            storedAt: now
+        };
+        const keys = ( Object.keys(cache));
+        if (keys.length > TITLE_CACHE_MAX_ENTRIES) {
+            const sorted = keys.sort((a, b) => cache[a].storedAt - cache[b].storedAt);
+            for (let i = 0; i < sorted.length - TITLE_CACHE_MAX_ENTRIES; i++) {
+                delete cache[sorted[i]];
+            }
+        }
+        this.saveTitleCache(cache);
+    }
+    async generateTitleViaLLM() {
+        const cts = ( new CancellationTokenSource());
+        const timeout = setTimeout(() => cts.cancel(), 5000);
+        try {
+            const models = await this.languageModelsService.selectLanguageModels({
+                vendor: "copilot",
+                id: "copilot-utility-small"
+            });
+            if (!models.length) {
+                this.setFallbackTitle();
+                return;
+            }
+            if (cts.token.isCancellationRequested) {
+                this.setFallbackTitle();
+                return;
+            }
+            let context;
+            if (this.extractedTitles.length > 0) {
+                context = this.extractedTitles.join(", ");
+            } else {
+                context = this.currentThinkingValue.substring(0, 1000);
+            }
+            const prompt = `Summarize the following content in a SINGLE sentence (under 10 words) using past tense. Follow these rules strictly:
+
+            OUTPUT FORMAT:
+            - MUST be a single sentence
+            - MUST be under 10 words
+            - The FIRST word MUST be a past tense verb (e.g. "Updated", "Reviewed", "Created", "Searched", "Analyzed")
+            - No quotes, no trailing punctuation
+
+            GENERAL:
+            - The content may include tool invocations (file edits, reads, searches, terminal commands), reasoning headers, or raw thinking text
+            - For reasoning headers or thinking text (no tool calls), summarize WHAT was considered/analyzed, NOT that thinking occurred
+            - For thinking-only summaries, use phrases like: "Considered...", "Planned...", "Analyzed...", "Reviewed..."
+
+            TOOL NAME FILTERING:
+            - NEVER include tool names like "Replace String in File", "Multi Replace String in File", "Create File", "Read File", etc. in the output
+            - If an action says "Edited X and used Replace String in File", output ONLY the action on X
+            - Tool names describe HOW something was done, not WHAT was done - always omit them
+
+            VOCABULARY - Use varied synonyms for natural-sounding summaries:
+            - For edits: "Updated", "Modified", "Changed", "Refactored", "Fixed", "Adjusted"
+            - For reads: "Reviewed", "Examined", "Checked", "Inspected", "Analyzed", "Explored"
+            - For creates: "Created", "Added", "Generated"
+            - For searches: "Searched for", "Looked up", "Investigated"
+            - For terminal: "Ran command", "Executed"
+            - For reasoning/thinking: "Considered", "Planned", "Analyzed", "Reviewed", "Evaluated"
+            - Choose the synonym that best fits the context
+
+${this.hookCount > 0 ? `BLOCKED/DENIED CONTENT (hooks detected):
+            - Only mention "blocked" if the content explicitly includes hook results that blocked or warned about a tool (e.g. "Blocked terminal" or "Warning for read_file")
+            - If blocked items are present alongside normal tool calls, briefly note the block but do NOT let it dominate the summary: e.g. "Updated file.ts, blocked terminal"
+
+            ` : `IMPORTANT: Do NOT use words like "blocked", "denied", or "tried" in the summary - there are no hooks or blocked items in this content. Just summarize normally.
+
+            `}RULES FOR TOOL CALLS:
+            1. If the SAME file was both edited AND read: Use a combined phrase like "Reviewed and updated <filename>"
+            2. If exactly ONE file was edited: Start with an edit synonym + "<filename>" (include actual filename)
+            3. If exactly ONE file was read: Start with a read synonym + "<filename>" (include actual filename)
+            4. If MULTIPLE files were edited: Start with an edit synonym + "X files"
+            5. If MULTIPLE files were read: Start with a read synonym + "X files"
+            6. If BOTH edits AND reads occurred on DIFFERENT files: Combine them naturally
+            7. For searches: Say "searched for <term>" or "looked up <term>" with the actual search term, NOT "searched for files"
+            8. After the file info, you may add a brief summary of other actions if space permits
+            9. NEVER say "1 file" - always use the actual filename when there's only one file
+
+            RULES FOR REASONING HEADERS (no tool calls):
+            1. If the input contains reasoning/analysis headers without actual tool invocations, summarize the main topic and what was considered
+            2. Use past tense verbs that indicate thinking, not doing: "Considered", "Planned", "Analyzed", "Evaluated"
+            3. Focus on WHAT was being thought about, not that thinking occurred
+
+            RULES FOR RAW THINKING TEXT:
+            1. Extract the main topic or question being considered from the text
+            2. Identify any specific files, functions, or concepts mentioned
+            3. Summarize as "Analyzed <topic>" or "Considered <specific thing>"
+            4. If discussing code structure: "Reviewed <component/architecture>"
+            5. If discussing a problem: "Analyzed <problem description>"
+            6. If discussing implementation: "Planned <feature/change>"
+
+            EXAMPLES WITH TOOLS:
+            - "Read HomePage.tsx, Edited HomePage.tsx" → "Reviewed and updated HomePage.tsx"
+            - "Edited HomePage.tsx" → "Updated HomePage.tsx"
+            - "Edited config.css and used Replace String in File" → "Modified config.css"
+            - "Edited App.tsx, used Multi Replace String in File" → "Refactored App.tsx"
+            - "Read config.json, Read package.json" → "Reviewed 2 files"
+            - "Edited App.tsx, Read utils.ts" → "Updated App.tsx and checked utils.ts"
+            - "Edited App.tsx, Read utils.ts, Read types.ts" → "Updated App.tsx and reviewed 2 files"
+            - "Edited index.ts, Edited styles.css, Ran terminal command" → "Modified 2 files and ran command"
+            - "Read README.md, Searched for AuthService" → "Checked README.md and searched for AuthService"
+            - "Searched for login, Searched for authentication" → "Searched for login and authentication"
+            - "Edited api.ts, Edited models.ts, Read schema.json" → "Updated 2 files and reviewed schema.json"
+            - "Edited Button.tsx, Edited Button.css, Edited index.ts" → "Modified 3 files"
+            - "Searched codebase for error handling" → "Looked up error handling"
+
+${this.hookCount > 0 ? `EXAMPLES WITH BLOCKED CONTENT (from hooks):
+            - "Blocked terminal, Edited config.ts" → "Edited config.ts, terminal was blocked"
+            - "Blocked terminal, Blocked read_file" → "Two tools were blocked by hooks"
+            - "Warning for read_file, Edited utils.ts" → "Edited utils.ts with a hook warning"
+
+            ` : ""}EXAMPLES WITH REASONING HEADERS (no tools):
+            - "Analyzing component architecture" → "Considered component architecture"
+            - "Planning refactor strategy" → "Planned refactor strategy"
+            - "Reviewing error handling approach, Considering edge cases" → "Analyzed error handling approach"
+            - "Understanding the codebase structure" → "Reviewed codebase structure"
+            - "Thinking about implementation options" → "Considered implementation options"
+
+            EXAMPLES WITH RAW THINKING TEXT:
+            - "I need to understand how the authentication flow works in this app..." → "Analyzed authentication flow"
+            - "Let me think about how to refactor this component to be more maintainable..." → "Planned component refactoring"
+            - "The error seems to be coming from the database connection..." → "Investigated database connection issue"
+            - "Looking at the UserService class, I see it handles..." → "Reviewed UserService implementation"
+
+            Content: ${context}`;
+            const response = await this.languageModelsService.sendChatRequest(models[0], undefined, [{
+                role: ChatMessageRole.User,
+                content: [{
+                    type: "text",
+                    value: prompt
+                }]
+            }], {}, cts.token);
+            let generatedTitle = "";
+            for await (const part of response.stream) {
+                if (cts.token.isCancellationRequested) {
+                    break;
+                }
+                if (Array.isArray(part)) {
+                    for (const p of part) {
+                        if (p.type === "text") {
+                            generatedTitle += p.value;
+                        }
+                    }
+                } else if (part.type === "text") {
+                    generatedTitle += part.value;
+                }
+            }
+            if (cts.token.isCancellationRequested) {
+                this.setFallbackTitle();
+                return;
+            }
+            await response.result;
+            generatedTitle = generatedTitle.trim();
+            if (generatedTitle.includes("can't assist with that")) {
+                this.setFallbackTitle();
+                return;
+            }
+            if (generatedTitle && !this._store.isDisposed) {
+                this.currentTitle = generatedTitle;
+                this.setFinalizedTitle(generatedTitle);
+                this.content.generatedTitle = generatedTitle;
+                this.setGeneratedTitleOnAllParts(generatedTitle);
+                if (!LocalChatSessionUri.isLocalSession(this.element.sessionResource)) {
+                    const cacheId = this.getTitleCacheId();
+                    if (cacheId) {
+                        this.setCachedTitle(cacheId, generatedTitle);
+                    }
+                }
+                return;
+            }
+        } catch (error) {} finally {
+            clearTimeout(timeout);
+            cts.dispose();
+        }
+        this.setFallbackTitle();
+    }
+    restoreSingleItemToOriginalPosition() {
+        if (!this.singleItemInfo) {
+            return false;
+        }
+        const {
+            element,
+            thinkingWrapper,
+            originalParent,
+            originalNextSibling,
+            restoreToOriginalParent,
+            toolInvocation
+        } = this.singleItemInfo;
+        const hasOtherThinkingItems = this.wrapper && ( Array.from(this.wrapper.children).some(child => child !== thinkingWrapper && child !== this.workingSpinnerElement));
+        if (hasOtherThinkingItems) {
+            this.singleItemInfo = undefined;
+            return false;
+        }
+        const precedingToolInvocationPart = isHTMLElement(originalNextSibling) && originalNextSibling.parentElement === originalParent ? originalNextSibling.previousElementSibling : originalParent.lastElementChild;
+        if (restoreToOriginalParent) {
+            if (originalNextSibling && originalNextSibling.parentNode === originalParent) {
+                originalParent.insertBefore(element, originalNextSibling);
+            } else {
+                originalParent.appendChild(element);
+            }
+        } else if (precedingToolInvocationPart?.classList.contains("chat-tool-invocation-part")) {
+            precedingToolInvocationPart.appendChild(element);
+        } else if (originalNextSibling && originalNextSibling.parentNode === originalParent) {
+            originalParent.insertBefore(element, originalNextSibling);
+        } else {
+            originalParent.appendChild(element);
+        }
+        thinkingWrapper.remove();
+        if (toolInvocation) {
+            this.toolWrappersByCallId.delete(toolInvocation.toolCallId);
+            this.toolIconsByCallId.delete(toolInvocation.toolCallId);
+            toolInvocation.isAttachedToThinking = false;
+        }
+        hide(this.domNode);
+        this.singleItemInfo = undefined;
+        return true;
+    }
+    updateAggregatedDiff() {
+        let totalAdded = 0;
+        let totalRemoved = 0;
+        for (const data of ( this.diffDataByPartId.values())) {
+            totalAdded += data.added;
+            totalRemoved += data.removed;
+        }
+        this._aggregatedDiff = {
+            added: totalAdded,
+            removed: totalRemoved
+        };
+        if (this.streamingCompleted || this.element.isComplete) {
+            this.setFinalizedTitle(this.currentTitle);
+        }
+    }
+    setFallbackTitle() {
+        const finalLabel = this.appendedItemCount > 0 ? this.appendedItemCount === 1 ? ( localize(11628, "Finished with 1 step")) : ( localize(11629, "Finished with {0} steps", this.appendedItemCount)) : ( localize(11630, "Finished Working"));
+        this.currentTitle = finalLabel;
+        if (this.wrapper) {
+            this.wrapper.classList.remove("chat-thinking-streaming");
+        }
+        this.domNode.classList.remove("chat-thinking-active");
+        this.streamingCompleted = true;
+        this.flushPendingExternalResources();
+        if (this._collapseButton) {
+            this._collapseButton.icon = Codicon.checkCompact;
+            this.setFinalizedTitle(finalLabel);
+        }
+        this.updateDropdownClickability();
+    }
+    appendItem(
+        factory,
+        toolInvocationId,
+        toolInvocationOrMarkdown,
+        originalParent,
+        onDidChangeDiff,
+        eagerDisposable
+    ) {
+        this.processPendingRemovals();
+        this.containsGroupedItems = true;
+        this.trackToolMetadata(toolInvocationId, toolInvocationOrMarkdown);
+        this.updateWorkingSpinnerVisibility();
+        this.appendedItemCount++;
+        if (onDidChangeDiff && toolInvocationId) {
+            this.diffDataByPartId.set(toolInvocationId, {
+                added: 0,
+                removed: 0,
+                resources: []
+            });
+            this._register(onDidChangeDiff(data => {
+                this.diffDataByPartId.set(toolInvocationId, data);
+                this.updateAggregatedDiff();
+            }));
+        }
+        if (eagerDisposable) {
+            this._register(eagerDisposable);
+        }
+        if (this.workingSpinnerLabel) {
+            const isTerminalTool = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") && toolInvocationOrMarkdown.toolSpecificData?.kind === "terminal";
+            const category = isTerminalTool ? WorkingMessageCategory.Terminal : WorkingMessageCategory.Tool;
+            this.workingSpinnerLabel.textContent = this.getRandomWorkingMessage(category);
+        }
+        if (this.isExpanded() || this.hasExpandedOnce || (this.fixedScrollingMode && !this.streamingCompleted)) {
+            const result = factory();
+            this.appendItemToDOM(result.domNode, toolInvocationId, toolInvocationOrMarkdown, originalParent);
+            if (result.disposable) {
+                const toolCallId = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") ? toolInvocationOrMarkdown.toolCallId : undefined;
+                if (toolCallId) {
+                    this.ownedToolParts.set(toolCallId, result.disposable);
+                } else {
+                    this._register(result.disposable);
+                }
+            }
+        } else {
+            const item = {
+                kind: "tool",
+                lazy: ( new Lazy(factory)),
+                toolInvocationId,
+                toolInvocationOrMarkdown,
+                originalParent,
+                isHook: !toolInvocationOrMarkdown && !!toolInvocationId
+            };
+            this.lazyItems.push(item);
+        }
+        this.updateDropdownClickability();
+    }
+    removeMaterializedItem(toolCallId) {
+        this.toolDisposables.deleteAndDispose(toolCallId);
+        this.ownedToolParts.delete(toolCallId);
+        const wrapper = this.toolWrappersByCallId.get(toolCallId);
+        if (wrapper) {
+            this.toolWrappersByCallId.delete(toolCallId);
+            this.toolIconsByCallId.delete(toolCallId);
+        }
+        this.appendedItemCount = Math.max(0, this.appendedItemCount - 1);
+        this.toolInvocationCount = Math.max(0, this.toolInvocationCount - 1);
+        const toolInvocationsIndex = this.toolInvocations.findIndex(
+            t => (t.kind === "toolInvocation" || t.kind === "toolInvocationSerialized") && t.toolCallId === toolCallId
+        );
+        if (toolInvocationsIndex !== -1) {
+            const label = this.toolLabelsByCallId.get(toolCallId);
+            if (label) {
+                const titleIndex = this.extractedTitles.indexOf(label);
+                if (titleIndex !== -1) {
+                    this.extractedTitles.splice(titleIndex, 1);
+                }
+            }
+            this.toolInvocations.splice(toolInvocationsIndex, 1);
+        }
+        this.toolLabelsByCallId.delete(toolCallId);
+        this._pendingExternalResources.delete(toolCallId);
+        this._externalResourceWidget.removeToolInvocation(toolCallId);
+        this.updateWorkingSpinnerVisibility();
+        this.updateDropdownClickability();
+        this._onDidChangeHeight.fire();
+    }
+    removeEditPillByPartId(partId) {
+        let removed = false;
+        const lazyIndex = this.lazyItems.findIndex(item => item.kind === "tool" && item.toolInvocationId === partId);
+        if (lazyIndex !== -1) {
+            this.lazyItems.splice(lazyIndex, 1);
+            removed = true;
+        }
+        if (this.diffDataByPartId.delete(partId)) {
+            this.updateAggregatedDiff();
+            removed = true;
+        }
+        if (removed) {
+            this.appendedItemCount = Math.max(0, this.appendedItemCount - 1);
+            this.updateDropdownClickability();
+            this._onDidChangeHeight.fire();
+        }
+    }
+    removeLazyItem(toolInvocationId) {
+        const index = this.lazyItems.findIndex(item => item.kind === "tool" && item.toolInvocationId === toolInvocationId);
+        if (index === -1) {
+            return false;
+        }
+        const removedItem = this.lazyItems[index];
+        this.lazyItems.splice(index, 1);
+        this.appendedItemCount--;
+        if (removedItem.kind === "tool" && removedItem.isHook) {
+            this.hookCount = Math.max(0, this.hookCount - 1);
+        } else {
+            this.toolInvocationCount--;
+        }
+        if (removedItem.kind === "tool" && removedItem.toolInvocationOrMarkdown && (removedItem.toolInvocationOrMarkdown.kind === "toolInvocation" || removedItem.toolInvocationOrMarkdown.kind === "toolInvocationSerialized")) {
+            removedItem.toolInvocationOrMarkdown.isAttachedToThinking = false;
+            const toolCallId = removedItem.toolInvocationOrMarkdown.toolCallId;
+            this._pendingExternalResources.delete(toolCallId);
+            this._externalResourceWidget.removeToolInvocation(toolCallId);
+            const label = this.toolLabelsByCallId.get(toolCallId);
+            if (label) {
+                const titleIndex = this.extractedTitles.indexOf(label);
+                if (titleIndex !== -1) {
+                    this.extractedTitles.splice(titleIndex, 1);
+                }
+            }
+            this.toolLabelsByCallId.delete(toolCallId);
+        }
+        const toolInvocationsIndex = this.toolInvocations.findIndex(
+            t => (t.kind === "toolInvocation" || t.kind === "toolInvocationSerialized") && t.toolId === toolInvocationId
+        );
+        if (toolInvocationsIndex !== -1) {
+            this.toolInvocations.splice(toolInvocationsIndex, 1);
+        }
+        this.updateDropdownClickability();
+        this.updateWorkingSpinnerVisibility();
+        return true;
+    }
+    processPendingRemovals() {
+        this.pendingRemovalFlushDisposable?.dispose();
+        this.pendingRemovalFlushDisposable = undefined;
+        if (this.pendingRemovals.length === 0) {
+            return;
+        }
+        const pendingRemovals = this.pendingRemovals;
+        this.pendingRemovals = [];
+        for (const pending of pendingRemovals) {
+            this.removeStreamingToolEntry(pending.toolCallId, pending.toolLabel);
+        }
+    }
+    schedulePendingRemovalsFlush() {
+        if (this.pendingRemovalFlushDisposable) {
+            return;
+        }
+        this.pendingRemovalFlushDisposable = scheduleAtNextAnimationFrame(getWindow(this.domNode), () => {
+            this.pendingRemovalFlushDisposable = undefined;
+            if (this._store.isDisposed) {
+                return;
+            }
+            this.processPendingRemovals();
+        });
+    }
+    removeStreamingToolEntry(toolCallId, toolLabel) {
+        this.toolDisposables.deleteAndDispose(toolCallId);
+        this.ownedToolParts.get(toolCallId)?.dispose();
+        this.ownedToolParts.delete(toolCallId);
+        const wrapper = this.toolWrappersByCallId.get(toolCallId);
+        if (wrapper) {
+            wrapper.remove();
+            this.toolWrappersByCallId.delete(toolCallId);
+            this.toolIconsByCallId.delete(toolCallId);
+        }
+        const lazyIndex = this.lazyItems.findIndex(
+            item => item.kind === "tool" && item.toolInvocationOrMarkdown && (item.toolInvocationOrMarkdown.kind === "toolInvocation" || item.toolInvocationOrMarkdown.kind === "toolInvocationSerialized") && item.toolInvocationOrMarkdown.toolCallId === toolCallId
+        );
+        if (lazyIndex !== -1) {
+            const removedLazyItem = this.lazyItems[lazyIndex];
+            if (removedLazyItem.kind === "tool" && removedLazyItem.toolInvocationOrMarkdown && (removedLazyItem.toolInvocationOrMarkdown.kind === "toolInvocation" || removedLazyItem.toolInvocationOrMarkdown.kind === "toolInvocationSerialized")) {
+                removedLazyItem.toolInvocationOrMarkdown.isAttachedToThinking = false;
+            }
+            this.lazyItems.splice(lazyIndex, 1);
+        }
+        this.appendedItemCount = Math.max(0, this.appendedItemCount - 1);
+        this.toolInvocationCount = Math.max(0, this.toolInvocationCount - 1);
+        const toolInvocationsIndex = this.toolInvocations.findIndex(
+            t => (t.kind === "toolInvocation" || t.kind === "toolInvocationSerialized") && t.toolCallId === toolCallId
+        );
+        if (toolInvocationsIndex !== -1) {
+            this.toolInvocations.splice(toolInvocationsIndex, 1);
+        }
+        const titleIndex = this.extractedTitles.indexOf(toolLabel);
+        if (titleIndex !== -1) {
+            this.extractedTitles.splice(titleIndex, 1);
+        }
+        this.toolLabelsByCallId.delete(toolCallId);
+        this._pendingExternalResources.delete(toolCallId);
+        this._externalResourceWidget.removeToolInvocation(toolCallId);
+        this.updateWorkingSpinnerVisibility();
+        this.updateDropdownClickability();
+        this._onDidChangeHeight.fire();
+    }
+    trackToolMetadata(toolInvocationId, toolInvocationOrMarkdown) {
+        if (!toolInvocationId) {
+            return;
+        }
+        const isHook = !toolInvocationOrMarkdown;
+        if (isHook) {
+            this.hookCount++;
+        } else {
+            this.toolInvocationCount++;
+        }
+        if (this.toolInvocationCount === 1) {
+            this.defaultTitle = this.workingTitle;
+        }
+        let toolCallLabel;
+        let toolCallTitle;
+        const isToolInvocation = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized");
+        if (isToolInvocation && toolInvocationOrMarkdown.invocationMessage) {
+            const invocationMessage = toolInvocationOrMarkdown.invocationMessage;
+            const isStreamingEditTool = toolInvocationOrMarkdown.kind === "toolInvocation" && IChatToolInvocation.isStreaming(toolInvocationOrMarkdown) && isGenericEditToolId(toolInvocationOrMarkdown.toolId);
+            if (isStreamingEditTool) {
+                toolCallTitle = ( localize(11631, "Editing files"));
+            } else {
+                toolCallTitle = invocationMessage;
+            }
+            toolCallLabel = getThinkingTitleValue(toolCallTitle);
+            this.toolInvocations.push(toolInvocationOrMarkdown);
+            const toolCallId = toolInvocationOrMarkdown.toolCallId;
+            this.toolLabelsByCallId.set(toolCallId, toolCallLabel);
+            if (toolInvocationOrMarkdown.kind === "toolInvocationSerialized") {
+                this.updateExternalResourceParts(toolInvocationOrMarkdown);
+                if (IChatToolInvocation.isEffectivelyHidden(toolInvocationOrMarkdown)) {
+                    this.pendingRemovals.push({
+                        toolCallId: toolInvocationOrMarkdown.toolCallId,
+                        toolLabel: toolCallLabel
+                    });
+                    this.schedulePendingRemovalsFlush();
+                }
+            }
+            if (toolInvocationOrMarkdown.kind === "toolInvocation") {
+                let currentToolLabel = toolCallLabel;
+                let isComplete = false;
+                let isStreaming = IChatToolInvocation.isStreaming(toolInvocationOrMarkdown);
+                const toolStore = ( new DisposableStore());
+                this.toolDisposables.set(toolInvocationOrMarkdown.toolCallId, toolStore);
+                const updateTitle = updatedTitle => {
+                    const updatedMessage = getThinkingTitleValue(updatedTitle);
+                    if (updatedMessage && !thinkingTitleEqual(updatedTitle, toolCallTitle)) {
+                        if (updatedMessage !== currentToolLabel) {
+                            const oldIndex = this.extractedTitles.indexOf(currentToolLabel);
+                            const updatedIndex = this.extractedTitles.indexOf(updatedMessage);
+                            if (oldIndex !== -1) {
+                                if (updatedIndex !== -1 && updatedIndex !== oldIndex) {
+                                    this.extractedTitles.splice(oldIndex, 1);
+                                } else {
+                                    this.extractedTitles[oldIndex] = updatedMessage;
+                                }
+                            } else if (updatedIndex === -1) {
+                                this.extractedTitles.push(updatedMessage);
+                            }
+                            currentToolLabel = updatedMessage;
+                        }
+                        toolCallLabel = updatedMessage;
+                        toolCallTitle = updatedTitle;
+                        this.toolLabelsByCallId.set(toolCallId, updatedMessage);
+                        this.lastExtractedTitle = updatedMessage;
+                        if (!this.fixedScrollingMode && !this._isExpanded.read(undefined)) {
+                            this.setTitle(updatedTitle);
+                        }
+                    }
+                };
+                const autorunDisposable = autorun(reader => {
+                    if (isComplete) {
+                        return;
+                    }
+                    const currentState = toolInvocationOrMarkdown.state.read(reader);
+                    this.updateWorkingSpinnerVisibility(reader);
+                    if (isStreaming && currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+                        isStreaming = false;
+                        const termData = toolInvocationOrMarkdown.toolSpecificData;
+                        if (termData?.kind === "terminal") {
+                            const iconEl = this.toolIconsByCallId.get(toolCallId);
+                            if (iconEl) {
+                                const newIcon = termData.commandLine?.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal;
+                                setThinkingIcon(iconEl, newIcon);
+                            }
+                        }
+                        if (toolInvocationOrMarkdown.presentation === "hidden") {
+                            this.pendingRemovals.push({
+                                toolCallId: toolInvocationOrMarkdown.toolCallId,
+                                toolLabel: currentToolLabel
+                            });
+                            this.schedulePendingRemovalsFlush();
+                            isComplete = true;
+                            return;
+                        }
+                    }
+                    if (currentState.type === IChatToolInvocation.StateKind.Completed || currentState.type === IChatToolInvocation.StateKind.Cancelled) {
+                        if (toolInvocationOrMarkdown.presentation === "hidden" || toolInvocationOrMarkdown.presentation === "hiddenAfterComplete") {
+                            this.pendingRemovals.push({
+                                toolCallId: toolInvocationOrMarkdown.toolCallId,
+                                toolLabel: currentToolLabel
+                            });
+                            this.schedulePendingRemovalsFlush();
+                        }
+                        if (currentState.type === IChatToolInvocation.StateKind.Completed) {
+                            this.updateExternalResourceParts(toolInvocationOrMarkdown);
+                            const completedMessage = toolInvocationOrMarkdown.pastTenseMessage ?? toolInvocationOrMarkdown.invocationMessage;
+                            const completedText = typeof completedMessage === "string" ? completedMessage : completedMessage.value;
+                            const iconElement = this.toolIconsByCallId.get(toolCallId);
+                            if (iconElement && isNoProblemsFoundResult(toolInvocationOrMarkdown.toolId, completedText)) {
+                                setThinkingIcon(iconElement, Codicon.search);
+                            }
+                        }
+                        isComplete = true;
+                        return;
+                    }
+                    if (currentState.type === IChatToolInvocation.StateKind.Streaming) {
+                        isStreaming = true;
+                        const streamingMessage = currentState.streamingMessage.read(reader);
+                        if (streamingMessage) {
+                            updateTitle(streamingMessage);
+                        }
+                        return;
+                    }
+                    if (currentState.type === IChatToolInvocation.StateKind.Executing) {
+                        const progressData = currentState.progress.read(reader);
+                        if (progressData.message) {
+                            updateTitle(progressData.message);
+                        } else {
+                            const invocationMsg = toolInvocationOrMarkdown.invocationMessage;
+                            if (invocationMsg) {
+                                updateTitle(invocationMsg);
+                            }
+                        }
+                        return;
+                    }
+                    const invocationMsg = toolInvocationOrMarkdown.invocationMessage;
+                    if (invocationMsg) {
+                        updateTitle(invocationMsg);
+                    }
+                });
+                toolStore.add(autorunDisposable);
+            }
+        } else if (toolInvocationOrMarkdown?.kind === "markdownContent") {
+            const codeblockInfo = extractCodeblockUrisFromText(toolInvocationOrMarkdown.content.value);
+            if (codeblockInfo?.uri) {
+                const filename = basename(codeblockInfo.uri);
+                toolCallLabel = ( localize(11632, "Edited {0}", filename));
+            } else {
+                toolCallLabel = ( localize(11633, "Edited file"));
+            }
+            toolCallTitle = toolCallLabel;
+        } else if (toolInvocationOrMarkdown?.kind === "externalEdit") {
+            const filename = basename(toolInvocationOrMarkdown.uri);
+            switch (toolInvocationOrMarkdown.editKind) {
+            case "create":
+                toolCallLabel = ( localize(11634, "Created {0}", filename));
+                break;
+            case "delete":
+                toolCallLabel = ( localize(11635, "Deleted {0}", filename));
+                break;
+            case "rename":
+                toolCallLabel = ( localize(11636, "Renamed {0}", filename));
+                break;
+            case "edit":
+                toolCallLabel = ( localize(11632, "Edited {0}", filename));
+                break;
+            }
+            toolCallTitle = toolCallLabel;
+        } else {
+            toolCallLabel = toolInvocationId;
+            toolCallTitle = toolCallLabel;
+        }
+        if (!this.extractedTitles.includes(toolCallLabel)) {
+            this.extractedTitles.push(toolCallLabel);
+        }
+        this.lastExtractedTitle = toolCallLabel;
+        if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+            this.setTitle(toolCallTitle);
+        }
+    }
+    updateExternalResourceParts(toolInvocation) {
+        if (toolInvocation.toolSpecificData?.kind === "terminal") {
+            return;
+        }
+        if (this.fixedScrollingMode && !this.streamingCompleted && !this.element.isComplete) {
+            this._pendingExternalResources.set(toolInvocation.toolCallId, toolInvocation);
+            return;
+        }
+        const extractedImages = extractImagesFromToolInvocationOutputDetails(toolInvocation, this.element.sessionResource);
+        if (extractedImages.length === 0) {
+            return;
+        }
+        const parts = extractedImages.map(image => ({
+            kind: "data",
+            value: image.data.buffer,
+            mimeType: image.mimeType,
+            uri: image.uri
+        }));
+        this._externalResourceWidget.setToolInvocationParts(toolInvocation.toolCallId, parts);
+    }
+    flushPendingExternalResources() {
+        if (this._pendingExternalResources.size === 0) {
+            return;
+        }
+        const pending = Array.from(( this._pendingExternalResources.values()));
+        this._pendingExternalResources.clear();
+        for (const toolInvocation of pending) {
+            this.updateExternalResourceParts(toolInvocation);
+        }
+    }
+    appendItemToDOM(content, toolInvocationId, toolInvocationOrMarkdown, originalParent) {
+        if (!content.hasChildNodes() || content.textContent?.trim() === "") {
+            return;
+        }
+        const itemWrapper = $(".chat-thinking-tool-wrapper");
+        const isMarkdownEdit = toolInvocationOrMarkdown?.kind === "markdownContent";
+        const isExternalEdit = toolInvocationOrMarkdown?.kind === "externalEdit";
+        const isTerminalTool = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") && toolInvocationOrMarkdown.toolSpecificData?.kind === "terminal";
+        const isSearchTool = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") && toolInvocationOrMarkdown.toolSpecificData?.kind === "search";
+        const toolInvocationIcon = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") ? toolInvocationOrMarkdown.icon : undefined;
+        let icon;
+        if (isNoProblemsFoundResult(toolInvocationId, content.textContent ?? undefined)) {
+            icon = Codicon.search;
+        } else if (isMarkdownEdit || isExternalEdit) {
+            icon = Codicon.pencil;
+        } else if (isSearchTool) {
+            icon = Codicon.search;
+        } else if (isTerminalTool) {
+            const terminalData = toolInvocationOrMarkdown.toolSpecificData;
+            const exitCode = terminalData?.terminalCommandState?.exitCode;
+            const isSandboxWrapped = terminalData?.commandLine?.isSandboxWrapped;
+            if (exitCode !== undefined && exitCode !== 0) {
+                icon = Codicon.error;
+            } else if (isSandboxWrapped) {
+                icon = Codicon.terminalSecure;
+            } else {
+                icon = toolInvocationIcon ?? Codicon.terminal;
+            }
+        } else if (content.classList.contains("chat-hook-outcome-blocked")) {
+            icon = Codicon.error;
+        } else if (content.classList.contains("chat-hook-outcome-warning")) {
+            icon = Codicon.warning;
+        } else {
+            icon = toolInvocationId ? getToolInvocationIcon(toolInvocationId, toolInvocationIcon, content.textContent ?? undefined) : Codicon.tools;
+        }
+        const iconElement = createThinkingIcon(icon);
+        itemWrapper.appendChild(iconElement);
+        itemWrapper.appendChild(content);
+        if (this.toolInvocationCount === 1 && this.hookCount === 0 && originalParent) {
+            const toolInvocation = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") ? toolInvocationOrMarkdown : undefined;
+            this.singleItemInfo = {
+                element: content,
+                thinkingWrapper: itemWrapper,
+                originalParent,
+                originalNextSibling: this.domNode,
+                restoreToOriginalParent: !!toolInvocation || isExternalEdit,
+                toolInvocation
+            };
+        } else {
+            this.singleItemInfo = undefined;
+        }
+        const isToolInvocation = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized");
+        if (isToolInvocation && toolInvocationOrMarkdown.toolCallId) {
+            this.toolWrappersByCallId.set(toolInvocationOrMarkdown.toolCallId, itemWrapper);
+            this.toolIconsByCallId.set(toolInvocationOrMarkdown.toolCallId, iconElement);
+        }
+        this.appendToWrapper(itemWrapper);
+        if (this.fixedScrollingMode && this.scrollableElement) {
+            if (this.childResizeObserver && !this.streamingCompleted) {
+                const observeDisposable = this.childResizeObserver.observe(itemWrapper);
+                const toolCallId = isToolInvocation ? toolInvocationOrMarkdown.toolCallId : undefined;
+                if (toolCallId) {
+                    let store = this.toolDisposables.get(toolCallId);
+                    if (!store) {
+                        store = ( new DisposableStore());
+                        this.toolDisposables.set(toolCallId, store);
+                    }
+                    store.add(observeDisposable);
+                } else {
+                    this._register(observeDisposable);
+                }
+            }
+            this.scheduleAppendRefresh();
+        }
+    }
+    scheduleAppendRefresh() {
+        if (this._pendingAppendRefresh.value) {
+            return;
+        }
+        this._pendingAppendRefresh.value = scheduleAtNextAnimationFrame(getWindow(this.wrapper), () => {
+            this._pendingAppendRefresh.clear();
+            if (this._store.isDisposed) {
+                return;
+            }
+            this.refreshContentHeight();
+            this.updateScrollDimensionsFromCache();
+        });
+    }
+    materializeLazyItem(item) {
+        if (item.kind === "thinking") {
+            this.appendToWrapper(item.textContainer);
+            this.textContainer = item.textContainer;
+            this.id = item.content.id;
+            this.updateThinking(item.content);
+            return;
+        }
+        if (this.workingSpinnerLabel) {
+            const isTerminalTool = item.toolInvocationOrMarkdown && (item.toolInvocationOrMarkdown.kind === "toolInvocation" || item.toolInvocationOrMarkdown.kind === "toolInvocationSerialized") && item.toolInvocationOrMarkdown.toolSpecificData?.kind === "terminal";
+            const category = isTerminalTool ? WorkingMessageCategory.Terminal : WorkingMessageCategory.Tool;
+            this.workingSpinnerLabel.textContent = this.getRandomWorkingMessage(category);
+        }
+        if (item.lazy.hasValue) {
+            const result = item.lazy.value;
+            if (!result.domNode.parentElement) {
+                this.appendItemToDOM(
+                    result.domNode,
+                    item.toolInvocationId,
+                    item.toolInvocationOrMarkdown,
+                    item.originalParent
+                );
+            }
+            return;
+        }
+        const result = item.lazy.value;
+        this.appendItemToDOM(
+            result.domNode,
+            item.toolInvocationId,
+            item.toolInvocationOrMarkdown,
+            item.originalParent
+        );
+        if (result.disposable) {
+            const toolCallId = item.toolInvocationOrMarkdown && (item.toolInvocationOrMarkdown.kind === "toolInvocation" || item.toolInvocationOrMarkdown.kind === "toolInvocationSerialized") ? item.toolInvocationOrMarkdown.toolCallId : undefined;
+            if (toolCallId) {
+                this.ownedToolParts.set(toolCallId, result.disposable);
+            } else {
+                this._register(result.disposable);
+            }
+        }
+    }
+    setupThinkingContainer(content) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.appendedItemCount++;
+        this.allThinkingParts.push(content);
+        const contentText = extractTextFromPart(content);
+        this.recordReasoningContent(contentText);
+        this.trackDroppedSummaryHeader(contentText);
+        this.textContainer = $(".chat-thinking-item.markdown-content");
+        if (this.childResizeObserver && this.fixedScrollingMode && !this.streamingCompleted) {
+            this._register(this.childResizeObserver.observe(this.textContainer));
+        }
+        if (content.value) {
+            if (this.isExpanded() || this.hasExpandedOnce || (this.fixedScrollingMode && !this.streamingCompleted)) {
+                this.appendToWrapper(this.textContainer);
+                this.id = content.id;
+                this.updateThinking(content);
+            } else {
+                this.content = content;
+                this.id = content.id;
+                const lazyThinking = {
+                    kind: "thinking",
+                    textContainer: this.textContainer,
+                    content
+                };
+                this.lazyItems.push(lazyThinking);
+            }
+            if (this.workingSpinnerLabel) {
+                this.workingSpinnerLabel.textContent = this.getRandomWorkingMessage(WorkingMessageCategory.Thinking);
+            }
+        }
+        this.updateDropdownClickability();
+    }
+    setTitle(title, omitPrefix) {
+        const titleValue = getThinkingTitleValue(title);
+        if (!titleValue || this.element.isComplete) {
+            return;
+        }
+        if (omitPrefix) {
+            this.clearTitleDetail();
+            if (this._collapseButton) {
+                const labelElement = this._collapseButton.labelElement;
+                labelElement.textContent = "";
+                const plainSpan = $("span");
+                plainSpan.textContent = titleValue;
+                labelElement.appendChild(plainSpan);
+                this._collapseButton.element.ariaLabel = titleValue;
+            }
+            this.forgetShimmerTitle();
+            this.currentTitle = titleValue;
+            return;
+        }
+        this.lastExtractedTitle = titleValue;
+        this.lastRenderedTitle = title;
+        this.currentTitle = ( localize(11637, "{0}: {1}", this.defaultTitle, titleValue));
+        if (!this._collapseButton) {
+            return;
+        }
+        const labelElement = this._collapseButton.labelElement;
+        this.setShimmerTitle(( localize(11638, "{0}: ", this.defaultTitle)));
+        this._titleDetailRendered.clear();
+        this._titleFileWidgetStore.clear();
+        const markdownTitle = typeof title === "string" ? ( new MarkdownString(title)) : title;
+        const result = this.chatContentMarkdownRenderer.render(markdownTitle);
+        result.element.classList.add("collapsible-title-content", "chat-thinking-title-detail");
+        renderFileWidgets(
+            result.element,
+            this.instantiationService,
+            this.chatMarkdownAnchorService,
+            this._titleFileWidgetStore
+        );
+        this._titleFileWidgetStore.add(addDisposableListener(result.element, EventType.CLICK, event => {
+            if (isHTMLElement(event.target) && event.target.closest("a, input")) {
+                return;
+            }
+            EventHelper.stop(event, true);
+            this.toggleExpanded();
+        }));
+        this._titleDetailRendered.value = result;
+        const previousTitleDetail = this.titleDetailContainer;
+        const hasTitleLinks = result.element.querySelector("a") !== null;
+        if (hasTitleLinks) {
+            const container = this._collapseButton.element.parentElement;
+            if (container) {
+                if (this._hoverChevron) {
+                    container.appendChild(this._hoverChevron);
+                }
+                container.insertBefore(result.element, this.diffButton?.element ?? this._hoverChevron ?? null);
+            }
+        } else {
+            labelElement.appendChild(result.element);
+            if (!this.diffButton && this._hoverChevron) {
+                this._collapseButton.element.appendChild(this._hoverChevron);
+            }
+        }
+        previousTitleDetail?.remove();
+        this.titleDetailContainer = result.element;
+        const renderedTitle = result.element.textContent?.trim() || titleValue;
+        const thinkingLabel = ( localize(11637, "{0}: {1}", this.defaultTitle, renderedTitle));
+        this._collapseButton.element.ariaLabel = thinkingLabel;
+        this._collapseButton.element.ariaExpanded = String(this.isExpanded());
+    }
+    clearTitleDetail() {
+        this.titleDetailContainer?.remove();
+        this.titleDetailContainer = undefined;
+        this._titleDetailRendered.clear();
+        this._titleFileWidgetStore.clear();
+    }
+    hasSameContent(other, _followingContent, _element) {
+        if (_element.isComplete) {
+            return true;
+        }
+        if ((other.kind === "toolInvocation" || other.kind === "toolInvocationSerialized") && other.toolSpecificData?.kind === "subagent" && !other.subAgentInvocationId) {
+            return false;
+        }
+        if (other.kind === "toolInvocation" || other.kind === "toolInvocationSerialized" || other.kind === "markdownContent" || other.kind === "hook") {
+            return true;
+        }
+        if (other.kind !== "thinking") {
+            return false;
+        }
+        return other?.id !== this.id;
+    }
+    dispose() {
+        this.isActive = false;
+        if (this.workingSpinnerElement) {
+            this.workingSpinnerElement.remove();
+            this.workingSpinnerElement = undefined;
+            this.workingSpinnerLabel = undefined;
+        }
+        this.pendingRemovalFlushDisposable?.dispose();
+        this.pendingRemovalFlushDisposable = undefined;
+        this.pendingScrollDisposable?.dispose();
+        super.dispose();
+    }
+};
+ChatThinkingContentPart = ChatThinkingContentPart_1 = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, IConfigurationService)), ( __param(6, IChatMarkdownAnchorService)), ( __param(7, ILanguageModelsService)), ( __param(8, IHoverService)), ( __param(9, ITelemetryService)), ( __param(10, IStorageService)), ( __param(11, IContextKeyService)), ( __param(12, IEditorService))], ChatThinkingContentPart));
+
+export { ChatThinkingContentPart, buildPhrasePool, createThinkingIcon, defaultThinkingMessages, getEffectiveThinkingDisplayMode, getToolInvocationIcon, maybePickFunWorkingMessage, splitReasoningSummaryRows };