@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatSubagentContentPart.d.ts

@@ -0,0 +1,123 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
+import { IChatRendererContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
+import { ChatTreeItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatContentPart, IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatContentParts";
+import { ChatCollapsibleContentPart } from "./chatCollapsibleContentPart.js";
+import { IChatMarkdownContent, IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { CollapsibleListPool } from "./chatReferencesContentPart.js";
+import { EditorPool } from "./chatContentCodePools.js";
+import { CodeBlockModelCollection } from "../../../common/widget/codeBlockModelCollection.js";
+import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service";
+/**
+ * This is generally copied from ChatThinkingContentPart. We are still experimenting with both UIs so I'm not
+ * trying to refactor to share code. Both could probably be simplified when stable.
+ */
+export declare class ChatSubagentContentPart extends ChatCollapsibleContentPart implements IChatContentPart {
+    readonly subAgentInvocationId: string;
+    private readonly context;
+    private readonly chatContentMarkdownRenderer;
+    private readonly listPool;
+    private readonly editorPool;
+    private readonly currentWidthDelegate;
+    private readonly codeBlockModelCollection;
+    private readonly announcedToolProgressKeys;
+    private readonly instantiationService;
+    private readonly chatMarkdownAnchorService;
+    private wrapper;
+    private isActive;
+    private hasToolItems;
+    private readonly isInitiallyComplete;
+    private promptContainer;
+    private resultContainer;
+    private lastItemWrapper;
+    private readonly layoutScheduler;
+    private description;
+    private agentName;
+    private prompt;
+    private readonly lazyItems;
+    private hasExpandedOnce;
+    private pendingPromptRender;
+    private pendingResultText;
+    private currentRunningToolMessage;
+    private toolsWaitingForConfirmation;
+    private userManuallyExpanded;
+    private autoExpandedForConfirmation;
+    /**
+     * Extracts subagent info (description, agentName, prompt) from a tool invocation.
+     */
+    private static extractSubagentInfo;
+    constructor(subAgentInvocationId: string, toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, chatContentMarkdownRenderer: IMarkdownRenderer, listPool: CollapsibleListPool, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, announcedToolProgressKeys: Set<string>, instantiationService: IInstantiationService, chatMarkdownAnchorService: IChatMarkdownAnchorService, hoverService: IHoverService);
+    protected initContent(): HTMLElement;
+    /**
+     * Renders the prompt as a collapsible section at the start of the content.
+     * If the wrapper doesn't exist yet (lazy init) or subagent is initially complete,
+     * this is deferred until expanded.
+     */
+    private renderPromptSection;
+    private doRenderPromptSection;
+    getIsActive(): boolean;
+    markAsInactive(): void;
+    finalizeTitle(): void;
+    private updateTitle;
+    /**
+     * Tracks a tool invocation's state for:
+     * 1. Updating the title with the current tool message (persists even after completion)
+     * 2. Auto-expanding when a tool is waiting for confirmation
+     * 3. Auto-collapsing when the confirmation is addressed
+     * This method is public to support testing.
+     */
+    trackToolState(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized): void;
+    /**
+     * Watches the tool invocation for completion and renders the result.
+     * Handles both live and serialized invocations.
+     */
+    private watchToolCompletion;
+    /**
+     * Renders the result text as a collapsible section.
+     * If the wrapper doesn't exist yet (lazy init) or subagent is initially complete,
+     * this is deferred until expanded.
+     */
+    renderResultText(resultText: string): void;
+    private doRenderResultText;
+    /**
+     * Appends a tool invocation to the subagent group.
+     * The tool part is created lazily - only when the subagent section is expanded,
+     * unless it's actively streaming (not initially complete), in which case render immediately.
+     */
+    appendToolInvocation(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, codeBlockStartIndex: number): void;
+    /**
+     * Appends a markdown item (e.g., an edit pill) to the subagent content part.
+     * This is used to route codeblockUri parts with subAgentInvocationId to this subagent's container.
+     */
+    appendMarkdownItem(factory: () => {
+        domNode: HTMLElement;
+        disposable?: IDisposable;
+    }, _codeblocksPartId: string | undefined, _markdown: IChatMarkdownContent, _originalParent?: HTMLElement): void;
+    /**
+     * Appends a markdown item's DOM node to the wrapper.
+     */
+    private appendMarkdownItemToDOM;
+    protected shouldInitEarly(): boolean;
+    /**
+     * Creates a ChatToolInvocationPart for the given tool invocation.
+     */
+    private createToolPart;
+    /**
+     * Appends a tool part's DOM node to the wrapper with appropriate icon wrapper.
+     */
+    private appendToolPartToDOM;
+    /**
+     * Materializes a lazy item by creating the content and adding it to the DOM.
+     */
+    private materializeLazyItem;
+    /**
+     * Materializes all pending lazy content (prompt, tool items, result) when the section is expanded.
+     * This is called when first expanded, but the wrapper must exist (created by base class initContent).
+     */
+    private materializePendingContent;
+    private performLayout;
+    hasSameContent(other: IChatRendererContent, _followingContent: IChatRendererContent[], _element: ChatTreeItem): boolean;
+}

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

@@ -0,0 +1,492 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { AnimationFrameScheduler, $, DisposableResizeObserver, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+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 { rcut } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ChatCollapsibleContentPart } from './chatCollapsibleContentPart.js';
+import { ChatCollapsibleMarkdownContentPart } from './chatCollapsibleMarkdownContentPart.js';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { RunSubagentTool } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/runSubagentTool';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { createThinkingIcon, getToolInvocationIcon } from './chatThinkingContentPart.js';
+import { ChatToolInvocationPart } from './toolInvocationParts/chatToolInvocationPart.js';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import * as chatSubagentContent from './media/chatSubagentContent.css';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var ChatSubagentContentPart_1;
+registerCss(chatSubagentContent);
+const MAX_TITLE_LENGTH = 100;
+let ChatSubagentContentPart = ChatSubagentContentPart_1 = class ChatSubagentContentPart extends ChatCollapsibleContentPart {
+    static extractSubagentInfo(toolInvocation) {
+        const defaultDescription = ( localize(5894, "Running subagent..."));
+        if (toolInvocation.toolId !== RunSubagentTool.Id) {
+            return {
+                description: defaultDescription,
+                agentName: undefined,
+                prompt: undefined
+            };
+        }
+        if (toolInvocation.toolSpecificData?.kind === "subagent") {
+            return {
+                description: toolInvocation.toolSpecificData.description ?? defaultDescription,
+                agentName: toolInvocation.toolSpecificData.agentName,
+                prompt: toolInvocation.toolSpecificData.prompt
+            };
+        }
+        if (toolInvocation.kind === "toolInvocation") {
+            const state = toolInvocation.state.get();
+            const params = state.type !== IChatToolInvocation.StateKind.Streaming ? state.parameters : undefined;
+            return {
+                description: params?.description ?? defaultDescription,
+                agentName: params?.agentName,
+                prompt: params?.prompt
+            };
+        }
+        return {
+            description: defaultDescription,
+            agentName: undefined,
+            prompt: undefined
+        };
+    }
+    constructor(
+        subAgentInvocationId,
+        toolInvocation,
+        context,
+        chatContentMarkdownRenderer,
+        listPool,
+        editorPool,
+        currentWidthDelegate,
+        codeBlockModelCollection,
+        announcedToolProgressKeys,
+        instantiationService,
+        chatMarkdownAnchorService,
+        hoverService
+    ) {
+        const {
+            description,
+            agentName,
+            prompt
+        } = ChatSubagentContentPart_1.extractSubagentInfo(toolInvocation);
+        const prefix = agentName || ( localize(5895, "Subagent"));
+        const initialTitle = `${prefix}: ${description}`;
+        super(initialTitle, context, undefined, hoverService);
+        this.subAgentInvocationId = subAgentInvocationId;
+        this.context = context;
+        this.chatContentMarkdownRenderer = chatContentMarkdownRenderer;
+        this.listPool = listPool;
+        this.editorPool = editorPool;
+        this.currentWidthDelegate = currentWidthDelegate;
+        this.codeBlockModelCollection = codeBlockModelCollection;
+        this.announcedToolProgressKeys = announcedToolProgressKeys;
+        this.instantiationService = instantiationService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+        this.isActive = true;
+        this.hasToolItems = false;
+        this.lazyItems = [];
+        this.hasExpandedOnce = false;
+        this.pendingPromptRender = false;
+        this.toolsWaitingForConfirmation = 0;
+        this.userManuallyExpanded = false;
+        this.autoExpandedForConfirmation = false;
+        this.description = description;
+        this.agentName = agentName;
+        this.prompt = prompt;
+        this.isInitiallyComplete = this.element.isComplete;
+        const node = this.domNode;
+        node.classList.add("chat-thinking-box", "chat-thinking-fixed-mode", "chat-subagent-part");
+        if (this._collapseButton && !this.element.isComplete) {
+            this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, "spin");
+        }
+        this._register(autorun(r => {
+            this.expanded.read(r);
+            if (this._collapseButton) {
+                if (!this.element.isComplete && this.isActive) {
+                    this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, "spin");
+                } else {
+                    this._collapseButton.icon = Codicon.check;
+                }
+            }
+        }));
+        this._register(autorun(r => {
+            if (this._isExpanded.read(r) && !this.hasExpandedOnce) {
+                this.hasExpandedOnce = true;
+                this.materializePendingContent();
+            }
+        }));
+        this.setExpanded(false);
+        this._register(autorun(r => {
+            const expanded = this._isExpanded.read(r);
+            if (expanded) {
+                if (!this.autoExpandedForConfirmation) {
+                    this.userManuallyExpanded = true;
+                }
+            } else {
+                if (this.autoExpandedForConfirmation) {
+                    this.autoExpandedForConfirmation = false;
+                }
+                if (this.userManuallyExpanded) {
+                    this.userManuallyExpanded = false;
+                }
+            }
+        }));
+        this.layoutScheduler = this._register(( new AnimationFrameScheduler(this.domNode, () => this.performLayout())));
+        this.renderPromptSection();
+        this.watchToolCompletion(toolInvocation);
+    }
+    initContent() {
+        this.wrapper = $(".chat-used-context-list.chat-thinking-collapsible");
+        if (!this.hasToolItems) {
+            this.wrapper.style.display = "none";
+        }
+        this.materializePendingContent();
+        const resizeObserver = this._register(( new DisposableResizeObserver(() => this.layoutScheduler.schedule())));
+        this._register(resizeObserver.observe(this.wrapper));
+        return this.wrapper;
+    }
+    renderPromptSection() {
+        if (!this.prompt || this.promptContainer) {
+            return;
+        }
+        if (!this.wrapper || (this.isInitiallyComplete && !this.isExpanded() && !this.hasExpandedOnce)) {
+            this.pendingPromptRender = true;
+            return;
+        }
+        this.pendingPromptRender = false;
+        this.doRenderPromptSection();
+    }
+    doRenderPromptSection() {
+        if (!this.prompt || this.promptContainer) {
+            return;
+        }
+        const lines = this.prompt.split("\n");
+        const rawFirstLine = lines[0] || ( localize(5896, "Prompt"));
+        const restOfLines = lines.slice(1).join("\n").trim();
+        const titleContent = rcut(rawFirstLine, MAX_TITLE_LENGTH);
+        const wasTruncated = rawFirstLine.length > MAX_TITLE_LENGTH;
+        const title = wasTruncated ? titleContent + "…" : titleContent;
+        const titleRemainder = rawFirstLine.length > titleContent.length ? rawFirstLine.slice(titleContent.length).trim() : "";
+        const content = titleRemainder ? (titleRemainder + (restOfLines ? "\n" + restOfLines : "")) : (restOfLines || this.prompt);
+        const collapsiblePart = this._register(this.instantiationService.createInstance(
+            ChatCollapsibleMarkdownContentPart,
+            title,
+            content,
+            this.context,
+            this.chatContentMarkdownRenderer
+        ));
+        this.promptContainer = $(".chat-thinking-tool-wrapper.chat-subagent-section");
+        const promptIcon = createThinkingIcon(Codicon.comment);
+        this.promptContainer.appendChild(promptIcon);
+        this.promptContainer.appendChild(collapsiblePart.domNode);
+        if (this.wrapper) {
+            if (this.wrapper.firstChild) {
+                this.wrapper.insertBefore(this.promptContainer, this.wrapper.firstChild);
+            } else {
+                append(this.wrapper, this.promptContainer);
+            }
+            if (this.wrapper.style.display === "none") {
+                this.wrapper.style.display = "";
+            }
+        }
+    }
+    getIsActive() {
+        return this.isActive;
+    }
+    markAsInactive() {
+        this.isActive = false;
+        if (this._collapseButton) {
+            this._collapseButton.icon = Codicon.check;
+        }
+        this.finalizeTitle();
+        this.setExpanded(false);
+    }
+    finalizeTitle() {
+        this.updateTitle();
+        if (this._collapseButton) {
+            this._collapseButton.icon = Codicon.check;
+        }
+    }
+    updateTitle() {
+        const prefix = this.agentName || ( localize(5895, "Subagent"));
+        let finalLabel = `${prefix}: ${this.description}`;
+        if (this.currentRunningToolMessage && this.isActive) {
+            finalLabel += ` \u2014 ${this.currentRunningToolMessage}`;
+        }
+        this.setTitleWithWidgets(( new MarkdownString(finalLabel)), this.instantiationService, this.chatMarkdownAnchorService, this.chatContentMarkdownRenderer);
+    }
+    trackToolState(toolInvocation) {
+        if (toolInvocation.kind !== "toolInvocation") {
+            return;
+        }
+        const message = toolInvocation.invocationMessage;
+        const messageText = typeof message === "string" ? message : message.value;
+        this.currentRunningToolMessage = messageText;
+        this.updateTitle();
+        let wasWaitingForConfirmation = false;
+        this._register(autorun(r => {
+            const state = toolInvocation.state.read(r);
+            const isWaitingForConfirmation = state.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state.type === IChatToolInvocation.StateKind.WaitingForPostApproval;
+            if (isWaitingForConfirmation && !wasWaitingForConfirmation) {
+                this.toolsWaitingForConfirmation++;
+                if (!this.isExpanded()) {
+                    this.autoExpandedForConfirmation = true;
+                    this.setExpanded(true);
+                }
+            } else if (!isWaitingForConfirmation && wasWaitingForConfirmation) {
+                this.toolsWaitingForConfirmation--;
+                if (this.toolsWaitingForConfirmation === 0 && this.autoExpandedForConfirmation && !this.userManuallyExpanded) {
+                    this.autoExpandedForConfirmation = false;
+                    this.setExpanded(false);
+                }
+            }
+            wasWaitingForConfirmation = isWaitingForConfirmation;
+        }));
+    }
+    watchToolCompletion(toolInvocation) {
+        if (toolInvocation.toolId !== RunSubagentTool.Id) {
+            return;
+        }
+        if (toolInvocation.kind === "toolInvocation") {
+            let wasStreaming = toolInvocation.state.get().type === IChatToolInvocation.StateKind.Streaming;
+            this._register(autorun(r => {
+                const state = toolInvocation.state.read(r);
+                if (state.type === IChatToolInvocation.StateKind.Completed) {
+                    wasStreaming = false;
+                    const textParts = ( (state.contentForModel || []).filter(part => part.kind === "text").map(part => part.value));
+                    if (textParts.length > 0) {
+                        this.renderResultText(textParts.join("\n"));
+                    }
+                    this.markAsInactive();
+                } else if (wasStreaming && state.type !== IChatToolInvocation.StateKind.Streaming) {
+                    wasStreaming = false;
+                    const {
+                        description,
+                        agentName,
+                        prompt
+                    } = ChatSubagentContentPart_1.extractSubagentInfo(toolInvocation);
+                    this.description = description;
+                    this.agentName = agentName;
+                    this.prompt = prompt;
+                    this.renderPromptSection();
+                    this.updateTitle();
+                }
+            }));
+        } else if (toolInvocation.toolSpecificData?.kind === "subagent" && toolInvocation.toolSpecificData.result) {
+            this.renderResultText(toolInvocation.toolSpecificData.result);
+            this.markAsInactive();
+        }
+    }
+    renderResultText(resultText) {
+        if (this.resultContainer || !resultText) {
+            return;
+        }
+        if (!this.wrapper || (this.isInitiallyComplete && !this.isExpanded() && !this.hasExpandedOnce)) {
+            this.pendingResultText = resultText;
+            return;
+        }
+        this.pendingResultText = undefined;
+        this.doRenderResultText(resultText);
+    }
+    doRenderResultText(resultText) {
+        if (this.resultContainer || !resultText) {
+            return;
+        }
+        const lines = resultText.split("\n");
+        const rawFirstLine = lines[0] || "";
+        const restOfLines = lines.slice(1).join("\n").trim();
+        const titleContent = rcut(rawFirstLine, MAX_TITLE_LENGTH);
+        const wasTruncated = rawFirstLine.length > MAX_TITLE_LENGTH;
+        const title = wasTruncated ? titleContent + "…" : titleContent;
+        const titleRemainder = rawFirstLine.length > titleContent.length ? rawFirstLine.slice(titleContent.length).trim() : "";
+        const content = titleRemainder ? (titleRemainder + (restOfLines ? "\n" + restOfLines : "")) : restOfLines;
+        const collapsiblePart = this._register(this.instantiationService.createInstance(
+            ChatCollapsibleMarkdownContentPart,
+            title,
+            content,
+            this.context,
+            this.chatContentMarkdownRenderer
+        ));
+        this.resultContainer = $(".chat-thinking-tool-wrapper.chat-subagent-section");
+        const resultIcon = createThinkingIcon(Codicon.check);
+        this.resultContainer.appendChild(resultIcon);
+        this.resultContainer.appendChild(collapsiblePart.domNode);
+        if (this.wrapper) {
+            append(this.wrapper, this.resultContainer);
+            if (this.wrapper.style.display === "none") {
+                this.wrapper.style.display = "";
+            }
+        }
+    }
+    appendToolInvocation(toolInvocation, codeBlockStartIndex) {
+        if (!this.hasToolItems) {
+            this.hasToolItems = true;
+            if (this.wrapper) {
+                this.wrapper.style.display = "";
+            }
+        }
+        this.trackToolState(toolInvocation);
+        if (this.isExpanded() || this.hasExpandedOnce) {
+            const part = this.createToolPart(toolInvocation, codeBlockStartIndex);
+            this.appendToolPartToDOM(part, toolInvocation);
+        } else {
+            const item = {
+                kind: "tool",
+                lazy: ( new Lazy(() => this.createToolPart(toolInvocation, codeBlockStartIndex))),
+                toolInvocation,
+                codeBlockStartIndex
+            };
+            this.lazyItems.push(item);
+        }
+    }
+    appendMarkdownItem(factory, _codeblocksPartId, _markdown, _originalParent) {
+        if (this.isExpanded() || this.hasExpandedOnce) {
+            const result = factory();
+            this.appendMarkdownItemToDOM(result.domNode);
+            if (result.disposable) {
+                this._register(result.disposable);
+            }
+        } else {
+            const item = {
+                kind: "markdown",
+                lazy: ( new Lazy(factory))
+            };
+            this.lazyItems.push(item);
+        }
+    }
+    appendMarkdownItemToDOM(domNode) {
+        if (!domNode.hasChildNodes() || domNode.textContent?.trim() === "") {
+            return;
+        }
+        const itemWrapper = $(".chat-thinking-tool-wrapper");
+        const iconElement = createThinkingIcon(Codicon.edit);
+        itemWrapper.appendChild(domNode);
+        itemWrapper.insertBefore(iconElement, itemWrapper.firstChild);
+        if (this.wrapper) {
+            if (this.resultContainer) {
+                this.wrapper.insertBefore(itemWrapper, this.resultContainer);
+            } else {
+                this.wrapper.appendChild(itemWrapper);
+            }
+        }
+        this.lastItemWrapper = itemWrapper;
+        this.layoutScheduler.schedule();
+    }
+    shouldInitEarly() {
+        return false;
+    }
+    createToolPart(toolInvocation, codeBlockStartIndex) {
+        const part = this.instantiationService.createInstance(
+            ChatToolInvocationPart,
+            toolInvocation,
+            this.context,
+            this.chatContentMarkdownRenderer,
+            this.listPool,
+            this.editorPool,
+            this.currentWidthDelegate,
+            this.codeBlockModelCollection,
+            this.announcedToolProgressKeys,
+            codeBlockStartIndex
+        );
+        this._register(part);
+        return part;
+    }
+    appendToolPartToDOM(part, toolInvocation) {
+        const content = part.domNode;
+        if (!content.hasChildNodes() || content.textContent?.trim() === "") {
+            return;
+        }
+        const itemWrapper = $(".chat-thinking-tool-wrapper");
+        const icon = getToolInvocationIcon(toolInvocation.toolId);
+        const iconElement = createThinkingIcon(icon);
+        itemWrapper.appendChild(content);
+        if (toolInvocation.kind === "toolInvocation") {
+            this._register(autorun(r => {
+                const state = toolInvocation.state.read(r);
+                const hasConfirmation = state.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state.type === IChatToolInvocation.StateKind.WaitingForPostApproval;
+                if (hasConfirmation) {
+                    iconElement.remove();
+                } else if (!iconElement.parentElement) {
+                    itemWrapper.insertBefore(iconElement, itemWrapper.firstChild);
+                }
+            }));
+        } else {
+            itemWrapper.insertBefore(iconElement, itemWrapper.firstChild);
+        }
+        if (this.wrapper) {
+            if (this.resultContainer) {
+                this.wrapper.insertBefore(itemWrapper, this.resultContainer);
+            } else {
+                this.wrapper.appendChild(itemWrapper);
+            }
+        }
+        this.lastItemWrapper = itemWrapper;
+        this.layoutScheduler.schedule();
+    }
+    materializeLazyItem(item) {
+        if (item.lazy.hasValue) {
+            return;
+        }
+        if (item.kind === "tool") {
+            const part = item.lazy.value;
+            this.appendToolPartToDOM(part, item.toolInvocation);
+        } else if (item.kind === "markdown") {
+            const result = item.lazy.value;
+            this.appendMarkdownItemToDOM(result.domNode);
+            if (result.disposable) {
+                this._register(result.disposable);
+            }
+        }
+    }
+    materializePendingContent() {
+        if (!this.wrapper) {
+            return;
+        }
+        if (this.pendingPromptRender) {
+            this.pendingPromptRender = false;
+            this.doRenderPromptSection();
+        }
+        for (const item of this.lazyItems) {
+            this.materializeLazyItem(item);
+        }
+        if (this.pendingResultText) {
+            const resultText = this.pendingResultText;
+            this.pendingResultText = undefined;
+            this.doRenderResultText(resultText);
+        }
+    }
+    performLayout() {
+        if (this.lastItemWrapper && this.wrapper) {
+            const height = this.lastItemWrapper.offsetHeight;
+            if (height > 0) {
+                this.wrapper.style.setProperty("--chat-subagent-last-item-height", `${height}px`);
+            }
+        }
+        if (this.isActive && !this.isInitiallyComplete && this.wrapper) {
+            const scrollHeight = this.wrapper.scrollHeight;
+            this.wrapper.scrollTop = scrollHeight;
+        }
+    }
+    hasSameContent(other, _followingContent, _element) {
+        if (other.kind === "markdownContent") {
+            return true;
+        }
+        if ((other.kind === "toolInvocation" || other.kind === "toolInvocationSerialized") && (other.subAgentInvocationId || other.toolId === RunSubagentTool.Id)) {
+            const otherEffectiveId = other.toolId === RunSubagentTool.Id ? other.toolCallId : other.subAgentInvocationId;
+            if (this.subAgentInvocationId && otherEffectiveId) {
+                return this.subAgentInvocationId === otherEffectiveId;
+            }
+            return !this.subAgentInvocationId && !otherEffectiveId;
+        }
+        return false;
+    }
+};
+ChatSubagentContentPart = ChatSubagentContentPart_1 = ( __decorate([( __param(9, IInstantiationService)), ( __param(10, IChatMarkdownAnchorService)), ( __param(11, IHoverService))], ChatSubagentContentPart));
+
+export { ChatSubagentContentPart };