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

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

@@ -18,7 +18,7 @@ import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
 import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
 import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
-import { ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { createToolInputUri, createToolSchemaUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
@@ -34,11 +34,39 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
     get codeblocks() {
         return this.markdownParts.flatMap(part => part.codeblocks);
     }
-    constructor(toolInvocation, context, renderer, editorPool, currentWidthDelegate, codeBlockModelCollection, codeBlockStartIndex, instantiationService, keybindingService, modelService, languageService, contextKeyService, chatWidgetService, commandService, markerService, languageModelToolsService, chatMarkdownAnchorService, confirmationService) {
-        if (!toolInvocation.confirmationMessages?.title) {
-            throw ( new Error('Confirmation messages are missing'));
+    constructor(
+        toolInvocation,
+        context,
+        renderer,
+        editorPool,
+        currentWidthDelegate,
+        codeBlockModelCollection,
+        codeBlockStartIndex,
+        instantiationService,
+        keybindingService,
+        modelService,
+        languageService,
+        contextKeyService,
+        chatWidgetService,
+        commandService,
+        markerService,
+        languageModelToolsService,
+        chatMarkdownAnchorService,
+        confirmationService
+    ) {
+        const state = toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation || !state.confirmationMessages?.title) {
+            throw ( new Error("Confirmation messages are missing"));
         }
-        super(toolInvocation, context, instantiationService, keybindingService, contextKeyService, chatWidgetService, languageModelToolsService);
+        super(
+            toolInvocation,
+            context,
+            instantiationService,
+            keybindingService,
+            contextKeyService,
+            chatWidgetService,
+            languageModelToolsService
+        );
         this.renderer = renderer;
         this.editorPool = editorPool;
         this.currentWidthDelegate = currentWidthDelegate;
@@ -54,22 +82,24 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         this.render({
             allowActionId: AcceptToolConfirmationActionId,
             skipActionId: SkipToolConfirmationActionId,
-            allowLabel: toolInvocation.confirmationMessages.confirmResults ? ( localize(5746, "Allow and Review")) : ( localize(5747, "Allow")),
-            skipLabel: ( localize(5748, 'Proceed without running this tool')),
-            partType: 'chatToolConfirmation',
-            subtitle: typeof toolInvocation.originMessage === 'string' ? toolInvocation.originMessage : toolInvocation.originMessage?.value,
+            allowLabel: state.confirmationMessages.confirmResults ? ( localize(6002, "Allow and Review")) : ( localize(6003, "Allow")),
+            skipLabel: ( localize(6004, "Proceed without running this tool")),
+            partType: "chatToolConfirmation",
+            subtitle: typeof toolInvocation.originMessage === "string" ? toolInvocation.originMessage : toolInvocation.originMessage?.value
         });
-        if (toolInvocation.fromSubAgent) {
-            context.container.classList.add('from-sub-agent');
-        }
     }
     additionalPrimaryActions() {
         const actions = super.additionalPrimaryActions();
-        if (this.toolInvocation.confirmationMessages?.allowAutoConfirm !== false) {
+        const state = this.toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            return actions;
+        }
+        if (state.confirmationMessages?.allowAutoConfirm !== false) {
             const confirmActions = this.confirmationService.getPreConfirmActions({
                 toolId: this.toolInvocation.toolId,
                 source: this.toolInvocation.source,
-                parameters: this.toolInvocation.parameters
+                parameters: state.parameters,
+                chatSessionResource: this.context.element.sessionResource
             });
             for (const action of confirmActions) {
                 if (action.divider) {
@@ -81,52 +111,56 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                     data: async () => {
                         const shouldConfirm = await action.select();
                         if (shouldConfirm) {
-                            this.confirmWith(this.toolInvocation, { type: ToolConfirmKind.UserAction });
+                            this.confirmWith(this.toolInvocation, {
+                                type: ToolConfirmKind.UserAction
+                            });
                         }
                     }
                 });
             }
         }
-        if (this.toolInvocation.confirmationMessages?.confirmResults) {
+        if (state.confirmationMessages?.confirmResults) {
             actions.unshift({
-                label: ( localize(5749, 'Allow and Skip Reviewing Result')),
+                label: ( localize(6005, "Allow and Skip Reviewing Result")),
                 data: () => {
-                    this.toolInvocation.confirmationMessages.confirmResults = undefined;
-                    this.confirmWith(this.toolInvocation, { type: ToolConfirmKind.UserAction });
+                    state.confirmationMessages.confirmResults = undefined;
+                    this.confirmWith(this.toolInvocation, {
+                        type: ToolConfirmKind.UserAction
+                    });
                 }
             }, ( new Separator()));
         }
         return actions;
     }
     createContentElement() {
-        const { message, disclaimer } = this.toolInvocation.confirmationMessages;
+        const state = this.toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            return "";
+        }
+        const {
+            message,
+            disclaimer
+        } = state.confirmationMessages;
         const toolInvocation = this.toolInvocation;
-        if (typeof message === 'string' && !disclaimer) {
+        if (typeof message === "string" && !disclaimer) {
             return message;
-        }
-        else {
+        } else {
             const codeBlockRenderOptions = {
                 hideToolbar: true,
                 reserveWidth: 19,
                 verticalPadding: 5,
                 editorOptions: {
                     tabFocusMode: true,
-                    ariaLabel: this.getTitle(),
-                },
+                    ariaLabel: this.getTitle()
+                }
             };
-            const elements = h('div', [
-                h('.message@messageContainer', [
-                    h('.message-wrapper@message'),
-                    h('.see-more@showMore', [
-                        h('a', [( localize(5750, "Show More"))])
-                    ]),
-                ]),
-                h('.editor@editor'),
-                h('.disclaimer@disclaimer'),
-            ]);
-            if (toolInvocation.toolSpecificData?.kind === 'input' && toolInvocation.toolSpecificData.rawInput && !isEmptyObject(toolInvocation.toolSpecificData.rawInput)) {
-                const titleEl = createElement('h3');
-                titleEl.textContent = ( localize(5751, "Input"));
+            const elements = h("div", [h(".message@messageContainer", [
+                h(".message-wrapper@message"),
+                h(".see-more@showMore", [h("a", [( localize(6006, "Show More"))])])
+            ]), h(".editor@editor"), h(".disclaimer@disclaimer")]);
+            if (toolInvocation.toolSpecificData?.kind === "input" && toolInvocation.toolSpecificData.rawInput && !isEmptyObject(toolInvocation.toolSpecificData.rawInput)) {
+                const titleEl = createElement("h3");
+                titleEl.textContent = ( localize(6007, "Input"));
                 elements.editor.appendChild(titleEl);
                 const inputData = toolInvocation.toolSpecificData;
                 const codeBlockRenderOptions = {
@@ -135,25 +169,27 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                     maxHeightInLines: 13,
                     verticalPadding: 5,
                     editorOptions: {
-                        wordWrap: 'off',
+                        wordWrap: "off",
                         readOnly: false,
-                        ariaLabel: this.getTitle(),
+                        ariaLabel: this.getTitle()
                     }
                 };
-                const langId = this.languageService.getLanguageIdByLanguageName('json');
+                const langId = this.languageService.getLanguageIdByLanguageName("json");
                 const rawJsonInput = JSON.stringify(inputData.rawInput ?? {}, null, 1);
-                const canSeeMore = count(rawJsonInput, '\n') > 2;
-                const model = this._register(this.modelService.createModel(
-                rawJsonInput.replace(/\n */g, ' '), this.languageService.createById(langId), createToolInputUri(toolInvocation.toolCallId), true));
+                const canSeeMore = count(rawJsonInput, "\n") > 2;
+                const model = this._register(
+                    this.modelService.createModel(
+                    rawJsonInput.replace(/\n */g, " "), this.languageService.createById(langId), createToolInputUri(toolInvocation.toolCallId), true)
+                );
                 const markerOwner = generateUuid();
                 const schemaUri = createToolSchemaUri(toolInvocation.toolId);
                 const validator = ( new RunOnceScheduler(async () => {
                     const newMarker = [];
-                    const result = await this.commandService.executeCommand('json.validate', schemaUri, model.getValue());
+                    const result = await this.commandService.executeCommand("json.validate", schemaUri, model.getValue());
                     for (const item of result ?? []) {
                         if (item.range && item.message) {
                             newMarker.push({
-                                severity: item.severity === 'Error' ? MarkerSeverity.Error : MarkerSeverity.Warning,
+                                severity: item.severity === "Error" ? MarkerSeverity.Error : MarkerSeverity.Warning,
                                 message: item.message,
                                 startLineNumber: item.range[0].line + 1,
                                 startColumn: item.range[0].character + 1,
@@ -174,7 +210,7 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                     codeBlockIndex: this.codeBlockStartIndex,
                     codeBlockPartIndex: 0,
                     element: this.context.element,
-                    languageId: langId ?? 'json',
+                    languageId: langId ?? "json",
                     renderOptions: codeBlockRenderOptions,
                     textModel: Promise.resolve(model),
                     chatSessionResource: this.context.element.sessionResource
@@ -191,28 +227,27 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                 });
                 this._register(editor.object.onDidChangeContentHeight(() => {
                     editor.object.layout(this.currentWidthDelegate());
-                    this._onDidChangeHeight.fire();
                 }));
                 this._register(model.onDidChangeContent(e => {
                     try {
                         inputData.rawInput = JSON.parse(model.getValue());
-                    }
-                    catch {
-                    }
+                    } catch {}
                 }));
                 elements.editor.append(editor.object.element);
                 if (canSeeMore) {
-                    const seeMore = h('div.see-more', [h('a@link')]);
-                    seeMore.link.textContent = ( localize(5752, "See more"));
+                    const seeMore = h("div.see-more", [h("a@link")]);
+                    seeMore.link.textContent = ( localize(6008, "See more"));
                     this._register(addDisposableGenericMouseDownListener(seeMore.link, () => {
                         try {
                             const parsed = JSON.parse(model.getValue());
                             model.setValue(JSON.stringify(parsed, null, 2));
-                            editor.object.editor.updateOptions({ tabFocusMode: false });
-                            editor.object.editor.updateOptions({ wordWrap: 'on' });
-                        }
-                        catch {
-                        }
+                            editor.object.editor.updateOptions({
+                                tabFocusMode: false
+                            });
+                            editor.object.editor.updateOptions({
+                                wordWrap: "on"
+                            });
+                        } catch {}
                         seeMore.root.remove();
                     }));
                     elements.editor.append(seeMore.root);
@@ -222,54 +257,52 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
             const messageSeeMoreObserver = this._register(( new ElementSizeObserver(mdPart.domNode, undefined)));
             const updateSeeMoreDisplayed = () => {
                 const show = messageSeeMoreObserver.getHeight() > SHOW_MORE_MESSAGE_HEIGHT_TRIGGER;
-                if (elements.messageContainer.classList.contains('can-see-more') !== show) {
-                    elements.messageContainer.classList.toggle('can-see-more', show);
-                    this._onDidChangeHeight.fire();
+                if (elements.messageContainer.classList.contains("can-see-more") !== show) {
+                    elements.messageContainer.classList.toggle("can-see-more", show);
                 }
             };
-            this._register(addDisposableListener(elements.showMore, 'click', () => {
-                elements.messageContainer.classList.toggle('can-see-more', false);
-                this._onDidChangeHeight.fire();
+            this._register(addDisposableListener(elements.showMore, "click", () => {
+                elements.messageContainer.classList.toggle("can-see-more", false);
                 messageSeeMoreObserver.dispose();
             }));
             this._register(messageSeeMoreObserver.onDidChange(updateSeeMoreDisplayed));
             messageSeeMoreObserver.startObserving();
             if (disclaimer) {
                 this._makeMarkdownPart(elements.disclaimer, disclaimer, codeBlockRenderOptions);
-            }
-            else {
+            } else {
                 elements.disclaimer.remove();
             }
             return elements.root;
         }
     }
     getTitle() {
-        const { title } = this.toolInvocation.confirmationMessages;
-        return typeof title === 'string' ? title : title.value;
+        const state = this.toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            return "";
+        }
+        const title = state.confirmationMessages?.title;
+        if (!title) {
+            return "";
+        }
+        return typeof title === "string" ? title : title.value;
     }
     _makeMarkdownPart(container, message, codeBlockRenderOptions) {
         const part = this._register(this.instantiationService.createInstance(ChatMarkdownContentPart, {
-            kind: 'markdownContent',
-            content: typeof message === 'string' ? ( new MarkdownString()).appendMarkdown(message) : message,
-        }, this.context, this.editorPool, false, this.codeBlockStartIndex, this.renderer, undefined, this.currentWidthDelegate(), this.codeBlockModelCollection, { codeBlockRenderOptions }));
-        renderFileWidgets(part.domNode, this.instantiationService, this.chatMarkdownAnchorService, this._store);
+            kind: "markdownContent",
+            content: typeof message === "string" ? ( new MarkdownString()).appendMarkdown(message) : message
+        }, this.context, this.editorPool, false, this.codeBlockStartIndex, this.renderer, undefined, this.currentWidthDelegate(), this.codeBlockModelCollection, {
+            codeBlockRenderOptions
+        }));
+        renderFileWidgets(
+            part.domNode,
+            this.instantiationService,
+            this.chatMarkdownAnchorService,
+            this._store
+        );
         container.append(part.domNode);
-        this._register(part.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
         return part;
     }
 };
-ToolConfirmationSubPart = ( __decorate([
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, IModelService)),
-    ( __param(10, ILanguageService)),
-    ( __param(11, IContextKeyService)),
-    ( __param(12, IChatWidgetService)),
-    ( __param(13, ICommandService)),
-    ( __param(14, IMarkerService)),
-    ( __param(15, ILanguageModelToolsService)),
-    ( __param(16, IChatMarkdownAnchorService)),
-    ( __param(17, ILanguageModelToolsConfirmationService))
-], ToolConfirmationSubPart));
+ToolConfirmationSubPart = ( __decorate([( __param(7, IInstantiationService)), ( __param(8, IKeybindingService)), ( __param(9, IModelService)), ( __param(10, ILanguageService)), ( __param(11, IContextKeyService)), ( __param(12, IChatWidgetService)), ( __param(13, ICommandService)), ( __param(14, IMarkerService)), ( __param(15, ILanguageModelToolsService)), ( __param(16, IChatMarkdownAnchorService)), ( __param(17, ILanguageModelToolsConfirmationService))], ToolConfirmationSubPart));
 
 export { ToolConfirmationSubPart };

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

@@ -20,13 +20,21 @@ export declare class ChatToolInvocationPart extends Disposable implements IChatC
     private readonly codeBlockStartIndex;
     private readonly instantiationService;
     readonly domNode: HTMLElement;
-    private _onDidChangeHeight;
-    readonly onDidChangeHeight: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     get codeblocks(): IChatCodeBlockInfo[];
     get codeblocksPartId(): string | undefined;
     private subPart;
+    private mcpAppPart;
+    private readonly _onDidRemount;
     constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, listPool: CollapsibleListPool, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, announcedToolProgressKeys: Set<string> | undefined, codeBlockStartIndex: number, instantiationService: IInstantiationService);
     private createToolInvocationSubPart;
+    /**
+     * Gets MCP App render data if this tool invocation has MCP App UI.
+     * Returns data from either:
+     * - toolSpecificData.mcpAppData (for in-progress tools)
+     * - result details mcpOutput (for completed tools)
+     */
+    private getMcpAppRenderData;
+    onDidRemount(): void;
     hasSameContent(other: IChatRendererContent, followingContent: IChatRendererContent[], element: ChatTreeItem): boolean;
     addDisposable(disposable: IDisposable): void;
 }

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

@@ -1,14 +1,15 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { $, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { $, createElement, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ToolInvocationPresentation, isToolResultOutputDetails, isToolResultInputOutputDetails } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ExtensionsInstallConfirmationWidgetSubPart } from './chatExtensionsInstallToolSubPart.js';
 import { ChatInputOutputMarkdownProgressPart } from './chatInputOutputMarkdownProgressPart.js';
+import { ChatMcpAppSubPart } from './chatMcpAppSubPart.js';
 import { ChatResultListSubPart } from './chatResultListSubPart.js';
 import { ChatTerminalToolConfirmationSubPart } from './chatTerminalToolConfirmationSubPart.js';
 import { ChatTerminalToolProgressPart } from './chatTerminalToolProgressPart.js';
@@ -16,16 +17,33 @@ import { ToolConfirmationSubPart } from './chatToolConfirmationSubPart.js';
 import { ChatToolOutputSubPart } from './chatToolOutputPart.js';
 import { ChatToolPostExecuteConfirmationPart } from './chatToolPostExecuteConfirmationPart.js';
 import { ChatToolProgressSubPart } from './chatToolProgressPart.js';
+import { ChatToolStreamingSubPart } from './chatToolStreamingSubPart.js';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
 let ChatToolInvocationPart = class ChatToolInvocationPart extends Disposable {
     get codeblocks() {
-        return this.subPart?.codeblocks ?? [];
+        const codeblocks = this.subPart?.codeblocks ?? [];
+        if (this.mcpAppPart) {
+            codeblocks.push(...this.mcpAppPart.codeblocks);
+        }
+        return codeblocks;
     }
     get codeblocksPartId() {
         return this.subPart?.codeblocksPartId;
     }
-    constructor(toolInvocation, context, renderer, listPool, editorPool, currentWidthDelegate, codeBlockModelCollection, announcedToolProgressKeys, codeBlockStartIndex, instantiationService) {
+    constructor(
+        toolInvocation,
+        context,
+        renderer,
+        listPool,
+        editorPool,
+        currentWidthDelegate,
+        codeBlockModelCollection,
+        announcedToolProgressKeys,
+        codeBlockStartIndex,
+        instantiationService
+    ) {
         super();
         this.toolInvocation = toolInvocation;
         this.context = context;
@@ -37,16 +55,12 @@ let ChatToolInvocationPart = class ChatToolInvocationPart extends Disposable {
         this.announcedToolProgressKeys = announcedToolProgressKeys;
         this.codeBlockStartIndex = codeBlockStartIndex;
         this.instantiationService = instantiationService;
-        this._onDidChangeHeight = this._register(( new Emitter()));
-        this.onDidChangeHeight = this._onDidChangeHeight.event;
-        this.domNode = $('.chat-tool-invocation-part');
-        if (toolInvocation.fromSubAgent) {
-            this.domNode.classList.add('from-sub-agent');
-        }
-        if (toolInvocation.presentation === 'hidden') {
+        this._onDidRemount = this._register(( new Emitter()));
+        this.domNode = $(".chat-tool-invocation-part");
+        if (toolInvocation.presentation === "hidden") {
             return;
         }
-        if (toolInvocation.kind === 'toolInvocation') {
+        if (toolInvocation.kind === "toolInvocation") {
             const initialState = toolInvocation.state.get().type;
             this._register(autorun(reader => {
                 if (toolInvocation.state.read(reader).type !== initialState) {
@@ -55,65 +69,180 @@ let ChatToolInvocationPart = class ChatToolInvocationPart extends Disposable {
             }));
         }
         const partStore = this._register(( new DisposableStore()));
+        let subPartDomNode = createElement("div");
+        this.domNode.appendChild(subPartDomNode);
         const render = () => {
-            clearNode(this.domNode);
             partStore.clear();
             if (toolInvocation.presentation === ToolInvocationPresentation.HiddenAfterComplete && IChatToolInvocation.isComplete(toolInvocation)) {
                 return;
             }
             this.subPart = partStore.add(this.createToolInvocationSubPart());
-            this.domNode.appendChild(this.subPart.domNode);
-            partStore.add(this.subPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+            subPartDomNode.replaceWith(this.subPart.domNode);
+            subPartDomNode = this.subPart.domNode;
+            const isConfirmation = this.subPart instanceof ToolConfirmationSubPart || this.subPart instanceof ChatTerminalToolConfirmationSubPart || this.subPart instanceof ExtensionsInstallConfirmationWidgetSubPart || this.subPart instanceof ChatToolPostExecuteConfirmationPart;
+            this.domNode.classList.toggle("has-confirmation", isConfirmation);
             partStore.add(this.subPart.onNeedsRerender(render));
-            this._onDidChangeHeight.fire();
         };
+        const mcpAppRenderData = this.getMcpAppRenderData();
+        if (mcpAppRenderData) {
+            const shouldRender = derived(r => {
+                const outcome = IChatToolInvocation.executionConfirmedOrDenied(toolInvocation, r);
+                return !!outcome && outcome.type !== ToolConfirmKind.Denied && outcome.type !== ToolConfirmKind.Skipped;
+            });
+            let appDomNode = createElement("div");
+            this.domNode.appendChild(appDomNode);
+            this._register(autorun(r => {
+                if (shouldRender.read(r)) {
+                    this.mcpAppPart = r.store.add(this.instantiationService.createInstance(
+                        ChatMcpAppSubPart,
+                        this.toolInvocation,
+                        this._onDidRemount.event,
+                        context,
+                        mcpAppRenderData
+                    ));
+                    appDomNode.replaceWith(this.mcpAppPart.domNode);
+                    appDomNode = this.mcpAppPart.domNode;
+                } else {
+                    this.mcpAppPart = undefined;
+                    clearNode(appDomNode);
+                }
+            }));
+        }
         render();
     }
     createToolInvocationSubPart() {
-        if (this.toolInvocation.kind === 'toolInvocation') {
-            if (this.toolInvocation.toolSpecificData?.kind === 'extensions') {
-                return this.instantiationService.createInstance(ExtensionsInstallConfirmationWidgetSubPart, this.toolInvocation, this.context);
+        if (this.toolInvocation.kind === "toolInvocation") {
+            if (this.toolInvocation.toolSpecificData?.kind === "extensions") {
+                return this.instantiationService.createInstance(
+                    ExtensionsInstallConfirmationWidgetSubPart,
+                    this.toolInvocation,
+                    this.context
+                );
             }
             const state = this.toolInvocation.state.get();
+            if (state.type === IChatToolInvocation.StateKind.Streaming) {
+                return this.instantiationService.createInstance(ChatToolStreamingSubPart, this.toolInvocation, this.context, this.renderer);
+            }
             if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-                if (this.toolInvocation.toolSpecificData?.kind === 'terminal') {
-                    return this.instantiationService.createInstance(ChatTerminalToolConfirmationSubPart, this.toolInvocation, this.toolInvocation.toolSpecificData, this.context, this.renderer, this.editorPool, this.currentWidthDelegate, this.codeBlockModelCollection, this.codeBlockStartIndex);
-                }
-                else {
-                    return this.instantiationService.createInstance(ToolConfirmationSubPart, this.toolInvocation, this.context, this.renderer, this.editorPool, this.currentWidthDelegate, this.codeBlockModelCollection, this.codeBlockStartIndex);
+                if (this.toolInvocation.toolSpecificData?.kind === "terminal") {
+                    return this.instantiationService.createInstance(
+                        ChatTerminalToolConfirmationSubPart,
+                        this.toolInvocation,
+                        this.toolInvocation.toolSpecificData,
+                        this.context,
+                        this.renderer,
+                        this.editorPool,
+                        this.currentWidthDelegate,
+                        this.codeBlockModelCollection,
+                        this.codeBlockStartIndex
+                    );
+                } else {
+                    return this.instantiationService.createInstance(
+                        ToolConfirmationSubPart,
+                        this.toolInvocation,
+                        this.context,
+                        this.renderer,
+                        this.editorPool,
+                        this.currentWidthDelegate,
+                        this.codeBlockModelCollection,
+                        this.codeBlockStartIndex
+                    );
                 }
             }
             if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                 return this.instantiationService.createInstance(ChatToolPostExecuteConfirmationPart, this.toolInvocation, this.context);
             }
         }
-        if (this.toolInvocation.toolSpecificData?.kind === 'terminal') {
-            return this.instantiationService.createInstance(ChatTerminalToolProgressPart, this.toolInvocation, this.toolInvocation.toolSpecificData, this.context, this.renderer, this.editorPool, this.currentWidthDelegate, this.codeBlockStartIndex, this.codeBlockModelCollection);
+        if (this.toolInvocation.toolSpecificData?.kind === "terminal") {
+            return this.instantiationService.createInstance(
+                ChatTerminalToolProgressPart,
+                this.toolInvocation,
+                this.toolInvocation.toolSpecificData,
+                this.context,
+                this.renderer,
+                this.editorPool,
+                this.currentWidthDelegate,
+                this.codeBlockStartIndex,
+                this.codeBlockModelCollection
+            );
         }
         const resultDetails = IChatToolInvocation.resultDetails(this.toolInvocation);
         if (Array.isArray(resultDetails) && resultDetails.length) {
-            return this.instantiationService.createInstance(ChatResultListSubPart, this.toolInvocation, this.context, this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage, resultDetails, this.listPool);
+            return this.instantiationService.createInstance(
+                ChatResultListSubPart,
+                this.toolInvocation,
+                this.context,
+                this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage,
+                resultDetails,
+                this.listPool
+            );
         }
         if (isToolResultOutputDetails(resultDetails)) {
-            return this.instantiationService.createInstance(ChatToolOutputSubPart, this.toolInvocation, this.context);
+            return this.instantiationService.createInstance(
+                ChatToolOutputSubPart,
+                this.toolInvocation,
+                this.context,
+                this._onDidRemount.event
+            );
         }
         if (isToolResultInputOutputDetails(resultDetails)) {
-            return this.instantiationService.createInstance(ChatInputOutputMarkdownProgressPart, this.toolInvocation, this.context, this.codeBlockStartIndex, this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage, this.toolInvocation.originMessage, resultDetails.input, resultDetails.output, !!resultDetails.isError);
+            return this.instantiationService.createInstance(
+                ChatInputOutputMarkdownProgressPart,
+                this.toolInvocation,
+                this.context,
+                this.codeBlockStartIndex,
+                this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage,
+                this.toolInvocation.originMessage,
+                resultDetails.input,
+                resultDetails.output,
+                !!resultDetails.isError
+            );
         }
-        if (this.toolInvocation.kind === 'toolInvocation' && this.toolInvocation.toolSpecificData?.kind === 'input' && !IChatToolInvocation.isComplete(this.toolInvocation)) {
-            return this.instantiationService.createInstance(ChatInputOutputMarkdownProgressPart, this.toolInvocation, this.context, this.codeBlockStartIndex, this.toolInvocation.invocationMessage, this.toolInvocation.originMessage, typeof this.toolInvocation.toolSpecificData.rawInput === 'string' ? this.toolInvocation.toolSpecificData.rawInput : JSON.stringify(this.toolInvocation.toolSpecificData.rawInput, null, 2), undefined, false);
+        if (this.toolInvocation.kind === "toolInvocation" && this.toolInvocation.toolSpecificData?.kind === "input" && !IChatToolInvocation.isComplete(this.toolInvocation)) {
+            return this.instantiationService.createInstance(
+                ChatInputOutputMarkdownProgressPart,
+                this.toolInvocation,
+                this.context,
+                this.codeBlockStartIndex,
+                this.toolInvocation.invocationMessage,
+                this.toolInvocation.originMessage,
+                typeof this.toolInvocation.toolSpecificData.rawInput === "string" ? this.toolInvocation.toolSpecificData.rawInput : JSON.stringify(this.toolInvocation.toolSpecificData.rawInput, null, 2),
+                undefined,
+                false
+            );
         }
-        return this.instantiationService.createInstance(ChatToolProgressSubPart, this.toolInvocation, this.context, this.renderer, this.announcedToolProgressKeys);
+        return this.instantiationService.createInstance(
+            ChatToolProgressSubPart,
+            this.toolInvocation,
+            this.context,
+            this.renderer,
+            this.announcedToolProgressKeys
+        );
+    }
+    getMcpAppRenderData() {
+        const toolSpecificData = this.toolInvocation.toolSpecificData;
+        if (toolSpecificData?.kind === "input" && toolSpecificData.mcpAppData) {
+            const rawInput = typeof toolSpecificData.rawInput === "string" ? toolSpecificData.rawInput : JSON.stringify(toolSpecificData.rawInput, null, 2);
+            return {
+                resourceUri: toolSpecificData.mcpAppData.resourceUri,
+                serverDefinitionId: toolSpecificData.mcpAppData.serverDefinitionId,
+                collectionId: toolSpecificData.mcpAppData.collectionId,
+                input: rawInput,
+                sessionResource: this.context.element.sessionResource
+            };
+        }
+        return undefined;
+    }
+    onDidRemount() {
+        this._onDidRemount.fire();
     }
     hasSameContent(other, followingContent, element) {
-        return (other.kind === 'toolInvocation' || other.kind === 'toolInvocationSerialized') && this.toolInvocation.toolCallId === other.toolCallId;
+        return (other.kind === "toolInvocation" || other.kind === "toolInvocationSerialized") && this.toolInvocation.toolCallId === other.toolCallId;
     }
     addDisposable(disposable) {
         this._register(disposable);
     }
 };
-ChatToolInvocationPart = ( __decorate([
-    ( __param(9, IInstantiationService))
-], ChatToolInvocationPart));
+ChatToolInvocationPart = ( __decorate([( __param(9, IInstantiationService))], ChatToolInvocationPart));
 
 export { ChatToolInvocationPart };

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

@@ -9,8 +9,6 @@ export declare abstract class BaseChatToolInvocationSubPart extends Disposable {
     abstract readonly domNode: HTMLElement;
     protected _onNeedsRerender: Emitter<void>;
     readonly onNeedsRerender: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
-    protected _onDidChangeHeight: Emitter<void>;
-    readonly onDidChangeHeight: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     abstract codeblocks: IChatCodeBlockInfo[];
     private readonly _codeBlocksPartId;
     get codeblocksPartId(): string;