@codingame/monaco-vscode-katex-common 34.1.3 → 35.0.1

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

@@ -0,0 +1,279 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, clearNode, append, addDisposableListener, EventType, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { Checkbox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { DisposableMap, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+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 { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { defaultCheckboxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { ResourceLabels, DEFAULT_LABELS_CONTAINER } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { ToolConfirmKind, AgentFeedbackReviewCommandId, IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatToolRiskAssessmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService.service';
+import { ChatCustomConfirmationWidget } from '../chatConfirmationWidget.js';
+import { AbstractToolConfirmationSubPart } from './abstractToolConfirmationSubPart.js';
+import * as chatAgentFeedbackReviewConfirmation from '../media/chatAgentFeedbackReviewConfirmation.css';
+
+registerCss(chatAgentFeedbackReviewConfirmation);
+let ChatAgentFeedbackReviewConfirmationSubPart = class ChatAgentFeedbackReviewConfirmationSubPart extends AbstractToolConfirmationSubPart {
+    constructor(
+        toolInvocation,
+        context,
+        instantiationService,
+        keybindingService,
+        contextKeyService,
+        chatWidgetService,
+        languageModelToolsService,
+        riskAssessmentService,
+        commandService,
+        logService,
+        hoverService
+    ) {
+        super(
+            toolInvocation,
+            context,
+            instantiationService,
+            keybindingService,
+            contextKeyService,
+            chatWidgetService,
+            languageModelToolsService,
+            riskAssessmentService
+        );
+        this.commandService = commandService;
+        this.logService = logService;
+        this.hoverService = hoverService;
+        this.codeblocks = [];
+        this._rows = ( new Map());
+        this._rowStores = this._register(( new DisposableMap()));
+        const data = toolInvocation.toolSpecificData;
+        if (!data || data.kind !== "agentFeedbackReviewConfirmation") {
+            throw ( new Error("Agent feedback review confirmation data is missing"));
+        }
+        this._resourceLabels = this._register(
+            this.instantiationService.createInstance(ResourceLabels, DEFAULT_LABELS_CONTAINER)
+        );
+        const listElement = $(".chat-agent-feedback-review-list");
+        void this._populate(listElement);
+        const revealLabel = data.options[0] ?? ( localize(8060, "Reveal Selected"));
+        const buttons = [{
+            label: revealLabel,
+            data: () => this._onReveal()
+        }, {
+            label: ( localize(8061, "Cancel")),
+            isSecondary: true,
+            data: () => this.confirmWith(this.toolInvocation, {
+                type: ToolConfirmKind.Skipped
+            })
+        }];
+        const confirmWidget = this._register(
+            this.instantiationService.createInstance(ChatCustomConfirmationWidget, this.context, {
+                title: this.getTitle(),
+                icon: Codicon.commentDiscussion,
+                message: listElement,
+                buttons
+            })
+        );
+        const hasToolConfirmation = ChatContextKeys.Editing.hasToolConfirmation.bindTo(this.contextKeyService);
+        hasToolConfirmation.set(true);
+        this._register(confirmWidget.onDidClick((
+            {
+                button,
+                isTouchClick
+            }
+        ) => {
+            button.data();
+            if (!isTouchClick) {
+                this.chatWidgetService.getWidgetBySessionResource(this.context.element.sessionResource)?.focusInput();
+            }
+        }));
+        this._register(toDisposable(() => hasToolConfirmation.reset()));
+        this.domNode = confirmWidget.domNode;
+    }
+    get _sessionResource() {
+        return this.context.element.sessionResource;
+    }
+    async _populate(listElement) {
+        let comments = [];
+        try {
+            comments = (await this.commandService.executeCommand(AgentFeedbackReviewCommandId.GetComments, this._sessionResource)) ?? [];
+        } catch (error) {
+            this.logService.warn("[AgentFeedbackReview] Failed to fetch unreviewed comments", error);
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        clearNode(listElement);
+        if (!comments.length) {
+            listElement.append($(".chat-agent-feedback-review-empty", undefined, ( localize(8062, "No unreviewed comments."))));
+            return;
+        }
+        for (const comment of comments) {
+            this._renderRow(listElement, comment);
+        }
+    }
+    _renderRow(listElement, comment) {
+        const rowStore = ( new DisposableStore());
+        this._rowStores.set(comment.id, rowStore);
+        const rowElement = append(listElement, $(".chat-agent-feedback-review-row"));
+        const checkbox = rowStore.add(( new Checkbox(( localize(8063, "Reveal this comment to the agent")), true, defaultCheckboxStyles)));
+        append(rowElement, checkbox.domNode);
+        const main = append(rowElement, $(".chat-agent-feedback-review-main"));
+        const header = append(main, $(".chat-agent-feedback-review-header"));
+        if (comment.kindLabel) {
+            append(
+                header,
+                $(".chat-agent-feedback-review-kind", undefined, comment.kindLabel)
+            );
+        }
+        const fileUri = URI.revive(comment.fileUri);
+        const fileLabel = rowStore.add(this._resourceLabels.create(header));
+        fileLabel.element.classList.add("chat-agent-feedback-review-file");
+        fileLabel.setResource({
+            resource: fileUri,
+            name: basename(fileUri)
+        }, {
+            fileKind: FileKind.FILE,
+            title: fileUri.fsPath || fileUri.path
+        });
+        this._renderCommentText(rowStore, main, comment.text);
+        const actionsContainer = append(rowElement, $(".chat-agent-feedback-review-actions"));
+        const actionBar = rowStore.add(( new ActionBar(actionsContainer)));
+        actionBar.push(rowStore.add(( new Action("agentFeedbackReview.reveal", ( localize(8064, "Open File and Reveal Comment")), ThemeIcon.asClassName(Codicon.goToFile), true, () => this._reveal(comment.id)))), {
+            icon: true,
+            label: false
+        });
+        actionBar.push(rowStore.add(( new Action("agentFeedbackReview.delete", ( localize(8065, "Delete Comment")), ThemeIcon.asClassName(Codicon.close), true, () => this._delete(comment.id)))), {
+            icon: true,
+            label: false
+        });
+        this._rows.set(comment.id, {
+            comment,
+            checkbox,
+            element: rowElement
+        });
+    }
+    _renderCommentText(rowStore, main, text) {
+        const container = append(main, $(".chat-agent-feedback-review-text-container"));
+        const textElement = append(container, $(".chat-agent-feedback-review-text"));
+        textElement.textContent = text;
+        const toggle = append(container, $("button.chat-agent-feedback-review-expand-toggle"));
+        toggle.type = "button";
+        toggle.tabIndex = 0;
+        const toggleIcon = append(toggle, $("span.codicon"));
+        toggleIcon.setAttribute("aria-hidden", "true");
+        const expandLabel = ( localize(8066, "Show More"));
+        const collapseLabel = ( localize(8067, "Show Less"));
+        let expanded = false;
+        const renderState = () => {
+            container.classList.toggle("collapsed", !expanded);
+            container.classList.toggle("expanded", expanded);
+            toggleIcon.classList.toggle("codicon-chevron-down", !expanded);
+            toggleIcon.classList.toggle("codicon-chevron-up", expanded);
+            toggle.setAttribute("aria-label", expanded ? collapseLabel : expandLabel);
+            toggle.setAttribute("aria-expanded", String(expanded));
+        };
+        const isOverflowing = () => {
+            const wasExpanded = expanded;
+            if (wasExpanded) {
+                container.classList.add("collapsed");
+                container.classList.remove("expanded");
+            }
+            const overflowing = textElement.scrollHeight - textElement.clientHeight > 1;
+            if (wasExpanded) {
+                container.classList.remove("collapsed");
+                container.classList.add("expanded");
+            }
+            return overflowing;
+        };
+        const updateOverflow = () => {
+            const overflowing = isOverflowing();
+            container.classList.toggle("overflowing", overflowing);
+            if (!overflowing && expanded) {
+                expanded = false;
+                renderState();
+            }
+        };
+        rowStore.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("element"),
+            toggle,
+            () => expanded ? collapseLabel : expandLabel
+        ));
+        rowStore.add(addDisposableListener(toggle, EventType.CLICK, e => {
+            e.preventDefault();
+            e.stopPropagation();
+            expanded = !expanded;
+            renderState();
+        }));
+        renderState();
+        const targetWindow = getWindow(container);
+        const observer = new targetWindow.ResizeObserver(() => updateOverflow());
+        observer.observe(textElement);
+        rowStore.add(toDisposable(() => observer.disconnect()));
+    }
+    async _reveal(commentId) {
+        try {
+            await this.commandService.executeCommand(AgentFeedbackReviewCommandId.Reveal, this._sessionResource, commentId);
+        } catch (error) {
+            this.logService.warn("[AgentFeedbackReview] Failed to reveal comment", error);
+        }
+    }
+    async _delete(commentId) {
+        const row = this._rows.get(commentId);
+        try {
+            await this.commandService.executeCommand(AgentFeedbackReviewCommandId.Delete, this._sessionResource, commentId);
+            row?.element.remove();
+            this._rows.delete(commentId);
+            this._rowStores.deleteAndDispose(commentId);
+        } catch (error) {
+            this.logService.warn("[AgentFeedbackReview] Failed to delete comment", error);
+        }
+    }
+    async _onReveal() {
+        const checkedIds = [];
+        for (const row of ( this._rows.values())) {
+            if (row.checkbox.checked) {
+                checkedIds.push(row.comment.id);
+            }
+        }
+        if (checkedIds.length) {
+            try {
+                await this.commandService.executeCommand(AgentFeedbackReviewCommandId.Accept, this._sessionResource, checkedIds);
+            } catch (error) {
+                this.logService.warn("[AgentFeedbackReview] Failed to accept comments", error);
+            }
+        }
+        this.confirmWith(this.toolInvocation, {
+            type: ToolConfirmKind.UserAction
+        });
+    }
+    createContentElement() {
+        return "";
+    }
+    getTitle() {
+        const state = this.toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            return "";
+        }
+        const title = state.confirmationMessages?.title;
+        return typeof title === "string" ? title : title?.value ?? "";
+    }
+};
+ChatAgentFeedbackReviewConfirmationSubPart = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IKeybindingService)), ( __param(4, IContextKeyService)), ( __param(5, IChatWidgetService)), ( __param(6, ILanguageModelToolsService)), ( __param(7, IChatToolRiskAssessmentService)), ( __param(8, ICommandService)), ( __param(9, ILogService)), ( __param(10, IHoverService))], ChatAgentFeedbackReviewConfirmationSubPart));
+
+export { ChatAgentFeedbackReviewConfirmationSubPart };

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

@@ -46,9 +46,9 @@ let ExtensionsInstallConfirmationWidgetSubPart = class ExtensionsInstallConfirma
         append(this.domNode, chatExtensionsContentPart.domNode);
         const state = toolInvocation.state.get();
         if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-            const allowLabel = ( localize(7517, "Allow"));
+            const allowLabel = ( localize(8068, "Allow"));
             const allowTooltip = keybindingService.appendKeybinding(allowLabel, AcceptToolConfirmationActionId);
-            const cancelLabel = ( localize(7518, "Cancel"));
+            const cancelLabel = ( localize(8069, "Cancel"));
             const cancelTooltip = keybindingService.appendKeybinding(cancelLabel, CancelChatActionId);
             const enableAllowButtonEvent = this._register(( new Emitter()));
             const buttons = [{
@@ -68,9 +68,9 @@ let ExtensionsInstallConfirmationWidgetSubPart = class ExtensionsInstallConfirma
                 tooltip: cancelTooltip
             }];
             const confirmWidget = this._register(instantiationService.createInstance(ChatConfirmationWidget, context, {
-                title: state.confirmationMessages?.title ?? ( localize(7519, "Install Extensions")),
+                title: state.confirmationMessages?.title ?? ( localize(8070, "Install Extensions")),
                 message: state.confirmationMessages?.message ?? ( localize(
-                    7520,
+                    8071,
                     "Click the Install button on the extension and then press Allow when finished."
                 )),
                 buttons

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

@@ -40,7 +40,17 @@ export declare class ChatMcpAppModel extends Disposable {
     private readonly _productService;
     private readonly _openerService;
     private static readonly heightCache;
-    /** Origin store for persistent webview origins per server */
+    /**
+     * In-memory origin map for agent-host MCP servers. Agent-host server
+     * ids embed the session id, so they're effectively single-use across
+     * VS Code restarts — using {@link WebviewOriginStore} for them would
+     * accumulate one persisted entry per agent-host session forever. The
+     * in-memory map keeps origins stable for the lifetime of the app
+     * (enough for webview state to persist across re-renders) without
+     * touching application storage.
+     */
+    private static readonly _agentHostOrigins;
+    /** Origin store for persistent webview origins per server (local MCP only) */
     private readonly _originStore;
     /** The webview element instance */
     private readonly _webview;
@@ -97,6 +107,32 @@ export declare class ChatMcpAppModel extends Disposable {
     /**
      * Sends the tool result notification when the result becomes available.
      */
+    /**
+     * Returns a stable identifier for the originating MCP server to use
+     * as the webview origin key. Local servers use their definition id,
+     * agent-host servers use the per-session `serverId`.
+     */
+    private _serverOriginId;
+    /**
+     * Picks a stable webview origin for this server. Local MCP servers
+     * get a persisted origin via {@link WebviewOriginStore} since their
+     * server-definition id is stable across VS Code restarts. Agent-host
+     * servers fall back to the static in-memory {@link _agentHostOrigins}
+     * map keyed by `serverId`, so origins are stable within the app
+     * lifetime without leaking entries into application storage for
+     * every session.
+     */
+    private _computeWebviewOrigin;
+    /**
+     * Resolves a server-relative resource URI into a workbench URI.
+     * - Local servers: wrap in {@link McpResourceURI.fromServer} so it
+     *   resolves through the MCP filesystem provider.
+     * - Agent-host servers: pass through as a plain {@link URI}. There's
+     *   no host-side resolver for AHP-backed servers in v1, so these
+     *   URIs may not be openable, but they preserve the original
+     *   resource reference for the user.
+     */
+    private _resolveServerResourceUri;
     private _sendToolResult;
     private _handleUiMessage;
     private _handleUpdateModelContext;
@@ -112,6 +148,12 @@ export declare class ChatMcpAppModel extends Disposable {
      * Handles resources/read requests from the MCP App.
      */
     private _handleResourcesRead;
+    /**
+     * Handles sampling/createMessage requests from the MCP App. Forwarded
+     * to the host-side sampling implementation through the underlying
+     * transport (typically an agent host that owns the MCP server).
+     */
+    private _handleSamplingCreateMessage;
     private _sendResponse;
     private _sendError;
     private _sendNotification;

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

@@ -14,6 +14,7 @@ import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/res
 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 { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IChatResponseResourceFileSystemProvider } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/chatResponseResourceFileSystemProvider.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
@@ -41,6 +42,9 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
     static {
         this.heightCache = ( new WeakMap());
     }
+    static {
+        this._agentHostOrigins = ( new Map());
+    }
     constructor(
         toolInvocation,
         renderData,
@@ -79,12 +83,12 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
         this._downloadParts = observableValue(this, []);
         this.downloadParts = this._downloadParts;
         this._originStore = ( new WebviewOriginStore(ORIGIN_STORE_KEY, storageService));
-        this._webviewOrigin = this._originStore.getOrigin("mcpApp", renderData.serverDefinitionId);
+        this._webviewOrigin = this._computeWebviewOrigin();
         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(7521, "MCP App")),
+            title: ( localize(8072, "MCP App")),
             options: {
                 purpose: WebviewContentPurpose.ChatOutputItem,
                 enableFindWidget: false,
@@ -127,6 +131,16 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
         ) => {
             await this._handleWebviewMessage(message);
         }));
+        this._register(this._mcpToolCallUI.onNotification(n => {
+            if (!this._announcedCapabilities) {
+                return;
+            }
+            this._webview.postMessage({
+                jsonrpc: "2.0",
+                method: n.method,
+                params: n.params
+            });
+        }));
         this._loadContent();
     }
     get height() {
@@ -339,6 +353,9 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
             case "resources/read":
                 result = await this._handleResourcesRead(request.params, token);
                 break;
+            case "sampling/createMessage":
+                result = await this._handleSamplingCreateMessage(request.params, token);
+                break;
             case "ping":
                 break;
             case "ui/notifications/size-changed":
@@ -456,6 +473,30 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
             hostContext: this.hostContext.get()
         };
     }
+    _serverOriginId() {
+        return this.renderData.kind === "agentHost" ? this.renderData.serverId : this.renderData.serverDefinitionId;
+    }
+    _computeWebviewOrigin() {
+        if (this.renderData.kind !== "agentHost") {
+            return this._originStore.getOrigin("mcpApp", this._serverOriginId());
+        }
+        const key = this._serverOriginId();
+        let origin = ChatMcpAppModel_1._agentHostOrigins.get(key);
+        if (!origin) {
+            origin = generateUuid();
+            ChatMcpAppModel_1._agentHostOrigins.set(key, origin);
+        }
+        return origin;
+    }
+    _resolveServerResourceUri(serverUri) {
+        if (this.renderData.kind === "agentHost") {
+            return ( URI.parse(serverUri));
+        }
+        return McpResourceURI.fromServer({
+            id: this.renderData.serverDefinitionId,
+            label: ""
+        }, serverUri);
+    }
     _sendToolResult(resultDetails) {
         if (isToolResultInputOutputDetails(resultDetails) && resultDetails.mcpOutput) {
             this._sendNotification({
@@ -487,10 +528,7 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
                     name: "Image"
                 };
             } else if (c.type === "resource_link") {
-                const uri = McpResourceURI.fromServer({
-                    id: this.renderData.serverDefinitionId,
-                    label: ""
-                }, c.uri);
+                const uri = this._resolveServerResourceUri(c.uri);
                 return {
                     kind: "file",
                     value: uri,
@@ -511,7 +549,7 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
         if (!widget) {
             return {};
         }
-        const idPrefix = `mcpui-context-${hash(this.renderData.serverDefinitionId)}-`;
+        const idPrefix = `mcpui-context-${hash(this._serverOriginId())}-`;
         const toDelete = widget.attachmentModel.getAttachmentIDs();
         const idsToDelete = Array.from(toDelete).filter(id => id.startsWith(idPrefix));
         const entries = [];
@@ -528,10 +566,7 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
                         mimeType: block.mimeType
                     });
                 } else if (block.type === "resource_link") {
-                    const uri = McpResourceURI.fromServer({
-                        id: this.renderData.serverDefinitionId,
-                        label: ""
-                    }, block.uri);
+                    const uri = this._resolveServerResourceUri(block.uri);
                     entries.push({
                         kind: "file",
                         value: uri,
@@ -613,10 +648,7 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
                         uri
                     });
                 } else if (content.type === "resource_link") {
-                    const mcpUri = McpResourceURI.fromServer({
-                        id: this.renderData.serverDefinitionId,
-                        label: ""
-                    }, content.uri);
+                    const mcpUri = this._resolveServerResourceUri(content.uri);
                     newParts.push({
                         kind: "data",
                         mimeType: content.mimeType,
@@ -673,6 +705,12 @@ let ChatMcpAppModel = class ChatMcpAppModel extends Disposable {
         }
         return this._mcpToolCallUI.readResource(params.uri, token);
     }
+    async _handleSamplingCreateMessage(params, token) {
+        if (!params) {
+            throw ( new Error("Missing params in sampling/createMessage request"));
+        }
+        return this._mcpToolCallUI.sampling(params, token);
+    }
     async _sendResponse(id, result) {
         await this._webview.postMessage({
             jsonrpc: "2.0",

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

@@ -2,25 +2,23 @@ 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 { ChatMcpAppData, 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 "../chatContentParts.js";
 import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
 /**
  * Data needed to render an MCP App, available before tool completion.
+ *
+ * Composed of the underlying MCP App backend descriptor (a discriminated
+ * union — see {@link ChatMcpAppData}) plus rendering context (`input`,
+ * `sessionResource`).
  */
-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;
+export type IMcpAppRenderData = ChatMcpAppData & {
     /** 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.

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

@@ -100,7 +100,7 @@ let ChatMcpAppSubPart = class ChatMcpAppSubPart extends BaseChatToolInvocationSu
             {
                 container.style.display = "none";
                 const progressMessage = $("span");
-                progressMessage.textContent = ( localize(7522, "Loading MCP App..."));
+                progressMessage.textContent = ( localize(8073, "Loading MCP App..."));
                 const progressPart = this._instantiationService.createInstance(
                     ChatProgressSubPart,
                     progressMessage,
@@ -130,12 +130,12 @@ let ChatMcpAppSubPart = class ChatMcpAppSubPart extends BaseChatToolInvocationSu
     _showError(container, error) {
         const errorNode = $(".mcp-app-error");
         const errorMessage = ( new MarkdownString());
-        errorMessage.appendText(( localize(7523, "Error loading MCP App: {0}", error.message || String(error))));
+        errorMessage.appendText(( localize(8074, "Error loading MCP App: {0}", error.message || String(error))));
         const errorWidget = this._register(( new ChatErrorWidget(ChatErrorLevel.Error, errorMessage, this._markdownRendererService)));
         errorNode.appendChild(errorWidget.domNode);
         const buttonContainer = append(errorNode, $(".chat-buttons-container"));
         const retryButton = this._register(( new Button(buttonContainer, defaultButtonStyles)));
-        retryButton.label = ( localize(7524, "Retry"));
+        retryButton.label = ( localize(8075, "Retry"));
         this._register(retryButton.onDidClick(() => {
             this._model.retry();
         }));

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

@@ -7,18 +7,21 @@ import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/work
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
 import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatToolRiskAssessmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService.service";
 import { IChatContentPartRenderContext } from "../chatContentParts.js";
+import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service";
 import { CollapsibleListPool } from "../chatReferencesContentPart.js";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { AbstractToolConfirmationSubPart } from "./abstractToolConfirmationSubPart.js";
 export declare class ChatModifiedFilesConfirmationSubPart extends AbstractToolConfirmationSubPart {
     private readonly listPool;
     private readonly markdownRendererService;
+    private readonly chatMarkdownAnchorService;
     private readonly editorService;
     private readonly commandService;
     readonly domNode: HTMLElement;
     readonly codeblocks: IChatCodeBlockInfo[];
-    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, listPool: CollapsibleListPool, instantiationService: IInstantiationService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, languageModelToolsService: ILanguageModelToolsService, markdownRendererService: IMarkdownRendererService, editorService: IEditorService, commandService: ICommandService);
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, listPool: CollapsibleListPool, instantiationService: IInstantiationService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, languageModelToolsService: ILanguageModelToolsService, markdownRendererService: IMarkdownRendererService, chatMarkdownAnchorService: IChatMarkdownAnchorService, editorService: IEditorService, commandService: ICommandService, riskAssessmentService: IChatToolRiskAssessmentService);
     private createButtons;
     private createWidgetContentElement;
     private createModifiedFilesElement;