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

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

@@ -1,17 +1,26 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { $, clearNode, hide } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { $, scheduleAtNextAnimationFrame, getWindow, clearNode, hide } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ThinkingDisplayMode, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { extractCodeblockUrisFromText } from '../../../common/widget/annotations.js';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { ChatCollapsibleContentPart } from './chatCollapsibleContentPart.js';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service';
 import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
@@ -22,33 +31,27 @@ import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 
 registerCss(chatThinkingContent);
 function extractTextFromPart(content) {
-    const raw = Array.isArray(content.value) ? content.value.join('') : (content.value || '');
+    const raw = Array.isArray(content.value) ? content.value.join("") : (content.value || "");
     return raw.trim();
 }
 function getToolInvocationIcon(toolId) {
     const lowerToolId = toolId.toLowerCase();
-    if (lowerToolId.includes('search') ||
-        lowerToolId.includes('grep') ||
-        lowerToolId.includes('find') ||
-        lowerToolId.includes('list') ||
-        lowerToolId.includes('semantic') ||
-        lowerToolId.includes('changes') ||
-        lowerToolId.includes('codebase')) {
+    if (lowerToolId.includes("search") || lowerToolId.includes("grep") || lowerToolId.includes("find") || lowerToolId.includes("list") || lowerToolId.includes("semantic") || lowerToolId.includes("changes") || lowerToolId.includes("codebase")) {
         return Codicon.search;
     }
-    if (lowerToolId.includes('read') ||
-        lowerToolId.includes('get_file') ||
-        lowerToolId.includes('problems')) {
-        return Codicon.eye;
+    if (lowerToolId.includes("read") || lowerToolId.includes("get_file") || lowerToolId.includes("problems")) {
+        return Codicon.book;
     }
-    if (lowerToolId.includes('edit') ||
-        lowerToolId.includes('create')) {
+    if (lowerToolId.includes("edit") || lowerToolId.includes("create")) {
         return Codicon.pencil;
     }
+    if (lowerToolId.includes("terminal")) {
+        return Codicon.terminal;
+    }
     return Codicon.tools;
 }
 function createThinkingIcon(icon) {
-    const iconElement = $('span.chat-thinking-icon');
+    const iconElement = $("span.chat-thinking-icon");
     iconElement.classList.add(...ThemeIcon.asClassNameArray(icon));
     return iconElement;
 }
@@ -56,67 +59,123 @@ function extractTitleFromThinkingContent(content) {
     const headerMatch = content.match(/^\*\*([^*]+)\*\*/);
     return headerMatch ? headerMatch[1] : undefined;
 }
+const THINKING_SCROLL_MAX_HEIGHT = 200;
+var WorkingMessageCategory;
+(function(WorkingMessageCategory) {
+    WorkingMessageCategory["Thinking"] = "thinking";
+    WorkingMessageCategory["Terminal"] = "terminal";
+    WorkingMessageCategory["Tool"] = "tool";
+})(WorkingMessageCategory || (WorkingMessageCategory = {}));
+const thinkingMessages = [( localize(5904, "Thinking...")), ( localize(5905, "Reasoning...")), ( localize(5906, "Considering...")), ( localize(5907, "Analyzing...")), ( localize(5908, "Evaluating..."))];
+const terminalMessages = [( localize(5909, "Executing...")), ( localize(5910, "Running...")), ( localize(5911, "Processing..."))];
+const toolMessages = [( localize(5912, "Processing...")), ( localize(5913, "Preparing...")), ( localize(5914, "Loading...")), ( localize(5915, "Analyzing...")), ( localize(5916, "Evaluating..."))];
 let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsibleContentPart {
-    constructor(content, context, chatContentMarkdownRenderer, instantiationService, configurationService, chatMarkdownAnchorService, languageModelsService, hoverService) {
+    getRandomWorkingMessage(category = WorkingMessageCategory.Tool) {
+        let pool = this.availableMessagesByCategory.get(category);
+        if (!pool || pool.length === 0) {
+            switch (category) {
+            case WorkingMessageCategory.Thinking:
+                pool = [...thinkingMessages];
+                break;
+            case WorkingMessageCategory.Terminal:
+                pool = [...terminalMessages];
+                break;
+            case WorkingMessageCategory.Tool:
+            default:
+                pool = [...toolMessages];
+                break;
+            }
+            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
+    ) {
         const initialText = extractTextFromPart(content);
-        const extractedTitle = extractTitleFromThinkingContent(initialText)
-            ?? 'Thinking...';
+        const extractedTitle = extractTitleFromThinkingContent(initialText) ?? "Working...";
         super(extractedTitle, context, undefined, hoverService);
         this.chatContentMarkdownRenderer = chatContentMarkdownRenderer;
+        this.streamingCompleted = streamingCompleted;
         this.instantiationService = instantiationService;
         this.configurationService = configurationService;
         this.chatMarkdownAnchorService = chatMarkdownAnchorService;
         this.languageModelsService = languageModelsService;
-        this.defaultTitle = ( localize(5673, 'Thinking...'));
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.defaultTitle = ( localize(5917, "Working..."));
         this.fixedScrollingMode = false;
+        this.autoScrollEnabled = true;
         this.extractedTitles = [];
         this.toolInvocationCount = 0;
-        this.streamingCompleted = false;
+        this.appendedItemCount = 0;
         this.isActive = true;
         this.toolInvocations = [];
+        this.lazyItems = [];
+        this.hasExpandedOnce = false;
+        this.availableMessagesByCategory = ( new Map());
+        this.toolWrappersByCallId = ( new Map());
+        this.toolDisposables = this._register(( new DisposableMap()));
+        this.pendingRemovals = [];
+        this.isUpdatingDimensions = false;
         this.id = content.id;
         this.content = content;
-        const configuredMode = this.configurationService.getValue('chat.agent.thinkingStyle') ?? ThinkingDisplayMode.Collapsed;
+        const configuredMode = this.configurationService.getValue("chat.agent.thinkingStyle") ?? ThinkingDisplayMode.Collapsed;
         this.fixedScrollingMode = configuredMode === ThinkingDisplayMode.FixedScrolling;
         this.currentTitle = extractedTitle;
         if (extractedTitle !== this.defaultTitle) {
             this.lastExtractedTitle = extractedTitle;
         }
         this.currentThinkingValue = initialText;
+        if (initialText.trim()) {
+            this.appendedItemCount++;
+        }
+        alert(( localize(5918, "Thinking")));
         if (configuredMode === ThinkingDisplayMode.Collapsed) {
             this.setExpanded(false);
-        }
-        else {
-            this.setExpanded(true);
-        }
-        if (this.fixedScrollingMode) {
+        } else if (configuredMode === ThinkingDisplayMode.CollapsedPreview) {
+            this.setExpanded(!this.streamingCompleted && !this.element.isComplete);
+        } else {
             this.setExpanded(false);
         }
         const node = this.domNode;
-        node.classList.add('chat-thinking-box');
-        node.tabIndex = 0;
+        node.classList.add("chat-thinking-box");
         if (this.fixedScrollingMode) {
-            node.classList.add('chat-thinking-fixed-mode');
+            node.classList.add("chat-thinking-fixed-mode");
             this.currentTitle = this.defaultTitle;
-            if (this._collapseButton && !this.context.element.isComplete) {
-                this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, 'spin');
-            }
         }
         this._register(autorun(r => {
-            this.expanded.read(r);
-            if (this._collapseButton && this.wrapper) {
-                if (this.wrapper.classList.contains('chat-thinking-streaming') && !this.context.element.isComplete) {
-                    this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, 'spin');
-                }
-                else {
+            const isExpanded = this.expanded.read(r);
+            if (this._collapseButton) {
+                if (this.streamingCompleted || this.element.isComplete) {
                     this._collapseButton.icon = Codicon.check;
+                } else if (!this.fixedScrollingMode) {
+                    if (isExpanded) {
+                        this._collapseButton.icon = Codicon.chevronDown;
+                    } else {
+                        this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, "spin");
+                    }
                 }
             }
         }));
-        if (this._collapseButton && !this.streamingCompleted && !this.context.element.isComplete) {
-            this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, 'spin');
-        }
-        const label = this.lastExtractedTitle ?? '';
+        this._register(autorun(r => {
+            if (this._isExpanded.read(r) && !this.hasExpandedOnce && this.lazyItems.length > 0) {
+                this.hasExpandedOnce = true;
+                for (const item of this.lazyItems) {
+                    this.materializeLazyItem(item);
+                }
+            }
+            this._onDidChangeHeight.fire();
+        }));
+        const label = this.lastExtractedTitle ?? "";
         if (!this.fixedScrollingMode && !this._isExpanded.get()) {
             this.setTitle(label);
         }
@@ -129,26 +188,156 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
                 if (expanded) {
                     this.setTitle(this.defaultTitle, true);
                     this.currentTitle = this.defaultTitle;
-                }
-                else if (this.lastExtractedTitle) {
-                    const collapsedLabel = this.lastExtractedTitle ?? '';
+                } else if (this.lastExtractedTitle) {
+                    const collapsedLabel = this.lastExtractedTitle ?? "";
                     this.setTitle(collapsedLabel);
                     this.currentTitle = collapsedLabel;
                 }
             }));
         }
     }
+    shouldInitEarly() {
+        return this.fixedScrollingMode && !this.streamingCompleted;
+    }
     initContent() {
-        this.wrapper = $('.chat-used-context-list.chat-thinking-collapsible');
-        this.wrapper.classList.add('chat-thinking-streaming');
-        if (this.currentThinkingValue) {
-            this.textContainer = $('.chat-thinking-item.markdown-content');
+        this.wrapper = $(".chat-used-context-list.chat-thinking-collapsible");
+        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) {
+            this.workingSpinnerElement = $(".chat-thinking-item.chat-thinking-spinner-item");
+            const spinnerIcon = createThinkingIcon(ThemeIcon.modify(Codicon.loading, "spin"));
+            this.workingSpinnerElement.appendChild(spinnerIcon);
+            this.workingSpinnerLabel = $("span.chat-thinking-spinner-label");
+            this.workingSpinnerLabel.textContent = this.getRandomWorkingMessage(WorkingMessageCategory.Thinking);
+            this.workingSpinnerElement.appendChild(this.workingSpinnerLabel);
+            this.wrapper.appendChild(this.workingSpinnerElement);
+        }
+        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)));
+            const mutationObserver = ( new MutationObserver(() => {
+                if (!this.streamingCompleted) {
+                    this.syncDimensionsAndScheduleScroll();
+                }
+            }));
+            mutationObserver.observe(this.wrapper, {
+                childList: true,
+                subtree: true,
+                characterData: true
+            });
+            this.mutationObserverDisposable = {
+                dispose: () => mutationObserver.disconnect()
+            };
+            this._register(this.mutationObserverDisposable);
+            this._register(this._onDidChangeHeight.event(() => {
+                this.syncDimensionsAndScheduleScroll();
+            }));
+            this.syncDimensionsAndScheduleScroll();
+            this.updateDropdownClickability();
+            return this.scrollableElement.getDomNode();
+        }
         this.updateDropdownClickability();
         return this.wrapper;
     }
+    handleScroll(scrollTop) {
+        if (!this.scrollableElement || this.isUpdatingDimensions) {
+            return;
+        }
+        const scrollDimensions = this.scrollableElement.getScrollDimensions();
+        const maxScrollTop = scrollDimensions.scrollHeight - scrollDimensions.height;
+        const isAtBottom = maxScrollTop <= 0 || scrollTop >= maxScrollTop - 10;
+        if (isAtBottom) {
+            this.autoScrollEnabled = true;
+        } else {
+            this.autoScrollEnabled = false;
+        }
+    }
+    syncDimensionsAndScheduleScroll() {
+        if (this.autoScrollEnabled && this.scrollableElement) {
+            this.isUpdatingDimensions = true;
+            try {
+                this.updateScrollDimensions();
+                this.scrollToBottom();
+            } finally {
+                this.isUpdatingDimensions = false;
+            }
+            return;
+        }
+        if (this.pendingScrollDisposable) {
+            return;
+        }
+        this.pendingScrollDisposable = scheduleAtNextAnimationFrame(getWindow(this.domNode), () => {
+            this.pendingScrollDisposable = undefined;
+            if (this._store.isDisposed) {
+                return;
+            }
+            this.isUpdatingDimensions = true;
+            try {
+                this.updateScrollDimensions();
+            } finally {
+                this.isUpdatingDimensions = false;
+            }
+        });
+    }
+    updateScrollDimensions() {
+        if (!this.scrollableElement) {
+            return;
+        }
+        const isCollapsed = this.domNode.classList.contains("chat-used-context-collapsed");
+        if (!isCollapsed) {
+            return;
+        }
+        const contentHeight = this.wrapper.scrollHeight;
+        const viewportHeight = Math.min(contentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        this.scrollableElement.setScrollDimensions({
+            width: this.scrollableElement.getDomNode().clientWidth,
+            scrollWidth: this.wrapper.scrollWidth,
+            height: viewportHeight,
+            scrollHeight: contentHeight
+        });
+    }
+    scrollToBottom() {
+        if (!this.scrollableElement) {
+            return;
+        }
+        const contentHeight = this.wrapper.scrollHeight;
+        const viewportHeight = Math.min(contentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        if (contentHeight > viewportHeight) {
+            this.scrollableElement.setScrollPosition({
+                scrollTop: contentHeight - viewportHeight
+            });
+        }
+    }
+    updateScrollDimensionsForCompletion() {
+        if (!this.scrollableElement || !this.fixedScrollingMode) {
+            return;
+        }
+        const contentHeight = this.wrapper.scrollHeight;
+        const viewportHeight = Math.min(contentHeight, THINKING_SCROLL_MAX_HEIGHT);
+        this.scrollableElement.setScrollDimensions({
+            width: this.scrollableElement.getDomNode().clientWidth,
+            scrollWidth: this.wrapper.scrollWidth,
+            height: viewportHeight,
+            scrollHeight: contentHeight
+        });
+        if (contentHeight <= THINKING_SCROLL_MAX_HEIGHT) {
+            this.scrollableElement.setScrollPosition({
+                scrollTop: 0
+            });
+        }
+    }
     renderMarkdown(content, reuseExisting) {
         if (this._store.isDisposed) {
             return;
@@ -159,11 +348,13 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
                 this.markdownResult.dispose();
                 this.markdownResult = undefined;
             }
-            clearNode(this.textContainer);
+            if (this.textContainer) {
+                clearNode(this.textContainer);
+            }
             return;
         }
         let contentToRender = cleanedContent;
-        if (cleanedContent.startsWith('**') && cleanedContent.endsWith('**')) {
+        if (cleanedContent.startsWith("**") && cleanedContent.endsWith("**")) {
             contentToRender = cleanedContent.slice(2, -2);
         }
         const target = reuseExisting ? this.markdownResult?.element : undefined;
@@ -175,21 +366,23 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
             fillInIncompleteTokens: true,
             asyncRenderCallback: () => this._onDidChangeHeight.fire(),
             codeBlockRendererSync: (_languageId, text, raw) => {
-                const codeElement = $('code');
+                const codeElement = $("code");
                 codeElement.textContent = text;
                 return codeElement;
             }
         }, target));
         this.markdownResult = rendered;
         if (!target) {
-            clearNode(this.textContainer);
-            this.textContainer.appendChild(createThinkingIcon(Codicon.comment));
-            this.textContainer.appendChild(rendered.element);
+            if (this.textContainer) {
+                clearNode(this.textContainer);
+                this.textContainer.appendChild(createThinkingIcon(Codicon.circleFilled));
+                this.textContainer.appendChild(rendered.element);
+            }
         }
     }
     setDropdownClickable(clickable) {
         if (this._collapseButton) {
-            this._collapseButton.element.style.pointerEvents = clickable ? 'auto' : 'none';
+            this._collapseButton.element.style.pointerEvents = clickable ? "auto" : "none";
         }
         if (!clickable && this.streamingCompleted) {
             super.setTitle(this.lastExtractedTitle ?? this.currentTitle);
@@ -199,20 +392,29 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
         if (!this.wrapper) {
             return;
         }
-        if (this.wrapper.children.length > 1 || this.toolInvocationCount > 0) {
+        if (this.wrapper.children.length > 1 || this.toolInvocationCount > 0 || this.lazyItems.length > 0) {
             this.setDropdownClickable(true);
             return;
         }
         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 stripMarkdown = text => {
+            return text.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").trim();
         };
         const strippedContent = stripMarkdown(contentWithoutTitle);
         const shouldDisable = !strippedContent || strippedContent === titleToCompare;
         this.setDropdownClickable(!shouldDisable);
     }
+    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);
+        }
+    }
     resetId() {
         this.id = undefined;
     }
@@ -224,6 +426,12 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
             return;
         }
         this.content = content;
+        for (const lazyItem of this.lazyItems) {
+            if (lazyItem.kind === "thinking" && lazyItem.content.id === content.id) {
+                lazyItem.content = content;
+                break;
+            }
+        }
         const raw = extractTextFromPart(content);
         const next = raw;
         if (next === this.currentThinkingValue) {
@@ -233,8 +441,8 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
         const reuseExisting = !!(this.markdownResult && next.startsWith(previousValue) && next.length > previousValue.length);
         this.currentThinkingValue = next;
         this.renderMarkdown(next, reuseExisting);
-        if (this.fixedScrollingMode && this.wrapper) {
-            this.wrapper.scrollTop = this.wrapper.scrollHeight;
+        if (this.fixedScrollingMode && this.scrollableElement) {
+            this.syncDimensionsAndScheduleScroll();
         }
         const extractedTitle = extractTitleFromThinkingContent(raw);
         if (extractedTitle && extractedTitle !== this.currentTitle) {
@@ -246,7 +454,7 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
         if (!extractedTitle || extractedTitle === this.currentTitle) {
             return;
         }
-        const label = this.lastExtractedTitle ?? '';
+        const label = this.lastExtractedTitle ?? "";
         if (!this.fixedScrollingMode && !this._isExpanded.get()) {
             this.setTitle(label);
         }
@@ -257,13 +465,32 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
     }
     markAsInactive() {
         this.isActive = false;
+        this.processPendingRemovals();
+        if (this.workingSpinnerElement) {
+            this.workingSpinnerElement.remove();
+            this.workingSpinnerElement = undefined;
+            this.workingSpinnerLabel = undefined;
+        }
     }
     finalizeTitleIfDefault() {
-        this.wrapper.classList.remove('chat-thinking-streaming');
+        this.processPendingRemovals();
+        if (this.wrapper) {
+            this.wrapper.classList.remove("chat-thinking-streaming");
+        }
         this.streamingCompleted = true;
+        if (this.mutationObserverDisposable) {
+            this.mutationObserverDisposable.dispose();
+            this.mutationObserverDisposable = undefined;
+        }
+        if (this.workingSpinnerElement) {
+            this.workingSpinnerElement.remove();
+            this.workingSpinnerElement = undefined;
+            this.workingSpinnerLabel = undefined;
+        }
         if (this._collapseButton) {
             this._collapseButton.icon = Codicon.check;
         }
+        this.updateScrollDimensionsForCompletion();
         this.updateDropdownClickability();
         if (this.content.generatedTitle) {
             this.currentTitle = this.content.generatedTitle;
@@ -277,8 +504,8 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
             super.setTitle(existingToolTitle);
             return;
         }
-        if (this.toolInvocationCount === 1 && this.currentThinkingValue.trim() === '' && this.singleToolItemInfo) {
-            this.restoreSingleToolToOriginalPosition();
+        if (this.appendedItemCount === 1 && this.currentThinkingValue.trim() === "" && this.singleItemInfo) {
+            this.restoreSingleItemToOriginalPosition();
             return;
         }
         if (this.extractedTitles.length === 1 && this.toolInvocationCount === 0) {
@@ -301,46 +528,144 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
         }
     }
     async generateTitleViaLLM() {
+        const cts = ( new CancellationTokenSource());
+        const timeout = setTimeout(() => cts.cancel(), 5000);
         try {
-            let models = await this.languageModelsService.selectLanguageModels({ vendor: 'copilot', id: 'copilot-fast' });
+            let models = await this.languageModelsService.selectLanguageModels({
+                vendor: "copilot",
+                id: "copilot-fast"
+            });
             if (!models.length) {
-                models = await this.languageModelsService.selectLanguageModels({ vendor: 'copilot', family: 'gpt-4o-mini' });
+                models = await this.languageModelsService.selectLanguageModels({
+                    vendor: "copilot",
+                    family: "gpt-4o-mini"
+                });
             }
             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.extractedTitles.join(", ");
+            } else {
                 context = this.currentThinkingValue.substring(0, 1000);
             }
-            const prompt = `Summarize the following actions in 6-7 words using past tense. Be very concise - focus on the main action only. No subjects, quotes, or punctuation.
+            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
+            - 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
+
+            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:
-			- "Preparing to create new page file, Read HomePage.tsx, Creating new TypeScript file" → "Created new page file"
-			- "Searching for files, Reading configuration, Analyzing dependencies" → "Analyzed project structure"
-			- "Invoked terminal command, Checked build output, Fixed errors" → "Ran build and fixed errors"
+            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"
 
-			Actions: ${context}`;
-            const response = await this.languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier('core')), [{ role: ChatMessageRole.User, content: [{ type: 'text', value: prompt }] }], {}, CancellationToken.None);
-            let generatedTitle = '';
+            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], ( new ExtensionIdentifier("core")), [{
+                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') {
+                        if (p.type === "text") {
                             generatedTitle += p.value;
                         }
                     }
-                }
-                else if (part.type === 'text') {
+                } 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;
                 if (this._collapseButton) {
@@ -350,36 +675,44 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
                 this.setGeneratedTitleOnToolInvocations(generatedTitle);
                 return;
             }
-        }
-        catch (error) {
+        } catch (error) {} finally {
+            clearTimeout(timeout);
+            cts.dispose();
         }
         this.setFallbackTitle();
     }
-    restoreSingleToolToOriginalPosition() {
-        if (!this.singleToolItemInfo) {
+    restoreSingleItemToOriginalPosition() {
+        if (!this.singleItemInfo) {
+            return;
+        }
+        const {
+            element,
+            originalParent,
+            originalNextSibling
+        } = this.singleItemInfo;
+        if (element.childElementCount > 1) {
+            this.singleItemInfo = undefined;
             return;
         }
-        const { element, originalParent, originalNextSibling } = this.singleToolItemInfo;
         if (originalNextSibling && originalNextSibling.parentNode === originalParent) {
             originalParent.insertBefore(element, originalNextSibling);
-        }
-        else {
+        } else {
             originalParent.appendChild(element);
         }
         hide(this.domNode);
-        this.singleToolItemInfo = undefined;
+        this.singleItemInfo = undefined;
     }
     setFallbackTitle() {
-        const finalLabel = this.toolInvocationCount > 0
-            ? ( localize(
-            5674,
-            'Finished thinking and invoked {0} tool{1}',
-            this.toolInvocationCount,
-            this.toolInvocationCount === 1 ? '' : 's'
-        ))
-            : ( localize(5675, 'Finished Thinking'));
+        const finalLabel = this.appendedItemCount > 0 ? ( localize(
+            5919,
+            "Finished with {0} step{1}",
+            this.appendedItemCount,
+            this.appendedItemCount === 1 ? "" : "s"
+        )) : ( localize(5920, "Finished Working"));
         this.currentTitle = finalLabel;
-        this.wrapper.classList.remove('chat-thinking-streaming');
+        if (this.wrapper) {
+            this.wrapper.classList.remove("chat-thinking-streaming");
+        }
         this.streamingCompleted = true;
         if (this._collapseButton) {
             this._collapseButton.icon = Codicon.check;
@@ -387,62 +720,295 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
         }
         this.updateDropdownClickability();
     }
-    appendItem(content, toolInvocationId, toolInvocation, originalParent) {
-        if (this.toolInvocationCount === 0 && originalParent) {
-            this.singleToolItemInfo = {
+    appendItem(factory, toolInvocationId, toolInvocationOrMarkdown, originalParent) {
+        this.processPendingRemovals();
+        this.trackToolMetadata(toolInvocationId, toolInvocationOrMarkdown);
+        this.appendedItemCount++;
+        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.toolDisposables.get(toolCallId)?.add(result.disposable);
+                } else {
+                    this._register(result.disposable);
+                }
+            }
+        } else {
+            const item = {
+                kind: "tool",
+                lazy: ( new Lazy(factory)),
+                toolInvocationId,
+                toolInvocationOrMarkdown,
+                originalParent
+            };
+            this.lazyItems.push(item);
+        }
+        this.updateDropdownClickability();
+    }
+    removeLazyItem(toolInvocationId) {
+        const index = this.lazyItems.findIndex(item => item.kind === "tool" && item.toolInvocationId === toolInvocationId);
+        if (index === -1) {
+            return false;
+        }
+        this.lazyItems.splice(index, 1);
+        this.appendedItemCount--;
+        this.toolInvocationCount--;
+        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();
+        return true;
+    }
+    processPendingRemovals() {
+        for (const pending of this.pendingRemovals) {
+            this.removeStreamingToolEntry(pending.toolCallId, pending.toolLabel);
+        }
+        this.pendingRemovals = [];
+    }
+    removeStreamingToolEntry(toolCallId, toolLabel) {
+        this.toolDisposables.deleteAndDispose(toolCallId);
+        const wrapper = this.toolWrappersByCallId.get(toolCallId);
+        if (wrapper) {
+            wrapper.remove();
+            this.toolWrappersByCallId.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) {
+            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.updateDropdownClickability();
+        this._onDidChangeHeight.fire();
+    }
+    trackToolMetadata(toolInvocationId, toolInvocationOrMarkdown) {
+        if (!toolInvocationId) {
+            return;
+        }
+        this.toolInvocationCount++;
+        let toolCallLabel;
+        const isToolInvocation = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized");
+        if (isToolInvocation && toolInvocationOrMarkdown.invocationMessage) {
+            const message = typeof toolInvocationOrMarkdown.invocationMessage === "string" ? toolInvocationOrMarkdown.invocationMessage : toolInvocationOrMarkdown.invocationMessage.value;
+            toolCallLabel = message;
+            this.toolInvocations.push(toolInvocationOrMarkdown);
+            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 = updatedMessage => {
+                    if (updatedMessage && 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;
+                        this.lastExtractedTitle = updatedMessage;
+                        if (!this.fixedScrollingMode && !this._isExpanded.read(undefined)) {
+                            this.setTitle(updatedMessage);
+                        }
+                    }
+                };
+                const autorunDisposable = autorun(reader => {
+                    if (isComplete) {
+                        return;
+                    }
+                    const currentState = toolInvocationOrMarkdown.state.read(reader);
+                    if (isStreaming && currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+                        isStreaming = false;
+                        if (toolInvocationOrMarkdown.presentation === "hidden") {
+                            this.pendingRemovals.push({
+                                toolCallId: toolInvocationOrMarkdown.toolCallId,
+                                toolLabel: currentToolLabel
+                            });
+                            isComplete = true;
+                            return;
+                        }
+                    }
+                    if (currentState.type === IChatToolInvocation.StateKind.Completed || currentState.type === IChatToolInvocation.StateKind.Cancelled) {
+                        isComplete = true;
+                        return;
+                    }
+                    if (currentState.type === IChatToolInvocation.StateKind.Streaming) {
+                        isStreaming = true;
+                        const streamingMessage = currentState.streamingMessage.read(reader);
+                        if (streamingMessage) {
+                            const updatedMessage = typeof streamingMessage === "string" ? streamingMessage : streamingMessage.value;
+                            updateTitle(updatedMessage);
+                        }
+                        return;
+                    }
+                    if (currentState.type === IChatToolInvocation.StateKind.Executing) {
+                        const progressData = currentState.progress.read(reader);
+                        if (progressData.message) {
+                            const updatedMessage = typeof progressData.message === "string" ? progressData.message : progressData.message.value;
+                            updateTitle(updatedMessage);
+                        } else {
+                            const invocationMsg = toolInvocationOrMarkdown.invocationMessage;
+                            if (invocationMsg) {
+                                const updatedMessage = typeof invocationMsg === "string" ? invocationMsg : invocationMsg.value;
+                                updateTitle(updatedMessage);
+                            }
+                        }
+                        return;
+                    }
+                    const invocationMsg = toolInvocationOrMarkdown.invocationMessage;
+                    if (invocationMsg) {
+                        const updatedMessage = typeof invocationMsg === "string" ? invocationMsg : invocationMsg.value;
+                        updateTitle(updatedMessage);
+                    }
+                });
+                toolStore.add(autorunDisposable);
+            }
+        } else if (toolInvocationOrMarkdown?.kind === "markdownContent") {
+            const codeblockInfo = extractCodeblockUrisFromText(toolInvocationOrMarkdown.content.value);
+            if (codeblockInfo?.uri) {
+                const filename = basename(codeblockInfo.uri);
+                toolCallLabel = ( localize(5921, "Edited {0}", filename));
+            } else {
+                toolCallLabel = ( localize(5922, "Edited file"));
+            }
+        } else {
+            toolCallLabel = `Invoked \`${toolInvocationId}\``;
+        }
+        if (!this.extractedTitles.includes(toolCallLabel)) {
+            this.extractedTitles.push(toolCallLabel);
+        }
+        this.lastExtractedTitle = toolCallLabel;
+        if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+            this.setTitle(toolCallLabel);
+        }
+    }
+    appendItemToDOM(content, toolInvocationId, toolInvocationOrMarkdown, originalParent) {
+        if (!content.hasChildNodes() || content.textContent?.trim() === "") {
+            return;
+        }
+        if (this.appendedItemCount === 1 && originalParent) {
+            this.singleItemInfo = {
                 element: content,
                 originalParent,
                 originalNextSibling: this.domNode
             };
+        } else {
+            this.singleItemInfo = undefined;
         }
-        else {
-            this.singleToolItemInfo = undefined;
+        const itemWrapper = $(".chat-thinking-tool-wrapper");
+        const isMarkdownEdit = toolInvocationOrMarkdown?.kind === "markdownContent";
+        const isTerminalTool = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized") && toolInvocationOrMarkdown.toolSpecificData?.kind === "terminal";
+        let icon;
+        if (isMarkdownEdit) {
+            icon = Codicon.pencil;
+        } else if (isTerminalTool) {
+            const terminalData = toolInvocationOrMarkdown.toolSpecificData;
+            const exitCode = terminalData?.terminalCommandState?.exitCode;
+            icon = exitCode !== undefined && exitCode !== 0 ? Codicon.error : Codicon.terminal;
+        } else {
+            icon = toolInvocationId ? getToolInvocationIcon(toolInvocationId) : Codicon.tools;
         }
-        const itemWrapper = $('.chat-thinking-tool-wrapper');
-        const icon = toolInvocationId ? getToolInvocationIcon(toolInvocationId) : Codicon.tools;
         const iconElement = createThinkingIcon(icon);
         itemWrapper.appendChild(iconElement);
         itemWrapper.appendChild(content);
-        this.wrapper.appendChild(itemWrapper);
-        if (toolInvocationId) {
-            this.toolInvocationCount++;
-            let toolCallLabel;
-            if (toolInvocation?.invocationMessage) {
-                const message = typeof toolInvocation.invocationMessage === 'string' ? toolInvocation.invocationMessage : toolInvocation.invocationMessage.value;
-                toolCallLabel = message;
-            }
-            else {
-                toolCallLabel = `Invoked \`${toolInvocationId}\``;
-            }
-            if (toolInvocation) {
-                this.toolInvocations.push(toolInvocation);
-            }
-            if (!this.extractedTitles.includes(toolCallLabel)) {
-                this.extractedTitles.push(toolCallLabel);
-            }
-            if (!this.fixedScrollingMode && !this._isExpanded.get()) {
-                this.setTitle(toolCallLabel);
-            }
+        const isToolInvocation = toolInvocationOrMarkdown && (toolInvocationOrMarkdown.kind === "toolInvocation" || toolInvocationOrMarkdown.kind === "toolInvocationSerialized");
+        if (isToolInvocation && toolInvocationOrMarkdown.toolCallId) {
+            this.toolWrappersByCallId.set(toolInvocationOrMarkdown.toolCallId, itemWrapper);
         }
-        if (this.fixedScrollingMode && this.wrapper) {
-            this.wrapper.scrollTop = this.wrapper.scrollHeight;
+        this.appendToWrapper(itemWrapper);
+        if (this.fixedScrollingMode && this.scrollableElement) {
+            this.syncDimensionsAndScheduleScroll();
         }
-        this.updateDropdownClickability();
     }
-    setupThinkingContainer(content, context) {
+    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) {
+            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.toolDisposables.get(toolCallId)?.add(result.disposable);
+            } else {
+                this._register(result.disposable);
+            }
+        }
+    }
+    setupThinkingContainer(content) {
         if (this._store.isDisposed) {
             return;
         }
-        this.textContainer = $('.chat-thinking-item.markdown-content');
+        this.appendedItemCount++;
+        this.textContainer = $(".chat-thinking-item.markdown-content");
         if (content.value) {
-            this.wrapper.appendChild(this.textContainer);
-            this.id = content.id;
-            this.updateThinking(content);
+            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) {
-        if (!title || this.context.element.isComplete) {
+        if (!title || this.element.isComplete) {
             return;
         }
         if (omitPrefix) {
@@ -450,16 +1016,16 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
             this.currentTitle = title;
             return;
         }
-        const thinkingLabel = `Thinking: ${title}`;
+        const thinkingLabel = `Working: ${title}`;
         this.lastExtractedTitle = title;
         this.currentTitle = thinkingLabel;
         this.setTitleWithWidgets(( new MarkdownString(thinkingLabel)), this.instantiationService, this.chatMarkdownAnchorService, this.chatContentMarkdownRenderer);
     }
     hasSameContent(other, _followingContent, _element) {
-        if (other.kind === 'toolInvocation' || other.kind === 'toolInvocationSerialized') {
+        if (other.kind === "toolInvocation" || other.kind === "toolInvocationSerialized" || other.kind === "markdownContent") {
             return true;
         }
-        if (other.kind !== 'thinking') {
+        if (other.kind !== "thinking") {
             return false;
         }
         return other?.id !== this.id;
@@ -469,15 +1035,15 @@ let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsi
             this.markdownResult.dispose();
             this.markdownResult = undefined;
         }
+        if (this.workingSpinnerElement) {
+            this.workingSpinnerElement.remove();
+            this.workingSpinnerElement = undefined;
+            this.workingSpinnerLabel = undefined;
+        }
+        this.pendingScrollDisposable?.dispose();
         super.dispose();
     }
 };
-ChatThinkingContentPart = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IChatMarkdownAnchorService)),
-    ( __param(6, ILanguageModelsService)),
-    ( __param(7, IHoverService))
-], ChatThinkingContentPart));
+ChatThinkingContentPart = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, IConfigurationService)), ( __param(6, IChatMarkdownAnchorService)), ( __param(7, ILanguageModelsService)), ( __param(8, IHoverService))], ChatThinkingContentPart));
 
-export { ChatThinkingContentPart };
+export { ChatThinkingContentPart, createThinkingIcon, getToolInvocationIcon };