@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.1

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

@@ -1,13 +1,12 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { $ as $$1, append, addDisposableListener, EventType, createElement, DisposableResizeObserver, clearNode, addStandardDisposableListener, WindowIntervalTimer, getWindow, reset, findParentWithClass } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { $ as $$1, append, addDisposableListener, EventType, createElement, DisposableResizeObserver, clearNode, addStandardDisposableListener, WindowIntervalTimer, getWindow, reset, findParentWithClass, hide, show } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { renderFormattedText } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/formattedTextRenderer';
 import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
 import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
 import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
 import { CachedListVirtualDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list';
 import { coalesce, distinct } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
 import { canceledName } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
@@ -15,7 +14,7 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
-import { Disposable, DisposableStore, dispose, toDisposable, thenIfNotDisposed } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, dispose, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { FileAccess, Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
@@ -44,12 +43,12 @@ import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { chatSubcommandLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { ChatAgentVoteDirection, ChatRequestQueueKind, IChatToolInvocation, isChatFollowup, ChatErrorLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatPlanReviewData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatPlanReviewData';
 import { ChatQuestionCarouselData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatQuestionCarouselData';
 import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { isResponseVM, isPendingDividerVM, isRequestVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
 import { getNWords } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatWordCounter';
-import { CodeBlockModelCollection } from '../../common/widget/codeBlockModelCollection.js';
 import { ChatConfiguration, ChatAgentLocation, CollapsedToolsDisplayMode, ThinkingDisplayMode, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ClickAnimation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/animations/animations';
 import { MarkHelpfulActionId } from '../actions/chatTitleActions.js';
@@ -68,13 +67,14 @@ import { InlineTextModelCollection } from './chatContentParts/chatContentParts.j
 import { ChatElicitationContentPart } from './chatContentParts/chatElicitationContentPart.js';
 import { ChatErrorConfirmationContentPart } from './chatContentParts/chatErrorConfirmationPart.js';
 import { ChatErrorContentPart } from './chatContentParts/chatErrorContentPart.js';
+import { ChatPlanReviewPart } from './chatContentParts/chatPlanReviewPart.js';
 import { ChatQuestionCarouselPart } from './chatContentParts/chatQuestionCarouselPart.js';
 import { ChatExtensionsContentPart } from './chatContentParts/chatExtensionsContentPart.js';
-import { codeblockHasClosingBackticks, ChatMarkdownContentPart } from './chatContentParts/chatMarkdownContentPart.js';
+import { ChatMarkdownContentPart, codeblockHasClosingBackticks } from './chatContentParts/chatMarkdownContentPart.js';
 import { ChatMcpServersInteractionContentPart } from './chatContentParts/chatMcpServersInteractionContentPart.js';
 import { ChatDisabledClaudeHooksContentPart } from './chatContentParts/chatDisabledClaudeHooksContentPart.js';
 import { ChatMultiDiffContentPart } from './chatContentParts/chatMultiDiffContentPart.js';
-import { ChatWorkingProgressContentPart, ChatProgressContentPart } from './chatContentParts/chatProgressContentPart.js';
+import { ChatWorkingProgressContentPart, ChatProgressSubPart, ChatProgressContentPart } from './chatContentParts/chatProgressContentPart.js';
 import { ChatPullRequestContentPart } from './chatContentParts/chatPullRequestContentPart.js';
 import { ChatQuotaExceededPart } from './chatContentParts/chatQuotaExceededPart.js';
 import { CollapsibleListPool, ChatUsedReferencesListContentPart } from './chatContentParts/chatReferencesContentPart.js';
@@ -90,6 +90,7 @@ import { ChatCodeBlockContentProvider } from './chatContentParts/codeBlockPart.j
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { ChatHookContentPart } from './chatContentParts/chatHookContentPart.js';
 import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
@@ -129,7 +130,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         editorOptions,
         rendererOptions,
         delegate,
-        codeBlockModelCollection,
         overflowWidgetsDomNode,
         viewModel,
         instantiationService,
@@ -144,12 +144,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         chatService,
         accessibilitySignalService,
         accessibilityService,
-        environmentService
+        environmentService,
+        telemetryService
     ) {
         super();
         this.rendererOptions = rendererOptions;
         this.delegate = delegate;
-        this.codeBlockModelCollection = codeBlockModelCollection;
         this.viewModel = viewModel;
         this.instantiationService = instantiationService;
         this.configService = configService;
@@ -164,6 +164,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.accessibilitySignalService = accessibilitySignalService;
         this.accessibilityService = accessibilityService;
         this.environmentService = environmentService;
+        this.telemetryService = telemetryService;
         this.codeBlocksByResponseId = ( new Map());
         this.codeBlocksByEditorUri = ( new ResourceMap());
         this.fileTreesByResponseId = ( new Map());
@@ -172,6 +173,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.responseTemplateDataByRequestId = ( new Map());
         this.pendingQuestionCarousels = ( new ResourceMap());
         this._notifiedQuestionCarousels = ( new Set());
+        this.workingProgressConfirmationEndListeners = ( new WeakSet());
         this._onDidClickFollowup = this._register(( new Emitter()));
         this.onDidClickFollowup = this._onDidClickFollowup.event;
         this._onDidClickRerunWithAgentOrCommandDetection = this._register(( new Emitter()));
@@ -190,17 +192,18 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this._currentLayoutWidth = observableValue(this, 0);
         this._isVisible = true;
         this._onDidChangeVisibility = this._register(( new Emitter()));
+        this._incrementalRenderingTelemetryLogged = false;
         this._announcedToolProgressKeys = ( new Set());
         this.chatContentMarkdownRenderer = this.instantiationService.createInstance(ChatContentMarkdownRenderer);
         this.markdownDecorationsRenderer = this.instantiationService.createInstance(ChatMarkdownDecorationsRenderer);
         this._editorPool = this._register(
-            this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, false)
+            this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, true)
         );
         this._toolEditorPool = this._register(
             this.instantiationService.createInstance(EditorPool, editorOptions, delegate, overflowWidgetsDomNode, true)
         );
         this._diffEditorPool = this._register(
-            this.instantiationService.createInstance(DiffEditorPool, editorOptions, delegate, overflowWidgetsDomNode, false)
+            this.instantiationService.createInstance(DiffEditorPool, editorOptions, delegate, overflowWidgetsDomNode, true)
         );
         this._treePool = this._register(
             this.instantiationService.createInstance(TreePool, this._onDidChangeVisibility.event)
@@ -211,11 +214,8 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             undefined,
             undefined
         ));
-        this._register(this.instantiationService.createInstance(ChatCodeBlockContentProvider));
         this._inlineTextModels = this._register(this.instantiationService.createInstance(InlineTextModelCollection));
-        this._toolInvocationCodeBlockCollection = this._register(
-            this.instantiationService.createInstance(CodeBlockModelCollection, "tools")
-        );
+        this._register(this.instantiationService.createInstance(ChatCodeBlockContentProvider));
         this._register(this.chatService.onDidSubmitRequest(e => {
             const carousels = this.pendingQuestionCarousels.get(e.chatSessionResource);
             if (carousels) {
@@ -265,6 +265,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             return;
         }
         const normalizedHeight = Math.ceil(height);
+        if (normalizedHeight === template.currentElement.currentRenderedHeight) {
+            return;
+        }
         template.currentElement.currentRenderedHeight = normalizedHeight;
         if (template.currentElement !== this._elementBeingRendered) {
             this._onDidChangeItemHeight.fire({
@@ -306,12 +309,13 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.fileTreesByResponseId.clear();
         this.focusedFileTreesByResponseId.clear();
         this.responseTemplateDataByRequestId.clear();
+        this.templateDataByRequestId.clear();
+        this._onDidUpdateViewModel.fire();
         this._editorPool.clear();
         this._toolEditorPool.clear();
         this._diffEditorPool.clear();
         this._treePool.clear();
         this._contentReferencesListPool.clear();
-        this._onDidUpdateViewModel.fire();
     }
     getCodeBlockInfoForEditor(uri) {
         return this.codeBlocksByEditorUri.get(uri);
@@ -460,7 +464,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const checkpointRestoreContainer = append(rowContainer, $(".checkpoint-restore-container"));
         append(checkpointRestoreContainer, $(".checkpoint-line-left"));
         const label = append(checkpointRestoreContainer, $("span.checkpoint-label-text"));
-        label.textContent = ( localize(6996, "Checkpoint Restored"));
+        label.textContent = ( localize(7116, "Checkpoint Restored"));
         const dot = append(checkpointRestoreContainer, $("span.checkpoint-dot-separator"));
         dot.textContent = "·";
         dot.setAttribute("aria-hidden", "true");
@@ -595,6 +599,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         templateData.footerToolbar.context = undefined;
         templateData.checkpointToolbar.context = undefined;
         templateData.checkpointRestoreToolbar.context = undefined;
+        templateData.currentElement = undefined;
     }
     renderChatTreeItem(element, index, templateData) {
         if (templateData.currentElement && templateData.currentElement.id !== element.id) {
@@ -667,6 +672,10 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             "show-detail-progress",
             isResponseVM(element) && !element.isComplete && !element.progressMessages.length && !progressMessageAtBottomOfResponse
         );
+        templateData.rowContainer.classList.toggle(
+            "chat-progress-reservable",
+            isResponseVM(element) && !element.isComplete && !!progressMessageAtBottomOfResponse
+        );
         const updateContainerCheckmarks = () => templateData.rowContainer.classList.toggle(
             "show-checkmarks",
             !!this.configService.getValue(AccessibilityWorkbenchSettingId.ShowChatCheckmarks)
@@ -680,14 +689,15 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (!this.rendererOptions.noHeader) {
             this.renderAvatar(element, templateData);
         }
+        const isSystemInitiatedRequest = isRequestVM(element) && !!element.isSystemInitiated;
         templateData.username.textContent = element.username;
         templateData.username.classList.toggle(
             "hidden",
-            element.username === COPILOT_USERNAME || this.environmentService.isSessionsWindow
+            element.username === COPILOT_USERNAME || this.environmentService.isSessionsWindow || isSystemInitiatedRequest
         );
         templateData.avatarContainer.classList.toggle(
             "hidden",
-            element.username === COPILOT_USERNAME || this.environmentService.isSessionsWindow
+            element.username === COPILOT_USERNAME || this.environmentService.isSessionsWindow || isSystemInitiatedRequest
         );
         this.hoverHidden(templateData.requestHover);
         clearNode(templateData.detail);
@@ -698,7 +708,10 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const supportsForkOrRestoration = this.rendererOptions.supportsFork || (this.rendererOptions.restorable ?? true);
         const checkpointEnabled = this.configService.getValue(ChatConfiguration.CheckpointsEnabled) && supportsForkOrRestoration;
         const isPendingRequest = isRequestVM(element) && !!element.pendingKind;
-        templateData.checkpointContainer.classList.toggle("hidden", isResponseVM(element) || isPendingRequest || !checkpointEnabled);
+        templateData.checkpointContainer.classList.toggle(
+            "hidden",
+            isResponseVM(element) || isPendingRequest || isSystemInitiatedRequest || !checkpointEnabled
+        );
         templateData.footerToolbar.refresh();
         templateData.checkpointToolbar.refresh();
         templateData.checkpointRestoreToolbar.refresh();
@@ -747,7 +760,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         templateData.requestHover.classList.toggle("editing", editing && isInput);
         templateData.requestHover.classList.toggle(
             "hidden",
-            (!!this.viewModel?.editing && !editing) || isResponseVM(element) || !this.rendererOptions.editable
+            (!!this.viewModel?.editing && !editing) || isResponseVM(element) || !this.rendererOptions.editable || isSystemInitiatedRequest
         );
         templateData.requestHover.classList.toggle("expanded", this.configService.getValue("chat.editRequests") === "hover");
         templateData.requestHover.classList.toggle("checkpoints-enabled", checkpointEnabled);
@@ -766,28 +779,38 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         rowRoot?.classList.toggle("response", isResponseVM(element));
         templateData.rowContainer.classList.toggle(mostRecentResponseClassName, index === this.delegate.getListLength() - 1);
         templateData.rowContainer.classList.toggle("confirmation-message", isRequestVM(element) && !!element.confirmation);
-        const shouldShowHeader = isResponseVM(element) && !this.rendererOptions.noHeader;
+        const shouldShowHeader = (isResponseVM(element) && !this.rendererOptions.noHeader) && !isSystemInitiatedRequest;
         templateData.header?.classList.toggle("header-disabled", !shouldShowHeader);
         if (isRequestVM(element) && element.confirmation) {
             this.renderConfirmationAction(element, templateData);
         }
+        const incrementalRendering = this.configService.getValue(ChatConfiguration.IncrementalRendering);
         if (isResponseVM(element) && index === this.delegate.getListLength() - 1 && (!element.isComplete || element.renderData)) {
             this.traceLayout("renderElement", `start progressive render, index=${index}`);
-            const timer = templateData.elementDisposables.add(new WindowIntervalTimer());
-            const runProgressiveRender = initial => {
-                try {
-                    if (this.doNextProgressiveRender(element, index, templateData, !!initial)) {
+            if (incrementalRendering && !element.renderData) {
+                this.logIncrementalRenderingTelemetry();
+                this.doIncrementalRender(element, index, templateData);
+            } else {
+                const timer = templateData.elementDisposables.add(new WindowIntervalTimer());
+                const runProgressiveRender = initial => {
+                    try {
+                        if (this.doNextProgressiveRender(element, index, templateData, !!initial)) {
+                            timer.cancel();
+                        }
+                    } catch (err) {
                         timer.cancel();
+                        this.logService.error(err);
                     }
-                } catch (err) {
-                    timer.cancel();
-                    this.logService.error(err);
-                }
-            };
-            timer.cancelAndSet(runProgressiveRender, 50, getWindow(templateData.rowContainer));
-            runProgressiveRender(true);
+                };
+                timer.cancelAndSet(runProgressiveRender, 50, getWindow(templateData.rowContainer));
+                runProgressiveRender(true);
+            }
         } else {
             if (isResponseVM(element)) {
+                if (incrementalRendering) {
+                    const rate = this.getProgressiveRenderRate(element);
+                    this._updateMorpherRate(templateData, rate, true);
+                }
                 this.renderChatResponseBasic(element, index, templateData);
             } else if (isRequestVM(element)) {
                 this.renderChatRequest(element, index, templateData);
@@ -813,11 +836,16 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const dividerContent = $$1(".pending-divider-content");
         const label = append(dividerContent, $$1("span.pending-divider-label"));
         if (element.dividerKind === ChatRequestQueueKind.Steering) {
-            label.textContent = ( localize(6997, "Steering"));
-            label.title = ( localize(6998, "Steering message will be sent after the next tool call happens"));
+            if (element.isSystemInitiated) {
+                label.textContent = ( localize(7117, "System Notification"));
+                label.title = ( localize(7118, "System notification will be sent after the next tool call happens"));
+            } else {
+                label.textContent = ( localize(7119, "Steering"));
+                label.title = ( localize(7120, "Steering message will be sent after the next tool call happens"));
+            }
         } else {
-            label.textContent = ( localize(6999, "Queued"));
-            label.title = ( localize(7000, "Queued messages will be sent after the current request completes"));
+            label.textContent = ( localize(7121, "Queued"));
+            label.title = ( localize(7122, "Queued messages will be sent after the current request completes"));
         }
         templateData.value.appendChild(dividerContent);
     }
@@ -825,10 +853,10 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         clearNode(templateData.detail);
         if (element.agentOrSlashCommandDetected) {
             const msg = element.slashCommand ? ( localize(
-                7001,
+                7123,
                 "used {0} [[(rerun without)]]",
                 `${chatSubcommandLeader}${element.slashCommand.name}`
-            )) : ( localize(7002, "[[(rerun without)]]"));
+            )) : ( localize(7124, "[[(rerun without)]]"));
             reset(templateData.detail, renderFormattedText(msg, {
                 actionHandler: {
                     disposables: templateData.elementDisposables,
@@ -841,7 +869,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             this.delegate.currentChatMode(),
             this.rendererOptions.progressMessageAtBottomOfResponse
         )) {
-            templateData.detail.textContent = ( localize(7003, "Working"));
+            templateData.detail.textContent = ( localize(7125, "Working"));
         }
     }
     renderConfirmationAction(element, templateData) {
@@ -850,7 +878,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             append(templateData.detail, $("span.codicon.codicon-check", {
                 "aria-hidden": "true"
             }));
-            append(templateData.detail, $("span.confirmation-text", undefined, ( localize(7004, "Selected \"{0}\"", element.confirmation))));
+            append(templateData.detail, $("span.confirmation-text", undefined, ( localize(7126, "Selected \"{0}\"", element.confirmation))));
             templateData.header?.classList.remove("header-disabled");
             templateData.header?.classList.add("partially-disabled");
         }
@@ -889,14 +917,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     }
     renderChatResponseBasic(element, index, templateData) {
         templateData.rowContainer.classList.toggle("chat-response-loading", (isResponseVM(element) && !element.isComplete));
-        if (element.isComplete || element.isCanceled) {
-            const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-            if (lastThinking?.domNode && lastThinking.getIsActive()) {
-                lastThinking.finalizeTitleIfDefault();
-                lastThinking.markAsInactive();
-            }
-            this.finalizeAllSubagentParts(templateData);
-        }
+        this.finalizeCompletedResponseParts(element, templateData);
         const content = [];
         const isFiltered = !!element.errorDetails?.responseIsFiltered;
         if (!isFiltered) {
@@ -923,57 +944,205 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (fileChangesSummaryPart) {
             content.push(fileChangesSummaryPart);
         }
+        const workingProgress = this.shouldShowWorkingProgress(element, content, false, templateData);
+        if (workingProgress) {
+            content.push(workingProgress);
+        }
         const diff = this.diff(templateData.renderedParts ?? [], content, element);
         this.renderChatContentDiff(diff, content, element, index, templateData);
+        this.finalizeCompletedResponseParts(element, templateData);
+    }
+    finalizeCompletedResponseParts(element, templateData) {
+        if (!element.isComplete && !element.isCanceled) {
+            return;
+        }
+        const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+        if (lastThinking?.domNode && lastThinking.getIsActive()) {
+            lastThinking.finalizeTitleIfDefault();
+            lastThinking.markAsInactive();
+        }
+        this.finalizeAllSubagentParts(templateData);
     }
     shouldShowWorkingProgress(element, partsToRender, moreContentAvailable, templateData) {
-        if (element.agentOrSlashCommandDetected || this.rendererOptions.renderStyle === "minimal" || element.isComplete || !checkModeOption(
+        if (element.agentOrSlashCommandDetected || this.rendererOptions.renderStyle === "minimal") {
+            return undefined;
+        }
+        const showProgressDetails = this.configService.getValue(ChatConfiguration.ChatPersistentProgressEnabled) !== false;
+        if (element.isComplete) {
+            return undefined;
+        }
+        const workingState = {
+            confirmationAdjustedTimestamp: element.confirmationAdjustedTimestamp,
+            completionTokenCountObs: element.completionTokenCountObs,
+            isComplete: element.isComplete,
+            completedAt: element.model.completedAt,
+            elapsedMs: element.model.elapsedMs
+        };
+        if (!checkModeOption(
             this.delegate.currentChatMode(),
             this.rendererOptions.progressMessageAtBottomOfResponse
         )) {
-            return false;
+            return undefined;
+        }
+        if (isResponseVM(element)) {
+            const widget = this.chatWidgetService.getWidgetBySessionResource(element.sessionResource);
+            if (widget?.inputPart.hasActiveToolConfirmationCarousel) {
+                const nonSubagentConfirmationCount = this.getPendingToolConfirmationCount(partsToRender, false);
+                if (nonSubagentConfirmationCount > 0) {
+                    return {
+                        kind: "working",
+                        content: ( new MarkdownString()).appendText(this.getConfirmationPendingLabel(nonSubagentConfirmationCount))
+                    };
+                }
+                if (this.getPendingToolConfirmationCount(partsToRender, true) > 0 || this.getSubagentPart(templateData.renderedParts)) {
+                    return undefined;
+                }
+                return {
+                    kind: "working",
+                    content: ( new MarkdownString()).appendText(this.getConfirmationPendingLabel(1))
+                };
+            }
+        }
+        let lastPart;
+        for (let i = partsToRender.length - 1; i >= 0; i--) {
+            const part = partsToRender[i];
+            if (part.kind !== "markdownContent" || part.content.value.trim().length > 0) {
+                lastPart = part;
+                break;
+            }
+        }
+        if (showProgressDetails) {
+            const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
+            if (lastThinking?.getIsActive() && !lastThinking.isFixedScrollingMode) {
+                return undefined;
+            }
+            if (lastPart?.kind === "progressMessage") {
+                return undefined;
+            }
+            return {
+                kind: "working",
+                state: workingState
+            };
         }
         if (( partsToRender.some(
             part => part.kind === "toolInvocation" && IChatToolInvocation.isStreaming(part)
         ))) {
-            return false;
+            return undefined;
         }
         if (( partsToRender.some(
             part => part.kind === "toolInvocation" && !IChatToolInvocation.isComplete(part) && isMcpToolInvocation(part)
         ))) {
-            return false;
+            return undefined;
         }
-        const lastPart = findLast(
-            partsToRender,
-            part => part.kind !== "markdownContent" || part.content.value.trim().length > 0
-        );
         const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
         if (lastThinking) {
-            return false;
+            return undefined;
         }
         if (lastPart && (lastPart.kind === "toolInvocation" || lastPart.kind === "toolInvocationSerialized")) {
             if (lastPart.isAttachedToThinking) {
-                return false;
+                return undefined;
             }
             const collapsedToolsMode = this.configService.getValue("chat.agent.thinking.collapsedTools");
             if (collapsedToolsMode !== CollapsedToolsDisplayMode.Off && this.shouldPinPart(lastPart, isResponseVM(element) ? element : undefined)) {
-                return false;
+                return undefined;
             }
         }
         const hasRenderedThinkingPart = ( (templateData.renderedParts ?? []).some(part => part instanceof ChatThinkingContentPart));
         const hasEditPillMarkdown = ( partsToRender.some(part => part.kind === "markdownContent" && this.hasEditCodeblockUri(part)));
         if (hasRenderedThinkingPart && hasEditPillMarkdown) {
-            return false;
+            return undefined;
         }
         if (this.getSubagentPart(templateData.renderedParts)) {
-            return false;
+            return undefined;
         }
-        if (!lastPart || lastPart.kind === "references" || (lastPart.kind === "markdownContent" && !moreContentAvailable && this.hasBeenCaughtUpLongEnough(element)) || ((lastPart.kind === "toolInvocation" || lastPart.kind === "toolInvocationSerialized") && (IChatToolInvocation.isComplete(lastPart) || lastPart.presentation === "hidden")) || ((lastPart.kind === "textEditGroup" || lastPart.kind === "notebookEditGroup") && lastPart.done && !( partsToRender.some(
+        if (!lastPart || lastPart.kind === "references" || (lastPart.kind === "markdownContent" && !moreContentAvailable && this.hasBeenCaughtUpLongEnough(element)) || ((lastPart.kind === "toolInvocation" || lastPart.kind === "toolInvocationSerialized") && (IChatToolInvocation.isComplete(lastPart) || IChatToolInvocation.isEffectivelyHidden(lastPart))) || ((lastPart.kind === "textEditGroup" || lastPart.kind === "notebookEditGroup") && lastPart.done && !( partsToRender.some(
             part => part.kind === "toolInvocation" && !IChatToolInvocation.isComplete(part)
         ))) || (lastPart.kind === "progressTask" && lastPart.deferred.isSettled) || lastPart.kind === "mcpServersStarting" || lastPart.kind === "disabledClaudeHooks" || lastPart.kind === "hook") {
-            return true;
+            return {
+                kind: "working"
+            };
         }
-        return false;
+        return undefined;
+    }
+    getPendingToolConfirmationCount(parts, includeSubagentConfirmations) {
+        return parts.filter(part => {
+            if (part.kind !== "toolInvocation") {
+                return false;
+            }
+            const state = part.state.get();
+            return state.type === IChatToolInvocation.StateKind.WaitingForConfirmation && !!state.confirmationMessages?.title && part.presentation !== "hidden" && part.source.type !== "mcp" && (isSubagentToolInvocation(part) === includeSubagentConfirmations);
+        }).length;
+    }
+    getConfirmationPendingLabel(count) {
+        return count === 1 ? ( localize(7127, "1 confirmation pending")) : ( localize(7128, "{0} confirmations pending", count));
+    }
+    removeWorkingProgressContentPart(templateData) {
+        const renderedParts = templateData.renderedParts;
+        if (!renderedParts) {
+            return;
+        }
+        for (let i = renderedParts.length - 1; i >= 0; i--) {
+            const part = renderedParts[i];
+            if (part instanceof ChatWorkingProgressContentPart) {
+                part.dispose();
+                part.domNode?.remove();
+                renderedParts.splice(i, 1);
+                this.fireItemHeightChange(templateData);
+                return;
+            }
+        }
+    }
+    updateWorkingProgressForPendingConfirmations(templateData) {
+        const element = templateData.currentElement;
+        if (!isResponseVM(element)) {
+            return;
+        }
+        if (element.isComplete && this.configService.getValue(ChatConfiguration.ChatPersistentProgressEnabled) !== false) {
+            return;
+        }
+        const pendingConfirmationCount = this.getPendingToolConfirmationCount(element.response.value, false);
+        if (pendingConfirmationCount === 0) {
+            this.removeWorkingProgressContentPart(templateData);
+            return;
+        }
+        const workingProgressPart = this.getWorkingProgressContentPart(templateData);
+        if (workingProgressPart) {
+            workingProgressPart.updateWorkingContent(( new MarkdownString()).appendText(this.getConfirmationPendingLabel(pendingConfirmationCount)));
+        }
+    }
+    getWorkingProgressContentPart(templateData) {
+        const renderedParts = templateData.renderedParts;
+        if (!renderedParts) {
+            return undefined;
+        }
+        for (let i = renderedParts.length - 1; i >= 0; i--) {
+            const part = renderedParts[i];
+            if (part instanceof ChatWorkingProgressContentPart) {
+                return part;
+            }
+        }
+        return undefined;
+    }
+    createUpdateWorkingProgressOnConfirmationEnd(toolInvocation, templateData) {
+        if (( this.workingProgressConfirmationEndListeners.has(toolInvocation))) {
+            return undefined;
+        }
+        this.workingProgressConfirmationEndListeners.add(toolInvocation);
+        let wasWaitingForConfirmation = false;
+        const disposable = autorun(reader => {
+            const currentState = toolInvocation.state.read(reader);
+            const isWaitingForConfirmation = currentState.type === IChatToolInvocation.StateKind.WaitingForConfirmation;
+            if (wasWaitingForConfirmation && !isWaitingForConfirmation) {
+                this.updateWorkingProgressForPendingConfirmations(templateData);
+                this.workingProgressConfirmationEndListeners.delete(toolInvocation);
+                disposable.dispose();
+            }
+            wasWaitingForConfirmation = isWaitingForConfirmation;
+        });
+        return toDisposable(() => {
+            this.workingProgressConfirmationEndListeners.delete(toolInvocation);
+            disposable.dispose();
+        });
     }
     hasBeenCaughtUpLongEnough(element) {
         const lastRenderTime = element.renderData?.lastRenderTime;
@@ -998,6 +1167,11 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     renderChatRequest(element, index, templateData) {
         templateData.rowContainer.classList.toggle("chat-response-loading", false);
         templateData.rowContainer.classList.toggle("pending-request", !!element.pendingKind);
+        templateData.rowContainer.classList.toggle("system-initiated-request", !!element.isSystemInitiated);
+        if (element.isSystemInitiated) {
+            this.renderSystemInitiatedRequest(element, templateData);
+            return;
+        }
         if (element.pendingKind && this._pendingDragController) {
             templateData.rowContainer.dataset.pendingRequestId = element.id;
             templateData.rowContainer.dataset.pendingKind = element.pendingKind;
@@ -1064,7 +1238,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 container: templateData.rowContainer,
                 editorPool: this._editorPool,
                 diffEditorPool: this._diffEditorPool,
-                codeBlockModelCollection: this.codeBlockModelCollection,
                 currentWidth: this._currentLayoutWidth,
                 onDidChangeVisibility: this._onDidChangeVisibility.event,
                 inlineTextModels: this._inlineTextModels,
@@ -1102,13 +1275,73 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         templateData.renderedParts = parts;
         if (element.variables.length) {
-            const newPart = this.renderAttachments(element.variables, element.contentReferences, templateData);
+            const newPart = this.renderAttachments(
+                element.variables,
+                element.contentReferences,
+                element.modelId,
+                templateData
+            );
             if (newPart.domNode) {
                 templateData.value.appendChild(newPart.domNode);
             }
             templateData.elementDisposables.add(newPart);
         }
     }
+    renderSystemInitiatedRequest(element, templateData) {
+        clearNode(templateData.value);
+        if (templateData.renderedParts) {
+            dispose(templateData.renderedParts);
+        }
+        templateData.renderedParts = [];
+        const label = element.systemInitiatedLabel ?? element.messageText;
+        const rendered = this.chatContentMarkdownRenderer.render(( new MarkdownString(label)));
+        templateData.elementDisposables.add(rendered);
+        rendered.element.classList.add("progress-step");
+        const progressPart = this.instantiationService.createInstance(ChatProgressSubPart, rendered.element, Codicon.check, undefined);
+        templateData.elementDisposables.add(progressPart);
+        templateData.value.appendChild(progressPart.domNode);
+    }
+    doIncrementalRender(element, index, templateData) {
+        if (!this._isVisible) {
+            return;
+        }
+        const rate = this.getProgressiveRenderRate(element);
+        this._updateMorpherRate(templateData, rate, element.isComplete || element.isCanceled);
+        if (element.isCanceled || element.isComplete) {
+            element.renderData = undefined;
+            templateData.rowContainer.classList.toggle("chat-response-loading", false);
+            this.renderChatResponseBasic(element, index, templateData);
+            return;
+        }
+        templateData.rowContainer.classList.toggle("chat-response-loading", true);
+        const contentForThisTurn = this.getNextProgressiveRenderContent(element, templateData);
+        const partsToRender = this.diff(templateData.renderedParts ?? [], contentForThisTurn.content, element);
+        const contentIsAlreadyRendered = partsToRender.every(part => part === null);
+        if (!contentIsAlreadyRendered) {
+            this.renderChatContentDiff(partsToRender, contentForThisTurn.content, element, index, templateData);
+        }
+    }
+    _updateMorpherRate(templateData, rate, isComplete) {
+        const renderedParts = templateData.renderedParts;
+        if (!renderedParts) {
+            return;
+        }
+        for (const part of renderedParts) {
+            if (part instanceof ChatMarkdownContentPart) {
+                part.updateStreamRate(rate, isComplete);
+            }
+        }
+    }
+    logIncrementalRenderingTelemetry() {
+        if (this._incrementalRenderingTelemetryLogged) {
+            return;
+        }
+        this._incrementalRenderingTelemetryLogged = true;
+        this.telemetryService.publicLog2("chatIncrementalRenderingSettings", {
+            animationStyle: this.configService.getValue(ChatConfiguration.IncrementalRenderingStyle) ?? "none",
+            buffering: this.configService.getValue(ChatConfiguration.IncrementalRenderingBuffering) ?? "word"
+        });
+    }
     doNextProgressiveRender(element, index, templateData, isInRenderElement) {
         if (!this._isVisible) {
             return true;
@@ -1187,6 +1420,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     renderedParts[contentIndex] = alreadyRenderedPart;
                     return;
                 }
+                if (partToRender.kind === "markdownContent" && alreadyRenderedPart instanceof ChatMarkdownContentPart && this.configService.getValue(ChatConfiguration.IncrementalRendering)) {
+                    if (alreadyRenderedPart.tryIncrementalUpdate(partToRender)) {
+                        renderedParts[contentIndex] = alreadyRenderedPart;
+                        return;
+                    }
+                }
                 alreadyRenderedPart.dispose();
                 if (alreadyRenderedPart.domNode) {
                     const thinkingToolWrapper = findParentWithClass(alreadyRenderedPart.domNode, "chat-thinking-tool-wrapper");
@@ -1203,7 +1442,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 container: templateData.rowContainer,
                 editorPool: this._editorPool,
                 diffEditorPool: this._diffEditorPool,
-                codeBlockModelCollection: this.codeBlockModelCollection,
                 currentWidth: this._currentLayoutWidth,
                 onDidChangeVisibility: this._onDidChangeVisibility.event,
                 inlineTextModels: this._inlineTextModels,
@@ -1212,12 +1450,13 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             };
             const lastThinking = this.getLastThinkingPart(renderedParts);
             if (lastThinking && (partToRender.kind === "toolInvocation" || partToRender.kind === "toolInvocationSerialized" || partToRender.kind === "markdownContent" || partToRender.kind === "textEditGroup" || partToRender.kind === "hook") && this.shouldPinPart(partToRender, element)) {
+                if (alreadyRenderedPart instanceof ChatMarkdownContentPart) {
+                    lastThinking.removeEditPillByPartId(alreadyRenderedPart.codeblocksPartId);
+                }
                 const newPart = this.renderChatContentPart(partToRender, templateData, context);
                 if (newPart) {
                     renderedParts[contentIndex] = newPart;
-                    if (alreadyRenderedPart instanceof ChatWorkingProgressContentPart && alreadyRenderedPart?.domNode) {
-                        alreadyRenderedPart.domNode.remove();
-                    }
+                    alreadyRenderedPart?.domNode?.remove();
                 }
                 return;
             }
@@ -1253,6 +1492,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     getNextProgressiveRenderContent(element, templateData) {
         const data = this.getDataForProgressiveRender(element);
         const renderImmediately = this.configService.getValue("chat.experimental.renderMarkdownImmediately") === true;
+        const incrementalRendering = this.configService.getValue(ChatConfiguration.IncrementalRendering) === true;
         const renderableResponse = annotateSpecialMarkdownContent(element.response.value);
         this.traceLayout(
             "getNextProgressiveRenderContent",
@@ -1267,7 +1507,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         let moreContentAvailable = false;
         for (let i = 0; i < renderableResponse.length; i++) {
             const part = renderableResponse[i];
-            if (part.kind === "markdownContent" && !renderImmediately) {
+            if (part.kind === "markdownContent" && !renderImmediately && !incrementalRendering) {
                 const wordCountResult = getNWords(part.content.value, numNeededWords);
                 this.traceLayout(
                     "getNextProgressiveRenderContent",
@@ -1315,10 +1555,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 renderedParts: partsToRender
             };
         }
-        if (this.shouldShowWorkingProgress(element, partsToRender, moreContentAvailable, templateData)) {
-            partsToRender.push({
-                kind: "working"
-            });
+        const workingProgress = this.shouldShowWorkingProgress(element, partsToRender, moreContentAvailable, templateData);
+        if (workingProgress) {
+            partsToRender.push(workingProgress);
         }
         const fileChangesSummaryPart = this.getChatFileChangesSummaryPart(element);
         if (fileChangesSummaryPart) {
@@ -1487,7 +1726,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             return;
         }
         for (const part of templateData.renderedParts) {
-            if (part instanceof ChatSubagentContentPart && part.getIsActive()) {
+            if (part instanceof ChatSubagentContentPart && part.getIsActive() && !part.hasToolsWaitingForConfirmation) {
                 part.markAsInactive();
             }
         }
@@ -1496,6 +1735,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         this.finalizeCurrentThinkingPart(context, templateData);
         const lastSubagent = this.getSubagentPart(templateData.renderedParts, subagentId);
         if (lastSubagent) {
+            this.maybeRouteSubagentToolToCarousel(toolInvocation, lastSubagent, context, templateData, codeBlockStartIndex);
             if (!isParentSubagentTool(toolInvocation)) {
                 lastSubagent.appendToolInvocation(toolInvocation, codeBlockStartIndex);
             }
@@ -1510,14 +1750,69 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             this._contentReferencesListPool,
             this._toolEditorPool,
             () => this._currentLayoutWidth.get(),
-            this._toolInvocationCodeBlockCollection,
             this._announcedToolProgressKeys
         );
+        this.maybeRouteSubagentToolToCarousel(toolInvocation, subagentPart, context, templateData, codeBlockStartIndex);
         if (!isParentSubagentTool(toolInvocation)) {
             subagentPart.appendToolInvocation(toolInvocation, codeBlockStartIndex);
         }
         return subagentPart;
     }
+    maybeRouteSubagentToolToCarousel(toolInvocation, subagentPart, context, templateData, codeBlockStartIndex) {
+        if (!this.configService.getValue(ChatConfiguration.ToolConfirmationCarousel)) {
+            return;
+        }
+        if (toolInvocation.kind !== "toolInvocation" || !isResponseVM(context.element)) {
+            return;
+        }
+        if (isParentSubagentTool(toolInvocation) || toolInvocation.presentation === "hidden" || toolInvocation.source.type === "mcp") {
+            return;
+        }
+        if (!!this.viewModel?.editing) {
+            return;
+        }
+        const widget = this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource);
+        if (!widget) {
+            return;
+        }
+        const subAgentInvocationId = subagentPart.subAgentInvocationId;
+        const agentName = subagentPart.getAgentLabel();
+        const scrollToSubagent = targetSubAgentId => {
+            const currentTemplateData = this.getTemplateDataForRequestId(context.element.id);
+            const currentSubagentPart = this.getSubagentPart(currentTemplateData?.renderedParts, targetSubAgentId) ?? subagentPart;
+            currentSubagentPart.domNode.scrollIntoView({
+                behavior: "smooth",
+                block: "center"
+            });
+        };
+        const navigateToCarousel = targetSubAgentId => {
+            widget.inputPart.activateCarouselForSubagent(targetSubAgentId);
+        };
+        const factory = tool => this.instantiationService.createInstance(
+            ChatToolInvocationPart,
+            tool,
+            context,
+            this.chatContentMarkdownRenderer,
+            this._contentReferencesListPool,
+            this._toolEditorPool,
+            () => this._currentLayoutWidth.get(),
+            this._announcedToolProgressKeys,
+            codeBlockStartIndex
+        );
+        const addToolToCarousel = tool => {
+            widget.inputPart.addToolToConfirmationCarousel(tool, factory, subAgentInvocationId, agentName, scrollToSubagent);
+            const listener = this.createUpdateWorkingProgressOnConfirmationEnd(tool, templateData);
+            if (listener) {
+                templateData.elementDisposables.add(listener);
+            }
+        };
+        const shouldUseCarouselForTool = (tool, state) => this.configService.getValue(ChatConfiguration.ToolConfirmationCarousel) && !this.viewModel?.editing && tool.presentation !== "hidden" && tool.source.type !== "mcp" && state.type === IChatToolInvocation.StateKind.WaitingForConfirmation && !!state.confirmationMessages?.title;
+        subagentPart.enableCarouselMode(navigateToCarousel, addToolToCarousel, shouldUseCarouselForTool);
+        const toolState = toolInvocation.state.get();
+        if (toolState.type === IChatToolInvocation.StateKind.WaitingForConfirmation && toolState.confirmationMessages?.title) {
+            addToolToCarousel(toolInvocation);
+        }
+    }
     finalizeCurrentThinkingPart(context, templateData) {
         const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
         if (!lastThinking) {
@@ -1541,19 +1836,19 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             const isResponseElement = isResponseVM(context.element);
             const shouldPin = this.shouldPinPart(content, isResponseElement ? context.element : undefined);
             if (context.element.isComplete && !shouldPin) {
-                for (const templateData of ( this.templateDataByRequestId.values())) {
-                    if (templateData.renderedParts) {
-                        const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-                        if (lastThinking?.getIsActive()) {
-                            this.finalizeCurrentThinkingPart(context, templateData);
-                        }
+                const elementTemplateData = this.getTemplateDataForRequestId(context.element.id);
+                if (elementTemplateData?.renderedParts) {
+                    const lastThinking = this.getLastThinkingPart(elementTemplateData.renderedParts);
+                    if (lastThinking?.getIsActive()) {
+                        this.finalizeCurrentThinkingPart(context, elementTemplateData);
                     }
                 }
             }
             const isSubagentContent = (content.kind === "toolInvocation" || content.kind === "toolInvocationSerialized") && isSubagentToolInvocation(content);
             if (context.element.isComplete && !isSubagentContent) {
-                for (const templateData of ( this.templateDataByRequestId.values())) {
-                    this.finalizeAllSubagentParts(templateData);
+                const elementTemplateData = this.getTemplateDataForRequestId(context.element.id);
+                if (elementTemplateData) {
+                    this.finalizeAllSubagentParts(elementTemplateData);
                 }
             }
             if (content.kind === "treeData") {
@@ -1620,6 +1915,8 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 return this.renderElicitation(context, content, templateData);
             } else if (content.kind === "questionCarousel") {
                 return this.renderQuestionCarousel(context, content, templateData);
+            } else if (content.kind === "planReview") {
+                return this.renderPlanReview(context, content);
             } else if (content.kind === "changesSummary") {
                 return this.renderChangesSummary(content, context, templateData);
             } else if (content.kind === "mcpServersStarting") {
@@ -1643,7 +1940,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 "ChatListItemRenderer#renderChatContentPart: error rendering content",
                 toErrorMessage(err, true)
             );
-            const errorPart = this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Error, ( new MarkdownString(( localize(7005, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
+            const errorPart = this.instantiationService.createInstance(ChatErrorContentPart, ChatErrorLevel.Error, ( new MarkdownString(( localize(7129, "Failed to render content")) + `: ${toErrorMessage(err, false)}`)), content, this.chatContentMarkdownRenderer);
             return {
                 dispose: () => errorPart.dispose(),
                 domNode: errorPart.domNode,
@@ -1756,10 +2053,8 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }));
         part.codeblocks?.forEach((info, i) => {
             codeBlocksByResponseId[codeBlockStartIndex + i] = info;
-            part.addDisposable(thenIfNotDisposed(info.uriPromise, uri => {
-                if (!uri) {
-                    return;
-                }
+            const uri = info.uri;
+            if (uri) {
                 this.codeBlocksByEditorUri.set(uri, info);
                 part.addDisposable(toDisposable(() => {
                     const codeblock = this.codeBlocksByEditorUri.get(uri);
@@ -1767,10 +2062,19 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                         this.codeBlocksByEditorUri.delete(uri);
                     }
                 }));
-            }));
+            }
         });
     }
     renderToolInvocation(toolInvocation, context, templateData) {
+        if (IChatToolInvocation.isComplete(toolInvocation)) {
+            const msg = toolInvocation.pastTenseMessage ?? toolInvocation.invocationMessage;
+            const text = typeof msg === "string" ? msg : msg?.value;
+            if (!text || text.trim().length === 0) {
+                return this.renderNoContent(
+                    other => (other.kind === "toolInvocation" || other.kind === "toolInvocationSerialized") && other.toolCallId === toolInvocation.toolCallId
+                );
+            }
+        }
         if (this.configService.getValue("chat.agent.thinking.collapsedTools") === CollapsedToolsDisplayMode.Off) {
             this.finalizeCurrentThinkingPart(context, templateData);
         }
@@ -1785,7 +2089,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 this._contentReferencesListPool,
                 this._toolEditorPool,
                 () => this._currentLayoutWidth.get(),
-                this._toolInvocationCodeBlockCollection,
                 this._announcedToolProgressKeys,
                 codeBlockStartIndex
             );
@@ -1799,7 +2102,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const collapsedToolsMode = this.configService.getValue("chat.agent.thinking.collapsedTools");
         if (isResponseVM(context.element) && collapsedToolsMode !== CollapsedToolsDisplayMode.Off) {
             const lastThinking = this.getLastThinkingPart(templateData.renderedParts);
-            if (!lastThinking && toolInvocation.presentation !== "hidden" && this.shouldPinPart(toolInvocation, context.element) && collapsedToolsMode === CollapsedToolsDisplayMode.Always) {
+            if (!lastThinking && !IChatToolInvocation.isEffectivelyHidden(toolInvocation) && this.shouldPinPart(toolInvocation, context.element) && collapsedToolsMode === CollapsedToolsDisplayMode.Always) {
                 const thinkingPart = this.renderThinkingPart({
                     kind: "thinking"
                 }, context, templateData);
@@ -1818,7 +2121,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 return thinkingPart;
             }
             if (this.shouldPinPart(toolInvocation, context.element)) {
-                if (lastThinking && toolInvocation.presentation !== "hidden") {
+                if (lastThinking && !IChatToolInvocation.isEffectivelyHidden(toolInvocation)) {
                     toolInvocation.isAttachedToThinking = true;
                     lastThinking.appendItem(createToolPart, toolInvocation.toolId, toolInvocation, templateData.value);
                     this.setupConfirmationTransitionWatcher(
@@ -1838,12 +2141,46 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             }
         }
         const subagentId = getSubagentId(toolInvocation);
-        if (subagentId && isResponseVM(context.element) && toolInvocation.presentation !== "hidden") {
+        if (subagentId && isResponseVM(context.element) && !IChatToolInvocation.isEffectivelyHidden(toolInvocation)) {
             return this.handleSubagentToolGrouping(toolInvocation, subagentId, context, templateData, codeBlockStartIndex);
         }
         const {
             part
         } = createToolPart();
+        if (this.configService.getValue(ChatConfiguration.ToolConfirmationCarousel) && toolInvocation.kind === "toolInvocation" && isResponseVM(context.element) && toolInvocation.source.type !== "mcp" && !this.viewModel?.editing) {
+            const widget = this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource);
+            if (widget) {
+                const factory = tool => this.instantiationService.createInstance(
+                    ChatToolInvocationPart,
+                    tool,
+                    context,
+                    this.chatContentMarkdownRenderer,
+                    this._contentReferencesListPool,
+                    this._toolEditorPool,
+                    () => this._currentLayoutWidth.get(),
+                    this._announcedToolProgressKeys,
+                    codeBlockStartIndex
+                );
+                const routePartToCarousel = () => {
+                    widget.inputPart.addToolToConfirmationCarousel(toolInvocation, factory);
+                    hide(part.domNode);
+                    return true;
+                };
+                part.addDisposable(autorun(reader => {
+                    const state = toolInvocation.state.read(reader);
+                    const isCarouselConfirmation = state.type === IChatToolInvocation.StateKind.WaitingForConfirmation && !!state.confirmationMessages?.title && toolInvocation.presentation !== "hidden" && toolInvocation.source.type !== "mcp" && !this.viewModel?.editing;
+                    if (isCarouselConfirmation) {
+                        if (!routePartToCarousel()) ;
+                    } else if (IChatToolInvocation.isEffectivelyHidden(toolInvocation, reader)) {
+                        this.updateWorkingProgressForPendingConfirmations(templateData);
+                        hide(part.domNode);
+                    } else {
+                        this.updateWorkingProgressForPendingConfirmations(templateData);
+                        show(part.domNode);
+                    }
+                }));
+            }
+        }
         return part;
     }
     setupConfirmationTransitionWatcher(
@@ -1857,10 +2194,12 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (toolInvocation.kind !== "toolInvocation") {
             return;
         }
-        const removeConfirmationWidget = () => {
+        const moveConfirmationWidgetOutOfThinking = () => {
             const createdPart = getCreatedPart();
             toolInvocation.isAttachedToThinking = false;
+            let part;
             if (createdPart?.domNode) {
+                part = createdPart;
                 const wrapper = createdPart.domNode.parentElement;
                 if (wrapper?.classList.contains("chat-thinking-tool-wrapper")) {
                     wrapper.remove();
@@ -1870,8 +2209,10 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             } else {
                 thinkingPart.removeLazyItem(toolInvocation.toolId);
                 const {
-                    domNode
+                    domNode,
+                    part: createdPart
                 } = createToolPart();
+                part = createdPart;
                 templateData.value.appendChild(domNode);
             }
             this.finalizeCurrentThinkingPart(context, templateData);
@@ -1879,13 +2220,59 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 thinkingPart.domNode?.remove();
                 thinkingPart.dispose();
             }
+            return part;
+        };
+        const isWorkingState = type => type === IChatToolInvocation.StateKind.Streaming || type === IChatToolInvocation.StateKind.Executing;
+        const tryRouteConfirmationToCarousel = () => {
+            if (!this.configService.getValue(ChatConfiguration.ToolConfirmationCarousel) || !isResponseVM(context.element) || this.viewModel?.editing || toolInvocation.presentation === "hidden" || toolInvocation.source.type === "mcp") {
+                return false;
+            }
+            const state = toolInvocation.state.get();
+            if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation || !state.confirmationMessages?.title) {
+                return false;
+            }
+            const widget = this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource);
+            if (!widget) {
+                return false;
+            }
+            const part = moveConfirmationWidgetOutOfThinking();
+            const factory = tool => this.instantiationService.createInstance(
+                ChatToolInvocationPart,
+                tool,
+                context,
+                this.chatContentMarkdownRenderer,
+                this._contentReferencesListPool,
+                this._toolEditorPool,
+                () => this._currentLayoutWidth.get(),
+                this._announcedToolProgressKeys,
+                context.codeBlockStartIndex
+            );
+            part.addDisposable(autorun(reader => {
+                const currentState = toolInvocation.state.read(reader);
+                if (currentState.type === IChatToolInvocation.StateKind.WaitingForConfirmation && currentState.confirmationMessages?.title) {
+                    widget.inputPart.addToolToConfirmationCarousel(toolInvocation, factory);
+                    hide(part.domNode);
+                } else if (IChatToolInvocation.isEffectivelyHidden(toolInvocation, reader)) {
+                    this.updateWorkingProgressForPendingConfirmations(templateData);
+                    hide(part.domNode);
+                } else {
+                    this.updateWorkingProgressForPendingConfirmations(templateData);
+                    show(part.domNode);
+                }
+            }));
+            return true;
         };
         const currentState = toolInvocation.state.get();
-        if (currentState.type === IChatToolInvocation.StateKind.WaitingForConfirmation || currentState.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-            removeConfirmationWidget();
+        if (currentState.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            if (!tryRouteConfirmationToCarousel()) {
+                moveConfirmationWidgetOutOfThinking();
+            }
+            return;
+        }
+        if (currentState.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
+            moveConfirmationWidgetOutOfThinking();
             return;
         }
-        const isWorkingState = type => type === IChatToolInvocation.StateKind.Streaming || type === IChatToolInvocation.StateKind.Executing;
         if (!isWorkingState(currentState.type)) {
             return;
         }
@@ -1898,7 +2285,9 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                 }
                 didRemoveConfirmationWidget = true;
                 disposable.dispose();
-                removeConfirmationWidget();
+                if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation || !tryRouteConfirmationToCarousel()) {
+                    moveConfirmationWidgetOutOfThinking();
+                }
             }
         });
         thinkingPart.addDisposable(disposable);
@@ -1928,7 +2317,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         }
         const shouldPinToThinking = hookPart.hookType === HookType.PreToolUse || hookPart.hookType === HookType.PostToolUse;
         if (shouldPinToThinking) {
-            const hookTitle = hookPart.stopReason ? (hookPart.toolDisplayName ? ( localize(7006, "Blocked {0}", hookPart.toolDisplayName)) : ( localize(7007, "Blocked by hook"))) : (hookPart.toolDisplayName ? ( localize(7008, "Used {0}, but received a warning", hookPart.toolDisplayName)) : ( localize(7009, "Tool call received a warning")));
+            const hookTitle = hookPart.stopReason ? (hookPart.toolDisplayName ? ( localize(7130, "Blocked {0}", hookPart.toolDisplayName)) : ( localize(7131, "Blocked by hook"))) : (hookPart.toolDisplayName ? ( localize(7132, "Used {0}, but received a warning", hookPart.toolDisplayName)) : ( localize(7133, "Tool call received a warning")));
             let thinkingPart = this.getLastThinkingPart(templateData.renderedParts);
             if (!thinkingPart) {
                 const newThinking = this.renderThinkingPart({
@@ -1960,6 +2349,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (!isResponseVM(context.element)) {
             return;
         }
+        this.finalizeCurrentThinkingPart(context, templateData);
         const taskPart = this.instantiationService.createInstance(
             ChatTaskContentPart,
             task,
@@ -1984,6 +2374,21 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
     renderQuestionCarousel(context, carousel, templateData) {
         this.finalizeCurrentThinkingPart(context, templateData);
         this._notifyOnQuestionCarousel(context, carousel);
+        if (!carousel.terminalId && isResponseVM(context.element)) {
+            const responseElement = context.element;
+            const model = this.chatService.getSession(responseElement.sessionResource);
+            const request = model?.getRequests().find(r => r.id === responseElement.requestId);
+            if (request?.terminalExecutionId) {
+                carousel.terminalId = request.terminalExecutionId;
+                this.logService.trace(
+                    `ChatListItemRenderer#renderQuestionCarousel: backfilled terminalId=${carousel.terminalId} for request=${responseElement.requestId}`
+                );
+            } else {
+                this.logService.trace(
+                    `ChatListItemRenderer#renderQuestionCarousel: no terminalExecutionId to backfill for request=${responseElement.requestId}`
+                );
+            }
+        }
         const widget = isResponseVM(context.element) ? this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource) : undefined;
         const shouldAutoFocus = widget ? widget.getInput() === "" : true;
         const responseId = isResponseVM(context.element) ? context.element.requestId : undefined;
@@ -2085,10 +2490,10 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             return;
         }
         const questionCount = carousel.questions.length;
-        const question = carousel.questions.length > 0 && carousel.questions[0].message ? carousel.questions[0].message : ( localize(7010, "Chat input required."));
+        const question = carousel.questions.length > 0 && carousel.questions[0].message ? carousel.questions[0].message : ( localize(7134, "Chat input required."));
         const stringQuestion = typeof question === "string" ? question : question.value;
-        const alertMessage = questionCount === 1 ? ( localize(7011, "Chat input required (1 question): {0}", stringQuestion)) : ( localize(
-            7012,
+        const alertMessage = questionCount === 1 ? ( localize(7135, "Chat input required (1 question): {0}", stringQuestion)) : ( localize(
+            7136,
             "Chat input required ({0} questions): {1}",
             questionCount,
             stringQuestion
@@ -2097,12 +2502,60 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (stableKey) {
             this._notifiedQuestionCarousels.add(stableKey);
         }
-        const signalMessage = questionCount === 1 ? ( localize(7013, "Chat needs your input (1 question).")) : ( localize(7014, "Chat needs your input ({0} questions).", questionCount));
+        const signalMessage = questionCount === 1 ? ( localize(7137, "Chat needs your input (1 question).")) : ( localize(7138, "Chat needs your input ({0} questions).", questionCount));
         this.accessibilitySignalService.playSignal(AccessibilitySignal.chatUserActionRequired, {
             allowManyInParallel: true,
             customAlertMessage: signalMessage
         });
     }
+    renderPlanReview(context, review) {
+        const widget = isResponseVM(context.element) ? this.chatWidgetService.getWidgetBySessionResource(context.element.sessionResource) : undefined;
+        const responseId = isResponseVM(context.element) ? context.element.requestId : undefined;
+        const reviewKey = review.resolveId ?? `${responseId ?? ""}_${context.contentIndex}`;
+        const handleSubmit = result => {
+            review.data = result;
+            review.isUsed = true;
+            if (review instanceof ChatPlanReviewData) {
+                review.completion.complete(result);
+            }
+            widget?.input.clearPlanReview(undefined, reviewKey);
+        };
+        const responseIsComplete = isResponseVM(context.element) && context.element.isComplete;
+        if (review.isUsed || responseIsComplete) {
+            if (responseIsComplete && !review.isUsed) {
+                review.isUsed = true;
+                if (review instanceof ChatPlanReviewData) {
+                    review.completion.complete(undefined);
+                }
+                if (responseId) {
+                    widget?.input.clearPlanReview(responseId);
+                }
+            }
+            return this.renderNoContent(other => other.kind === "planReview");
+        }
+        const isEditing = !!this.viewModel?.editing;
+        const dockedPart = isEditing ? undefined : widget?.input.renderPlanReview(review, context, {
+            onSubmit: handleSubmit
+        });
+        if (!dockedPart) {
+            const fallbackPart = this.instantiationService.createInstance(ChatPlanReviewPart, review, context, {
+                onSubmit: handleSubmit
+            });
+            return fallbackPart;
+        }
+        return this.renderNoContent((other, _followingContent, element) => {
+            if (review.isUsed || (isResponseVM(element) && element.isComplete)) {
+                return false;
+            }
+            if (other.kind === "planReview") {
+                if (review.resolveId && other.resolveId) {
+                    return review.resolveId === other.resolveId;
+                }
+                return other === review;
+            }
+            return false;
+        });
+    }
     removeCarouselFromTracking(context, part) {
         if (isResponseVM(context.element)) {
             const carousels = this.pendingQuestionCarousels.get(context.element.sessionResource);
@@ -2115,10 +2568,11 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         const part = this.instantiationService.createInstance(ChatCheckpointFileChangesSummaryContentPart, content, context);
         return part;
     }
-    renderAttachments(variables, contentReferences, templateData) {
+    renderAttachments(variables, contentReferences, modelId, templateData) {
         return this.instantiationService.createInstance(ChatAttachmentsContentPart, {
             variables,
             contentReferences,
+            modelId,
             domNode: undefined
         });
     }
@@ -2152,7 +2606,6 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
             this.chatContentMarkdownRenderer,
             undefined,
             this._currentLayoutWidth.get(),
-            this.codeBlockModelCollection,
             {}
         );
         markdownPart.addDisposable(
@@ -2188,7 +2641,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     })
                 );
                 markdownPart.addDisposable(
-                    this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), markdownPart.domNode, ( localize(7015, "Click to Edit")), {
+                    this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), markdownPart.domNode, ( localize(7139, "Click to Edit")), {
                         trapFocus: true
                     })
                 );
@@ -2215,7 +2668,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     subagentPart.appendMarkdownItem(() => ({
                         domNode: markdownPart.domNode,
                         disposable: markdownPart
-                    }), markdownPart.codeblocksPartId, markdown, templateData.value);
+                    }), markdownPart.codeblocksPartId, markdown, templateData.value, markdownPart);
                     return subagentPart;
                 }
             }
@@ -2228,7 +2681,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
                     thinkingPart.appendItem(() => ({
                         domNode: markdownPart.domNode,
                         disposable: markdownPart
-                    }), markdownPart.codeblocksPartId, markdown, templateData.value, markdownPart.onDidChangeDiff);
+                    }), markdownPart.codeblocksPartId, markdown, templateData.value, markdownPart.onDidChangeDiff, markdownPart);
                 }
                 return thinkingPart;
             }
@@ -2306,6 +2759,17 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         if (templateData.currentElement && !this.viewModel?.editing) {
             this.templateDataByRequestId.delete(templateData.currentElement.id);
         }
+        const codeBlocks = this.codeBlocksByResponseId.get(node.element.id);
+        if (codeBlocks) {
+            for (const info of codeBlocks) {
+                if (info?.uri) {
+                    this.codeBlocksByEditorUri.delete(info.uri);
+                }
+            }
+            this.codeBlocksByResponseId.delete(node.element.id);
+        }
+        this.fileTreesByResponseId.delete(node.element.id);
+        this.focusedFileTreesByResponseId.delete(node.element.id);
         if (isRequestVM(node.element) && node.element.id === this.viewModel?.editing?.id && details?.onScroll) {
             this._onDidDispose.fire(templateData);
         }
@@ -2333,7 +2797,7 @@ let ChatListItemRenderer = class ChatListItemRenderer extends Disposable {
         requestHover.style.opacity = "0";
     }
 };
-ChatListItemRenderer = ChatListItemRenderer_1 = ( __decorate([( __param(6, IInstantiationService)), ( __param(7, IConfigurationService)), ( __param(8, ILogService)), ( __param(9, IContextKeyService)), ( __param(10, IThemeService)), ( __param(11, ICommandService)), ( __param(12, IHoverService)), ( __param(13, IChatWidgetService)), ( __param(14, IChatEntitlementService)), ( __param(15, IChatService)), ( __param(16, IAccessibilitySignalService)), ( __param(17, IAccessibilityService)), ( __param(18, IWorkbenchEnvironmentService))], ChatListItemRenderer));
+ChatListItemRenderer = ChatListItemRenderer_1 = ( __decorate([( __param(5, IInstantiationService)), ( __param(6, IConfigurationService)), ( __param(7, ILogService)), ( __param(8, IContextKeyService)), ( __param(9, IThemeService)), ( __param(10, ICommandService)), ( __param(11, IHoverService)), ( __param(12, IChatWidgetService)), ( __param(13, IChatEntitlementService)), ( __param(14, IChatService)), ( __param(15, IAccessibilitySignalService)), ( __param(16, IAccessibilityService)), ( __param(17, IWorkbenchEnvironmentService)), ( __param(18, ITelemetryService))], ChatListItemRenderer));
 class ChatListDelegate extends CachedListVirtualDelegate {
     constructor(defaultElementHeight) {
         super();