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

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

@@ -0,0 +1,634 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { softAssertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isFalsyOrWhitespace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { hasKey, isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { McpToolCallUI } from '../../../../../mcp/browser/mcpToolCallUI.js';
+import { McpResourceURI } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { McpApps } from '../../../../../mcp/common/modelContextProtocolApps.js';
+import { WebviewOriginStore, WebviewContentPurpose } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview';
+import { IWebviewService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview.service';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { isToolResultInputOutputDetails } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun, autorunSelfDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var ChatMcpAppModel_1;
+const ORIGIN_STORE_KEY = "chatMcpApp.origins";
+let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
+    static {
+        ChatMcpAppModel_1 = this;
+    }
+    static {
+        this.heightCache = ( new WeakMap());
+    }
+    constructor(
+        toolInvocation,
+        renderData,
+        _container,
+        maxHeight,
+        currentWidth,
+        _instantiationService,
+        _chatWidgetService,
+        _webviewService,
+        storageService,
+        _logService,
+        _productService,
+        _openerService
+    ) {
+        super();
+        this.toolInvocation = toolInvocation;
+        this.renderData = renderData;
+        this._container = _container;
+        this._instantiationService = _instantiationService;
+        this._chatWidgetService = _chatWidgetService;
+        this._webviewService = _webviewService;
+        this._logService = _logService;
+        this._productService = _productService;
+        this._openerService = _openerService;
+        this._disposeCts = this._register(( new CancellationTokenSource()));
+        this._announcedCapabilities = false;
+        this._latestCsp = undefined;
+        this._loadState = observableValue(this, {
+            status: "loading"
+        });
+        this.loadState = this._loadState;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._originStore = ( new WebviewOriginStore(ORIGIN_STORE_KEY, storageService));
+        this._webviewOrigin = this._originStore.getOrigin("mcpApp", renderData.serverDefinitionId);
+        this._mcpToolCallUI = this._register(this._instantiationService.createInstance(McpToolCallUI, renderData));
+        this._height = ChatMcpAppModel_1.heightCache.get(this.toolInvocation) ?? 300;
+        this._webview = this._register(this._webviewService.createWebviewElement({
+            origin: this._webviewOrigin,
+            title: ( localize(5965, "MCP App")),
+            options: {
+                purpose: WebviewContentPurpose.ChatOutputItem,
+                enableFindWidget: false,
+                disableServiceWorker: true,
+                retainContextWhenHidden: true
+            },
+            contentOptions: {
+                allowMultipleAPIAcquire: true,
+                allowScripts: true,
+                allowForms: true
+            },
+            extension: undefined
+        }));
+        const targetWindow = getWindow(this._container);
+        this._webview.mountTo(this._container, targetWindow);
+        this.hostContext = ( this._mcpToolCallUI.hostContext.map((context, reader) => ({
+            ...context,
+            containerDimensions: {
+                width: currentWidth.read(reader),
+                maxHeight: maxHeight.read(reader)
+            },
+            toolCall: {
+                toolCallId: this.toolInvocation.toolCallId,
+                toolName: this.toolInvocation.toolId
+            }
+        })));
+        this._register(autorun(reader => {
+            const context = this.hostContext.read(reader);
+            if (this._announcedCapabilities) {
+                this._sendNotification({
+                    method: "ui/notifications/host-context-changed",
+                    params: context
+                });
+            }
+        }));
+        this._register(this._webview.onMessage(async (
+            {
+                message
+            }
+        ) => {
+            await this._handleWebviewMessage(message);
+        }));
+        this._loadContent();
+    }
+    get height() {
+        return this._height;
+    }
+    remount() {
+        this._webview.reinitializeAfterDismount();
+        this._announcedCapabilities = false;
+    }
+    retry() {
+        this._loadState.set({
+            status: "loading"
+        }, undefined);
+        this._loadContent();
+    }
+    async _loadContent() {
+        const token = this._disposeCts.token;
+        try {
+            const resourceContent = await this._mcpToolCallUI.loadResource(token);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const htmlWithCsp = this._injectPreamble(resourceContent);
+            this._announcedCapabilities = false;
+            this._latestCsp = resourceContent.csp;
+            this._webview.setHtml(htmlWithCsp);
+            this._loadState.set({
+                status: "loaded"
+            }, undefined);
+        } catch (error) {
+            this._logService.error("[MCP App] Error loading app:", error);
+            this._loadState.set({
+                status: "error",
+                error: error
+            }, undefined);
+        }
+    }
+    _injectPreamble(
+        {
+            html,
+            csp
+        }
+    ) {
+        const cleanDomains = s => (s?.join(" ") || "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+        const cspContent = `
+            default-src 'none';
+            script-src 'self' 'unsafe-inline' ${cleanDomains(csp?.resourceDomains)};
+            style-src 'self' 'unsafe-inline' ${cleanDomains(csp?.resourceDomains)};
+            connect-src 'self' ${cleanDomains(csp?.connectDomains)};
+            img-src 'self' data: ${cleanDomains(csp?.resourceDomains)};
+            font-src 'self' ${cleanDomains(csp?.resourceDomains)};
+            media-src 'self' data: ${cleanDomains(csp?.resourceDomains)};
+            frame-src ${cleanDomains(csp?.frameDomains) || `'none'`};
+            object-src 'none';
+            base-uri ${cleanDomains(csp?.baseUriDomains) || `'self'`};
+        `;
+        const cspTag = `<meta http-equiv="Content-Security-Policy" content="${cspContent}">`;
+        const postMessageRehoist = `
+            <script>(() => {
+                const api = acquireVsCodeApi();
+                const setMessageSource = (obj, src) => new Proxy(obj, {
+                    get: (target, prop) => {
+                        if (prop === 'source')  {
+                            return src;
+                        }
+                        return target[prop];
+                    }
+                });
+
+                const wrappedFns = new WeakMap();
+
+                let patchedPostMessage = (message, transfer) => api.postMessage(message, transfer);
+                const wrap = target => new Proxy(target, {
+                    set: (obj, prop, value) => {
+                        if (prop === 'postMessage') {
+                            patchedPostMessage = (message, transfer) => value.call(target, message, transfer);
+                        } else {
+                            obj[prop] = value;
+                        }
+                        return true;
+                    },
+                    get: (obj, prop) => {
+                        if (prop === 'postMessage') {
+                            return patchedPostMessage;
+                        }
+                        return obj[prop];
+                    },
+                });
+
+                const originalAddEventListener = window.addEventListener.bind(window);
+                window.addEventListener = (type, listener, options) => {
+                    if (type === 'message') {
+                        const originalListener = listener;
+                        const wrappedListener = (event) => {
+                            if (event.origin === document.location.origin && event.source !== window) { event = setMessageSource(event, window.parent); }
+                            originalListener(event);
+                        };
+                        wrappedFns.set(originalListener, wrappedListener);
+                        listener = wrappedListener;
+                    }
+
+                    return originalAddEventListener(type, listener, options);
+                };
+
+                const originalRemoveEventListener = window.removeEventListener.bind(window);
+                window.removeEventListener = (type, listener, options) => {
+                    const wrappedListener = wrappedFns.get(listener) || listener;
+                    return originalRemoveEventListener(type, wrappedListener, options);
+                };
+
+                window.parent = wrap(window.parent);
+
+                // Scroll boundary detection: bubble wheel events to parent when at scroll boundaries
+                const shouldBubbleScroll = (event) => {
+                    // First check element-level scrolling (for elements with overflow: auto/scroll)
+                    for (let node = event.target; node; node = node.parentNode) {
+                        if (!(node instanceof Element)) {
+                            continue;
+                        }
+
+                        // Skip HTML and BODY - we check document-level scroll separately
+                        if (node === document.documentElement || node === document.body) {
+                            continue;
+                        }
+
+                        // Check if the element can actually scroll
+                        const overflow = window.getComputedStyle(node).overflowY;
+                        if (overflow === 'hidden' || overflow === 'visible') {
+                            continue;
+                        }
+
+                        // Scroll up: if there's content above (scrollTop > 0), don't bubble
+                        if (event.deltaY < 0 && node.scrollTop > 0) {
+                            return false;
+                        }
+
+                        // Scroll down: if there's content below, don't bubble
+                        if (event.deltaY > 0 && node.scrollTop + node.clientHeight < node.scrollHeight) {
+                            // Account for rounding: scrollTop isn't rounded but scrollHeight/clientHeight are
+                            if (node.scrollHeight - node.scrollTop - node.clientHeight < 2) {
+                                continue;
+                            }
+                            return false;
+                        }
+                    }
+
+                    // Check document-level scrolling (works even with overflow: visible on html/body)
+                    const docEl = document.documentElement;
+                    const scrollTop = window.scrollY || docEl.scrollTop || document.body.scrollTop || 0;
+                    const scrollHeight = Math.max(docEl.scrollHeight, document.body.scrollHeight);
+                    const clientHeight = docEl.clientHeight;
+                    const scrollableDistance = scrollHeight - clientHeight;
+
+                    if (scrollableDistance > 2) {
+                        // Document is scrollable
+                        if (event.deltaY < 0 && scrollTop > 0) {
+                            return false;
+                        }
+                        if (event.deltaY > 0 && scrollTop < scrollableDistance - 2) {
+                            return false;
+                        }
+                    }
+
+                    return true;
+                };
+
+                window.addEventListener('wheel', (event) => {
+                    if (event.defaultPrevented || !shouldBubbleScroll(event)) {
+                        return;
+                    }
+                    api.postMessage({
+                        method: 'ui/notifications/sandbox-wheel',
+                        params: {
+                            deltaMode: event.deltaMode,
+                            deltaX: event.deltaX,
+                            deltaY: event.deltaY,
+                            deltaZ: event.deltaZ,
+                        }
+                    });
+                }, { passive: true });
+            })();</script>
+        `;
+        return this._prependToHead(html, cspTag + postMessageRehoist);
+    }
+    _prependToHead(html, content) {
+        const headMatch = html.match(/<head[^>]*>/i);
+        if (headMatch) {
+            const insertIndex = headMatch.index + headMatch[0].length;
+            return html.slice(0, insertIndex) + "\n" + content + html.slice(insertIndex);
+        }
+        const htmlMatch = html.match(/<html[^>]*>/i);
+        if (htmlMatch) {
+            const insertIndex = htmlMatch.index + htmlMatch[0].length;
+            return html.slice(0, insertIndex) + "\n<head>" + content + "</head>" + html.slice(insertIndex);
+        }
+        return `<!DOCTYPE html><html><head>${content}</head><body>${html}</body></html>`;
+    }
+    async _handleWebviewMessage(message) {
+        const request = message;
+        const token = this._disposeCts.token;
+        try {
+            let result = {};
+            switch (request.method) {
+            case "ui/initialize":
+                result = await this._handleInitialize(request.params);
+                break;
+            case "tools/call":
+                result = await this._handleToolsCall(request.params, token);
+                break;
+            case "resources/read":
+                result = await this._handleResourcesRead(request.params, token);
+                break;
+            case "ping":
+                break;
+            case "ui/notifications/size-changed":
+                this._handleSizeChanged(request.params);
+                break;
+            case "ui/open-link":
+                result = await this._handleOpenLink(request.params);
+                break;
+            case "ui/request-display-mode":
+                result = {
+                    mode: "inline"
+                };
+                break;
+            case "ui/notifications/initialized":
+                break;
+            case "ui/message":
+                result = await this._handleUiMessage(request.params);
+                break;
+            case "ui/update-model-context":
+                result = await this._handleUpdateModelContext(request.params);
+                break;
+            case "notifications/message":
+                await this._mcpToolCallUI.log(request.params);
+                break;
+            case "ui/notifications/sandbox-wheel":
+                this._handleSandboxWheel(request.params);
+                break;
+            default:
+                {
+                    softAssertNever(request);
+                    const cast = request;
+                    if (cast.id !== undefined) {
+                        await this._sendError(cast.id, -32601, `Method not found: ${cast.method}`);
+                    }
+                    return;
+                }
+            }
+            if (hasKey(request, {
+                id: true
+            })) {
+                await this._sendResponse(request.id, result);
+            }
+        } catch (error) {
+            this._logService.error(`[MCP App] Error handling ${request.method}:`, error);
+            if (hasKey(request, {
+                id: true
+            })) {
+                const message = error instanceof Error ? error.message : String(error);
+                await this._sendError(request.id, -32e3, message);
+            }
+        }
+    }
+    async _handleInitialize(_params) {
+        this._announcedCapabilities = true;
+        let args;
+        try {
+            args = JSON.parse(this.renderData.input);
+        } catch {
+            args = this.renderData.input;
+        }
+        const timeout = this._register(disposableTimeout(async () => {
+            this._store.delete(timeout);
+            await this._sendNotification({
+                method: "ui/notifications/tool-input",
+                params: {
+                    arguments: args
+                }
+            });
+            if (this.toolInvocation.kind === "toolInvocationSerialized") {
+                this._sendToolResult(this.toolInvocation.resultDetails);
+            } else if (this.toolInvocation.kind === "toolInvocation") {
+                const invocation = this.toolInvocation;
+                this._register(autorunSelfDisposable(reader => {
+                    const state = invocation.state.read(reader);
+                    if (state.type === IChatToolInvocation.StateKind.Completed) {
+                        this._sendToolResult(state.resultDetails);
+                        reader.dispose();
+                    }
+                }));
+            }
+        }));
+        return {
+            protocolVersion: McpApps.LATEST_PROTOCOL_VERSION,
+            hostInfo: {
+                name: this._productService.nameLong,
+                version: this._productService.version
+            },
+            hostCapabilities: {
+                openLinks: {},
+                serverTools: {
+                    listChanged: true
+                },
+                serverResources: {
+                    listChanged: true
+                },
+                logging: {},
+                sandbox: {
+                    csp: this._latestCsp,
+                    permissions: {
+                        clipboardWrite: {}
+                    }
+                },
+                updateModelContext: {
+                    audio: {},
+                    image: {},
+                    resourceLink: {},
+                    resource: {},
+                    structuredContent: {}
+                }
+            },
+            hostContext: this.hostContext.get()
+        };
+    }
+    _sendToolResult(resultDetails) {
+        if (isToolResultInputOutputDetails(resultDetails) && resultDetails.mcpOutput) {
+            this._sendNotification({
+                method: "ui/notifications/tool-result",
+                params: resultDetails.mcpOutput
+            });
+        }
+    }
+    async _handleUiMessage(params) {
+        const widget = this._chatWidgetService.getWidgetBySessionResource(this.renderData.sessionResource);
+        if (!widget) {
+            return {
+                isError: true
+            };
+        }
+        if (!isFalsyOrWhitespace(widget.getInput())) {
+            return {
+                isError: true
+            };
+        }
+        widget.setInput(( params.content.filter(c => c.type === "text").map(c => c.text)).join("\n\n"));
+        widget.attachmentModel.clearAndSetContext(...( params.content.map((c, i) => {
+            const id = `mcpui-${i}-${Date.now()}`;
+            if (c.type === "image") {
+                return {
+                    kind: "image",
+                    value: decodeBase64(c.data).buffer,
+                    id,
+                    name: "Image"
+                };
+            } else if (c.type === "resource_link") {
+                const uri = McpResourceURI.fromServer({
+                    id: this.renderData.serverDefinitionId,
+                    label: ""
+                }, c.uri);
+                return {
+                    kind: "file",
+                    value: uri,
+                    id,
+                    name: basename(uri)
+                };
+            } else {
+                return undefined;
+            }
+        })).filter(isDefined));
+        widget.focusInput();
+        return {
+            isError: false
+        };
+    }
+    async _handleUpdateModelContext(params) {
+        const widget = this._chatWidgetService.getWidgetBySessionResource(this.renderData.sessionResource);
+        if (!widget) {
+            return {};
+        }
+        const idPrefix = `mcpui-context-${hash(this.renderData.serverDefinitionId)}-`;
+        const toDelete = widget.attachmentModel.getAttachmentIDs();
+        const idsToDelete = Array.from(toDelete).filter(id => id.startsWith(idPrefix));
+        const entries = [];
+        let entryIndex = 0;
+        if (params.content) {
+            for (const block of params.content) {
+                const id = `${idPrefix}${entryIndex++}`;
+                if (block.type === "image") {
+                    entries.push({
+                        kind: "image",
+                        value: decodeBase64(block.data).buffer,
+                        id,
+                        name: "Image",
+                        mimeType: block.mimeType
+                    });
+                } else if (block.type === "resource_link") {
+                    const uri = McpResourceURI.fromServer({
+                        id: this.renderData.serverDefinitionId,
+                        label: ""
+                    }, block.uri);
+                    entries.push({
+                        kind: "file",
+                        value: uri,
+                        id,
+                        name: basename(uri)
+                    });
+                } else if (block.type === "text") {
+                    const preview = block.text.replaceAll(/\s+/g, " ").trim();
+                    const truncateTo = 20;
+                    entries.push({
+                        kind: "generic",
+                        value: block.text,
+                        id,
+                        tooltip: ( new MarkdownString()).appendCodeblock("plaintext", block.text),
+                        name: preview.length > truncateTo ? preview.slice(0, truncateTo) + "…" : preview
+                    });
+                }
+            }
+        }
+        if (params.structuredContent && ( Object.keys(params.structuredContent)).length > 0) {
+            const id = `${idPrefix}structured`;
+            const value = JSON.stringify(params.structuredContent, null, 2);
+            entries.push({
+                kind: "generic",
+                value,
+                tooltip: ( new MarkdownString()).appendCodeblock("json", value),
+                id,
+                name: "UI Data"
+            });
+        }
+        widget.attachmentModel.updateContext(idsToDelete, entries);
+        return {};
+    }
+    _handleSizeChanged(params) {
+        if (params.height !== undefined && params.height !== this._height) {
+            this._height = params.height;
+            ChatMcpAppModel_1.heightCache.set(this.toolInvocation, params.height);
+            this._onDidChangeHeight.fire();
+        }
+    }
+    _handleSandboxWheel(params) {
+        let defaultPrevented = false;
+        const evt = {
+            wheelDeltaX: params.deltaX,
+            wheelDeltaY: -params.deltaY,
+            wheelDelta: Math.abs(params.deltaY),
+            deltaX: params.deltaX,
+            deltaY: -params.deltaY,
+            deltaZ: params.deltaZ,
+            deltaMode: params.deltaMode,
+            preventDefault: () => {
+                defaultPrevented = true;
+            },
+            stopPropagation: () => {},
+            get defaultPrevented() {
+                return defaultPrevented;
+            }
+        };
+        const widget = this._chatWidgetService.getWidgetBySessionResource(this.renderData.sessionResource);
+        widget?.delegateScrollFromMouseWheelEvent(evt);
+    }
+    async _handleOpenLink(params) {
+        const ok = await this._openerService.open(params.url);
+        return {
+            isError: !ok
+        };
+    }
+    async _handleToolsCall(params, token) {
+        if (!params?.name) {
+            throw ( new Error("Missing tool name in tools/call request"));
+        }
+        return this._mcpToolCallUI.callTool(params.name, params.arguments || {}, token);
+    }
+    async _handleResourcesRead(params, token) {
+        if (!params?.uri) {
+            throw ( new Error("Missing uri in resources/read request"));
+        }
+        return this._mcpToolCallUI.readResource(params.uri, token);
+    }
+    async _sendResponse(id, result) {
+        await this._webview.postMessage({
+            jsonrpc: "2.0",
+            id,
+            result
+        });
+    }
+    async _sendError(id, code, message) {
+        await this._webview.postMessage({
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code,
+                message
+            }
+        });
+    }
+    async _sendNotification(message) {
+        await this._webview.postMessage({
+            jsonrpc: "2.0",
+            ...message
+        });
+    }
+    dispose() {
+        this._disposeCts.dispose(true);
+        super.dispose();
+    }
+};
+ChatMcpAppModel = ChatMcpAppModel_1 = ( __decorate([( __param(5, IInstantiationService)), ( __param(6, IChatWidgetService)), ( __param(7, IWebviewService)), ( __param(8, IStorageService)), ( __param(9, ILogService)), ( __param(10, IProductService)), ( __param(11, IOpenerService))], ChatMcpAppModel));
+
+export { ChatMcpAppModel };

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

@@ -0,0 +1,49 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMarkdownRendererService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+/**
+ * Data needed to render an MCP App, available before tool completion.
+ */
+export interface IMcpAppRenderData {
+    /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */
+    readonly resourceUri: string;
+    /** Reference to the server definition for reconnection */
+    readonly serverDefinitionId: string;
+    /** Reference to the collection containing the server */
+    readonly collectionId: string;
+    /** The tool input arguments as a JSON string */
+    readonly input: string;
+    /** The session resource URI for the chat session */
+    readonly sessionResource: URI;
+}
+/**
+ * Sub-part for rendering MCP App webviews in chat tool output.
+ * This is a thin view layer that delegates to ChatMcpAppModel.
+ */
+export declare class ChatMcpAppSubPart extends BaseChatToolInvocationSubPart {
+    private readonly _renderData;
+    private readonly _instantiationService;
+    private readonly _markdownRendererService;
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    /** The model that owns the webview */
+    private readonly _model;
+    /** The webview container */
+    private readonly _webviewContainer;
+    /** Current progress part for loading state */
+    private readonly _progressPart;
+    /** Current error node */
+    private _errorNode;
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, onDidRemount: Event<void>, context: IChatContentPartRenderContext, _renderData: IMcpAppRenderData, _instantiationService: IInstantiationService, _markdownRendererService: IMarkdownRendererService);
+    private _handleLoadStateChange;
+    private _updateContainerHeight;
+    /**
+     * Shows an error message in the container.
+     */
+    private _showError;
+}