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

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChat.js

@@ -29,7 +29,7 @@ var InlineChatConfigKeys;
     id: "editor",
     properties: {
         [InlineChatConfigKeys.NotebookAgent]: {
-            markdownDescription: ( localize(10731, "Enable agent-like behavior for inline chat widget in notebooks.")),
+            markdownDescription: ( localize(11347, "Enable agent-like behavior for inline chat widget in notebooks.")),
             default: false,
             type: "boolean",
             tags: ["experimental"],
@@ -39,13 +39,13 @@ var InlineChatConfigKeys;
         },
         [InlineChatConfigKeys.Affordance]: {
             description: ( localize(
-                10732,
+                11348,
                 "Controls whether an inline chat affordance is shown when text is selected."
             )),
             default: "off",
             type: "string",
             enum: ["off", "editor"],
-            enumDescriptions: [( localize(10733, "No affordance is shown.")), ( localize(10734, "Show an affordance in the editor at the cursor position."))],
+            enumDescriptions: [( localize(11349, "No affordance is shown.")), ( localize(11350, "Show an affordance in the editor at the cursor position."))],
             experiment: {
                 mode: "auto"
             },
@@ -56,7 +56,7 @@ var InlineChatConfigKeys;
         },
         [InlineChatConfigKeys.FixDiagnostics]: {
             description: ( localize(
-                10735,
+                11351,
                 "Controls whether the Fix action is shown for diagnostics in the editor."
             )),
             default: true,
@@ -68,7 +68,7 @@ var InlineChatConfigKeys;
         },
         [InlineChatConfigKeys.AskInChat]: {
             description: ( localize(
-                10736,
+                11352,
                 "Controls whether files in a chat editing session use Ask in Chat instead of Inline Chat."
             )),
             default: true,
@@ -78,23 +78,23 @@ var InlineChatConfigKeys;
 });
 const INLINE_CHAT_ID = "editor.contrib.inlineChatController";
 const CTX_INLINE_CHAT_POSSIBLE = ( new RawContextKey("inlineChatPossible", false, ( localize(
-    10737,
+    11353,
     "Whether a provider for inline chat exists and whether an editor for inline chat is open"
 ))));
-const CTX_INLINE_CHAT_HAS_AGENT = ( new RawContextKey("inlineChatHasEditsAgent", false, ( localize(10738, "Whether an agent for inline chat in interactive editors exists"))));
-const CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE = ( new RawContextKey("inlineChatHasNotebookInline", false, ( localize(10739, "Whether an agent for notebook cells exists"))));
-const CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT = ( new RawContextKey("inlineChatHasNotebookAgent", false, ( localize(10740, "Whether an agent for notebook cells exists"))));
-const CTX_INLINE_CHAT_VISIBLE = ( new RawContextKey("inlineChatVisible", false, ( localize(10741, "Whether the interactive editor input is visible"))));
-const CTX_INLINE_CHAT_FOCUSED = ( new RawContextKey("inlineChatFocused", false, ( localize(10742, "Whether the interactive editor input is focused"))));
-const CTX_INLINE_CHAT_RESPONSE_FOCUSED = ( new RawContextKey("inlineChatResponseFocused", false, ( localize(10743, "Whether the interactive widget's response is focused"))));
+const CTX_INLINE_CHAT_HAS_AGENT = ( new RawContextKey("inlineChatHasEditsAgent", false, ( localize(11354, "Whether an agent for inline chat in interactive editors exists"))));
+const CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE = ( new RawContextKey("inlineChatHasNotebookInline", false, ( localize(11355, "Whether an agent for notebook cells exists"))));
+const CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT = ( new RawContextKey("inlineChatHasNotebookAgent", false, ( localize(11356, "Whether an agent for notebook cells exists"))));
+const CTX_INLINE_CHAT_VISIBLE = ( new RawContextKey("inlineChatVisible", false, ( localize(11357, "Whether the interactive editor input is visible"))));
+const CTX_INLINE_CHAT_FOCUSED = ( new RawContextKey("inlineChatFocused", false, ( localize(11358, "Whether the interactive editor input is focused"))));
+const CTX_INLINE_CHAT_RESPONSE_FOCUSED = ( new RawContextKey("inlineChatResponseFocused", false, ( localize(11359, "Whether the interactive widget's response is focused"))));
 const CTX_INLINE_CHAT_OUTER_CURSOR_POSITION = ( new RawContextKey("inlineChatOuterCursorPosition", "", ( localize(
-    10744,
+    11360,
     "Whether the cursor of the outer editor is above or below the interactive editor input"
 ))));
-const CTX_INLINE_CHAT_REQUEST_IN_PROGRESS = ( new RawContextKey("inlineChatRequestInProgress", false, ( localize(10745, "Whether an inline chat request is currently in progress"))));
-const CTX_INLINE_CHAT_FILE_BELONGS_TO_CHAT = ( new RawContextKey("inlineChatFileBelongsToChat", false, ( localize(10746, "Whether the current file belongs to a chat editing session"))));
-const CTX_INLINE_CHAT_TERMINATED = ( new RawContextKey("inlineChatTerminated", false, ( localize(10747, "Whether the current inline chat session is terminated"))));
-const CTX_INLINE_CHAT_AFFORDANCE_VISIBLE = ( new RawContextKey("inlineChatAffordanceVisible", false, ( localize(10748, "Whether an inline chat affordance widget is visible"))));
+const CTX_INLINE_CHAT_REQUEST_IN_PROGRESS = ( new RawContextKey("inlineChatRequestInProgress", false, ( localize(11361, "Whether an inline chat request is currently in progress"))));
+const CTX_INLINE_CHAT_FILE_BELONGS_TO_CHAT = ( new RawContextKey("inlineChatFileBelongsToChat", false, ( localize(11362, "Whether the current file belongs to a chat editing session"))));
+const CTX_INLINE_CHAT_TERMINATED = ( new RawContextKey("inlineChatTerminated", false, ( localize(11363, "Whether the current inline chat session is terminated"))));
+const CTX_INLINE_CHAT_AFFORDANCE_VISIBLE = ( new RawContextKey("inlineChatAffordanceVisible", false, ( localize(11364, "Whether an inline chat affordance widget is visible"))));
 const CTX_INLINE_CHAT_V2_ENABLED = ( ContextKeyExpr.or(CTX_INLINE_CHAT_HAS_AGENT, ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT))));
 const CTX_FIX_DIAGNOSTICS_ENABLED = ( ContextKeyExpr.equals("config.inlineChat.fixDiagnostics", true));
 const CTX_ASK_IN_CHAT_ENABLED = ( ContextKeyExpr.equals("config.inlineChat.askInChat", true));
@@ -102,37 +102,37 @@ const ACTION_START = "inlineChat.start";
 const ACTION_ASK_IN_CHAT = "inlineChat.askInChat";
 const MENU_INLINE_CHAT_WIDGET_SECONDARY = MenuId.for("inlineChatWidget.secondary");
 const MENU_INLINE_CHAT_SIDE = MenuId.for("inlineChatWidget.side");
-const inlineChatForeground = registerColor("inlineChat.foreground", editorWidgetForeground, ( localize(10749, "Foreground color of the interactive editor widget")));
-const inlineChatBackground = registerColor("inlineChat.background", editorWidgetBackground, ( localize(10750, "Background color of the interactive editor widget")));
-registerColor("inlineChat.border", editorWidgetBorder, ( localize(10751, "Border color of the interactive editor widget")));
-registerColor("inlineChat.shadow", widgetShadow, ( localize(10752, "Shadow color of the interactive editor widget")));
-registerColor("inlineChatInput.border", editorWidgetBorder, ( localize(10753, "Border color of the interactive editor input")));
-registerColor("inlineChatInput.focusBorder", focusBorder, ( localize(10754, "Border color of the interactive editor input when focused")));
+const inlineChatForeground = registerColor("inlineChat.foreground", editorWidgetForeground, ( localize(11365, "Foreground color of the interactive editor widget")));
+const inlineChatBackground = registerColor("inlineChat.background", editorWidgetBackground, ( localize(11366, "Background color of the interactive editor widget")));
+registerColor("inlineChat.border", editorWidgetBorder, ( localize(11367, "Border color of the interactive editor widget")));
+registerColor("inlineChat.shadow", widgetShadow, ( localize(11368, "Shadow color of the interactive editor widget")));
+registerColor("inlineChatInput.border", editorWidgetBorder, ( localize(11369, "Border color of the interactive editor input")));
+registerColor("inlineChatInput.focusBorder", focusBorder, ( localize(11370, "Border color of the interactive editor input when focused")));
 registerColor(
     "inlineChatInput.placeholderForeground",
     inputPlaceholderForeground,
-    ( localize(10755, "Foreground color of the interactive editor input placeholder"))
+    ( localize(11371, "Foreground color of the interactive editor input placeholder"))
 );
-registerColor("inlineChatInput.background", inputBackground, ( localize(10756, "Background color of the interactive editor input")));
-registerColor("inlineChatDiff.inserted", ( transparent(diffInserted, .5)), ( localize(10757, "Background color of inserted text in the interactive editor input")));
+registerColor("inlineChatInput.background", inputBackground, ( localize(11372, "Background color of the interactive editor input")));
+registerColor("inlineChatDiff.inserted", ( transparent(diffInserted, .5)), ( localize(11373, "Background color of inserted text in the interactive editor input")));
 registerColor("editorOverviewRuler.inlineChatInserted", {
     dark: ( transparent(diffInserted, 0.6)),
     light: ( transparent(diffInserted, 0.8)),
     hcDark: ( transparent(diffInserted, 0.6)),
     hcLight: ( transparent(diffInserted, 0.8))
-}, ( localize(10758, "Overview ruler marker color for inline chat inserted content.")));
+}, ( localize(11374, "Overview ruler marker color for inline chat inserted content.")));
 registerColor("editorMinimap.inlineChatInserted", {
     dark: ( transparent(diffInserted, 0.6)),
     light: ( transparent(diffInserted, 0.8)),
     hcDark: ( transparent(diffInserted, 0.6)),
     hcLight: ( transparent(diffInserted, 0.8))
-}, ( localize(10759, "Minimap marker color for inline chat inserted content.")));
-registerColor("inlineChatDiff.removed", ( transparent(diffRemoved, .5)), ( localize(10760, "Background color of removed text in the interactive editor input")));
+}, ( localize(11375, "Minimap marker color for inline chat inserted content.")));
+registerColor("inlineChatDiff.removed", ( transparent(diffRemoved, .5)), ( localize(11376, "Background color of removed text in the interactive editor input")));
 registerColor("editorOverviewRuler.inlineChatRemoved", {
     dark: ( transparent(diffRemoved, 0.6)),
     light: ( transparent(diffRemoved, 0.8)),
     hcDark: ( transparent(diffRemoved, 0.6)),
     hcLight: ( transparent(diffRemoved, 0.8))
-}, ( localize(10761, "Overview ruler marker color for inline chat removed content.")));
+}, ( localize(11377, "Overview ruler marker color for inline chat removed content.")));
 
 export { ACTION_ASK_IN_CHAT, ACTION_START, CTX_ASK_IN_CHAT_ENABLED, CTX_FIX_DIAGNOSTICS_ENABLED, CTX_INLINE_CHAT_AFFORDANCE_VISIBLE, CTX_INLINE_CHAT_FILE_BELONGS_TO_CHAT, CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_HAS_AGENT, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE, CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, CTX_INLINE_CHAT_POSSIBLE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_TERMINATED, CTX_INLINE_CHAT_V2_ENABLED, CTX_INLINE_CHAT_VISIBLE, INLINE_CHAT_ID, InlineChatConfigKeys, MENU_INLINE_CHAT_SIDE, MENU_INLINE_CHAT_WIDGET_SECONDARY, inlineChatBackground, inlineChatForeground };

package/vscode/src/vs/workbench/contrib/interactive/browser/replInputHintContentWidget.js

@@ -88,7 +88,7 @@ let ReplInputHintContentWidget = class ReplInputHintContentWidget extends Dispos
         const keybinding = this.getKeybinding();
         const keybindingHintLabel = keybinding?.getLabel();
         if (keybinding && keybindingHintLabel) {
-            const actionPart = ( localize(10784, "Press {0} to execute. ", keybindingHintLabel));
+            const actionPart = ( localize(11400, "Press {0} to execute. ", keybindingHintLabel));
             const [before, after] = ( actionPart.split(keybindingHintLabel).map(fragment => {
                 const hintPart = $("span", undefined, fragment);
                 hintPart.style.fontStyle = "italic";
@@ -105,9 +105,9 @@ let ReplInputHintContentWidget = class ReplInputHintContentWidget extends Dispos
             hintElement.appendChild(after);
             this.domNode.append(hintElement);
             const helpKeybinding = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
-            const helpInfo = helpKeybinding ? ( localize(10785, "Use {0} for accessibility help. ", helpKeybinding)) : ( localize(10786, "Run the Open Accessibility Help command for more information. "));
+            const helpInfo = helpKeybinding ? ( localize(11401, "Use {0} for accessibility help. ", helpKeybinding)) : ( localize(11402, "Run the Open Accessibility Help command for more information. "));
             this.ariaLabel = actionPart.concat(helpInfo, ( localize(
-                10787,
+                11403,
                 " Toggle {0} in settings to disable this hint.",
                 AccessibilityVerbositySettingId.ReplEditor
             )));

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpToolCallUI.d.ts

@@ -1,9 +1,10 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
 import { IMcpToolCallUIData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
-import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
 import { MCP } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol";
 import { McpApps } from "../common/modelContextProtocolApps.js";
 /**
@@ -15,19 +16,47 @@ export interface IMcpAppResourceContent extends McpApps.McpUiResourceMeta {
     /** MIME type of the content */
     readonly mimeType: string;
 }
+/**
+ * Transport abstraction for the constrained subset of MCP requests an MCP
+ * App's webview makes back to the host. Two implementations exist: one
+ * routes through {@link IMcpService} (local servers), the other through
+ * {@link IAgentHostService.handleMcpRequest} on an `mcp://` AHP side
+ * channel (agent-host-resident servers).
+ */
+export interface IMcpAppCallTransport extends IDisposable {
+    /** Forwarded MCP server notifications (`notifications/*`) for this server. */
+    readonly onNotification: Event<{
+        readonly method: string;
+        readonly params?: unknown;
+    }>;
+    loadResource(token: CancellationToken): Promise<IMcpAppResourceContent>;
+    callTool(name: string, params: Record<string, unknown>, token: CancellationToken): Promise<MCP.CallToolResult>;
+    readResource(uri: string, token: CancellationToken): Promise<MCP.ReadResourceResult>;
+    sampling(params: MCP.CreateMessageRequest["params"], token: CancellationToken): Promise<MCP.CreateMessageResult>;
+    log(params: MCP.LoggingMessageNotificationParams): Promise<void>;
+}
 /**
  * Wrapper class that "upgrades" serializable IMcpToolCallUIData into a functional
  * object that can load UI resources and proxy tool/resource calls back to the MCP server.
+ *
+ * Selects the underlying transport based on whether the renderer was given
+ * an AHP `mcp://` channel — agent-host-resident servers route through
+ * {@link IAgentHostService}, everything else uses the local {@link IMcpService}.
  */
 export declare class McpToolCallUI extends Disposable {
     private readonly _uiData;
-    private readonly _mcpService;
     /**
      * Basic host context reflecting the current UI and theme. Notably lacks
      * the `toolInfo` or `viewport` sizes.
      */
     readonly hostContext: IObservable<McpApps.McpUiHostContext>;
-    constructor(_uiData: IMcpToolCallUIData, _mcpService: IMcpService, themeService: IThemeService);
+    private readonly _transport;
+    /** Forwarded MCP server notifications scoped to this App's server. */
+    readonly onNotification: Event<{
+        readonly method: string;
+        readonly params?: unknown;
+    }>;
+    constructor(_uiData: IMcpToolCallUIData, instantiationService: IInstantiationService, themeService: IThemeService);
     /**
      * Gets the underlying UI data.
      */
@@ -36,10 +65,6 @@ export declare class McpToolCallUI extends Disposable {
      * Logs a message to the MCP server's logger.
      */
     log(log: MCP.LoggingMessageNotificationParams): Promise<void>;
-    /**
-     * Gets or finds the MCP server for this UI.
-     */
-    private _getServer;
     /**
      * Loads the UI resource from the MCP server.
      * @param token Cancellation token
@@ -61,4 +86,10 @@ export declare class McpToolCallUI extends Disposable {
      * @returns The resource content
      */
     readResource(uri: string, token: CancellationToken): Promise<MCP.ReadResourceResult>;
+    /**
+     * Issues a `sampling/createMessage` request against the MCP server's
+     * host-side sampling implementation. Only supported when the App
+     * server runs inside an agent host that has opted into sampling.
+     */
+    sampling(params: MCP.CreateMessageRequest["params"], token: CancellationToken): Promise<MCP.CreateMessageResult>;
 }

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpToolCallUI.js

@@ -3,24 +3,177 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { Gesture } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
 import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { locale, isWeb, isMobile } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ColorScheme } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/theme';
 import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
 import { McpServer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpServer';
 import { McpToolVisibility } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
-import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
-import { translateMcpLogMessage, findMcpServer, startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
+import { IMcpService, IMcpSamplingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { findMcpServer, translateMcpLogMessage, startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
-let McpToolCallUI = class McpToolCallUI extends Disposable {
-    constructor(_uiData, _mcpService, themeService) {
+function readResourceContentToHtml(contents) {
+    if (!contents || contents.length === 0) {
+        throw ( new Error("UI resource not found on server"));
+    }
+    const content = contents[0];
+    let html;
+    const mimeType = content.mimeType || "text/html";
+    if (hasKey(content, {
+        text: true
+    })) {
+        html = content.text;
+    } else if (hasKey(content, {
+        blob: true
+    })) {
+        html = ( decodeBase64(content.blob).toString());
+    } else {
+        throw ( new Error("UI resource has no content"));
+    }
+    const meta = content._meta?.ui;
+    return {
+        ...meta,
+        html,
+        mimeType
+    };
+}
+let LocalMcpAppCallTransport = class LocalMcpAppCallTransport extends Disposable {
+    constructor(_uiData, _mcpService, _samplingService) {
         super();
         this._uiData = _uiData;
         this._mcpService = _mcpService;
+        this._samplingService = _samplingService;
+        this._onNotification = this._register(( new Emitter()));
+        this.onNotification = this._onNotification.event;
+    }
+    async _getServer(token) {
+        return findMcpServer(
+            this._mcpService,
+            s => s.definition.id === this._uiData.serverDefinitionId && s.collection.id === this._uiData.collectionId,
+            token
+        );
+    }
+    async log(params) {
+        const server = await this._getServer(CancellationToken.None);
+        if (server) {
+            translateMcpLogMessage(server.logger, params, `[App UI]`);
+        }
+    }
+    async loadResource(token) {
+        const server = await this._getServer(token);
+        if (!server) {
+            throw ( new Error("MCP server not found for UI resource"));
+        }
+        const resourceResult = await McpServer.callOn(server, h => h.readResource({
+            uri: this._uiData.resourceUri
+        }, token), token);
+        return readResourceContentToHtml(resourceResult.contents);
+    }
+    async callTool(name, params, token) {
+        const server = await this._getServer(token);
+        if (!server) {
+            throw ( new Error("MCP server not found for tool call"));
+        }
+        await startServerAndWaitForLiveTools(server, undefined, token);
+        const tool = server.tools.get().find(t => t.definition.name === name);
+        if (!tool || !(tool.visibility & McpToolVisibility.App)) {
+            throw ( new Error(`Tool not found on server: ${name}`));
+        }
+        const res = await tool.call(params, undefined, token);
+        return {
+            content: res.content,
+            isError: res.isError,
+            _meta: res._meta,
+            structuredContent: res.structuredContent
+        };
+    }
+    async readResource(uri, token) {
+        const server = await this._getServer(token);
+        if (!server) {
+            throw ( new Error("MCP server not found"));
+        }
+        return await McpServer.callOn(server, h => h.readResource({
+            uri
+        }, token), token);
+    }
+    async sampling(params, token) {
+        const server = await this._getServer(token);
+        if (!server) {
+            throw ( new Error("MCP server not found for sampling"));
+        }
+        const {
+            sample
+        } = await this._samplingService.sample({
+            server,
+            isDuringToolCall: true,
+            params
+        }, token);
+        return sample;
+    }
+};
+LocalMcpAppCallTransport = ( __decorate([( __param(1, IMcpService)), ( __param(2, IMcpSamplingService))], LocalMcpAppCallTransport));
+let AhpMcpAppCallTransport = class AhpMcpAppCallTransport extends Disposable {
+    constructor(_uiData, _channel, _agentHostService) {
+        super();
+        this._uiData = _uiData;
+        this._channel = _channel;
+        this._agentHostService = _agentHostService;
+        this._onNotification = this._register(( new Emitter()));
+        this.onNotification = this._onNotification.event;
+        this._register(this._agentHostService.onMcpNotification(n => {
+            if (n.channel === this._channel) {
+                this._onNotification.fire({
+                    method: n.method,
+                    params: n.params
+                });
+            }
+        }));
+    }
+    async log(params) {
+        try {
+            await this._agentHostService.handleMcpRequest(this._channel, "notifications/message", params);
+        } catch {}
+    }
+    async loadResource(_token) {
+        const result = await this._agentHostService.handleMcpRequest(this._channel, "resources/read", {
+            uri: this._uiData.resourceUri
+        });
+        return readResourceContentToHtml(result.contents);
+    }
+    async callTool(name, params, _token) {
+        const result = await this._agentHostService.handleMcpRequest(this._channel, "tools/call", {
+            name,
+            arguments: params
+        });
+        return result;
+    }
+    async readResource(uri, _token) {
+        const result = await this._agentHostService.handleMcpRequest(this._channel, "resources/read", {
+            uri
+        });
+        return result;
+    }
+    async sampling(params, _token) {
+        const result = await this._agentHostService.handleMcpRequest(this._channel, "sampling/createMessage", params);
+        return result;
+    }
+};
+AhpMcpAppCallTransport = ( __decorate([( __param(2, IAgentHostService))], AhpMcpAppCallTransport));
+let McpToolCallUI = class McpToolCallUI extends Disposable {
+    constructor(_uiData, instantiationService, themeService) {
+        super();
+        this._uiData = _uiData;
+        this._transport = this._register(
+            _uiData.kind === "agentHost" ? instantiationService.createInstance(AhpMcpAppCallTransport, _uiData, _uiData.channel) : instantiationService.createInstance(LocalMcpAppCallTransport, _uiData)
+        );
+        this.onNotification = this._transport.onNotification;
         const colorTheme = observableFromEvent(themeService.onDidColorThemeChange, () => {
             const type = themeService.getColorTheme().type;
             return type === ColorScheme.DARK || type === ColorScheme.HIGH_CONTRAST_DARK ? "dark" : "light";
@@ -122,79 +275,22 @@ let McpToolCallUI = class McpToolCallUI extends Disposable {
     get uiData() {
         return this._uiData;
     }
-    async log(log) {
-        const server = await this._getServer(CancellationToken.None);
-        if (server) {
-            translateMcpLogMessage(server.logger, log, `[App UI]`);
-        }
+    log(log) {
+        return this._transport.log(log);
     }
-    async _getServer(token) {
-        return findMcpServer(
-            this._mcpService,
-            s => s.definition.id === this._uiData.serverDefinitionId && s.collection.id === this._uiData.collectionId,
-            token
-        );
+    loadResource(token) {
+        return this._transport.loadResource(token);
     }
-    async loadResource(token) {
-        const server = await this._getServer(token);
-        if (!server) {
-            throw ( new Error("MCP server not found for UI resource"));
-        }
-        const resourceResult = await McpServer.callOn(server, h => h.readResource({
-            uri: this._uiData.resourceUri
-        }, token), token);
-        if (!resourceResult.contents || resourceResult.contents.length === 0) {
-            throw ( new Error("UI resource not found on server"));
-        }
-        const content = resourceResult.contents[0];
-        let html;
-        const mimeType = content.mimeType || "text/html";
-        if (hasKey(content, {
-            text: true
-        })) {
-            html = content.text;
-        } else if (hasKey(content, {
-            blob: true
-        })) {
-            html = ( decodeBase64(content.blob).toString());
-        } else {
-            throw ( new Error("UI resource has no content"));
-        }
-        const meta = content._meta?.ui;
-        return {
-            ...meta,
-            html,
-            mimeType
-        };
+    callTool(name, params, token) {
+        return this._transport.callTool(name, params, token);
     }
-    async callTool(name, params, token) {
-        const server = await this._getServer(token);
-        if (!server) {
-            throw ( new Error("MCP server not found for tool call"));
-        }
-        await startServerAndWaitForLiveTools(server, undefined, token);
-        const tool = server.tools.get().find(t => t.definition.name === name);
-        if (!tool || !(tool.visibility & McpToolVisibility.App)) {
-            throw ( new Error(`Tool not found on server: ${name}`));
-        }
-        const res = await tool.call(params, undefined, token);
-        return {
-            content: res.content,
-            isError: res.isError,
-            _meta: res._meta,
-            structuredContent: res.structuredContent
-        };
+    readResource(uri, token) {
+        return this._transport.readResource(uri, token);
     }
-    async readResource(uri, token) {
-        const server = await this._getServer(token);
-        if (!server) {
-            throw ( new Error("MCP server not found"));
-        }
-        return await McpServer.callOn(server, h => h.readResource({
-            uri
-        }, token), token);
+    sampling(params, token) {
+        return this._transport.sampling(params, token);
     }
 };
-McpToolCallUI = ( __decorate([( __param(1, IMcpService)), ( __param(2, IThemeService))], McpToolCallUI));
+McpToolCallUI = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IThemeService))], McpToolCallUI));
 
 export { McpToolCallUI };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController.js

@@ -144,7 +144,7 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
             return [{
                 text: `$(${successStateIcon.id})`,
                 color: themeColorFromId(cellStatusIconSuccess),
-                tooltip: ( localize(11748, "Success")),
+                tooltip: ( localize(12379, "Success")),
                 alignment: CellStatusbarAlignment.Left,
                 priority: Number.MAX_SAFE_INTEGER
             }];
@@ -152,14 +152,14 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
             return [{
                 text: `$(${errorStateIcon.id})`,
                 color: themeColorFromId(cellStatusIconError),
-                tooltip: ( localize(11749, "Failed")),
+                tooltip: ( localize(12380, "Failed")),
                 alignment: CellStatusbarAlignment.Left,
                 priority: Number.MAX_SAFE_INTEGER
             }];
         } else if (state === NotebookCellExecutionState.Pending || state === NotebookCellExecutionState.Unconfirmed) {
             return [{
                 text: `$(${pendingStateIcon.id})`,
-                tooltip: ( localize(11750, "Pending")),
+                tooltip: ( localize(12381, "Pending")),
                 alignment: CellStatusbarAlignment.Left,
                 priority: Number.MAX_SAFE_INTEGER
             }];
@@ -167,7 +167,7 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
             const icon = runState?.didPause ? executingStateIcon : ThemeIcon.modify(executingStateIcon, "spin");
             return [{
                 text: `$(${icon.id})`,
-                tooltip: ( localize(11751, "Executing")),
+                tooltip: ( localize(12382, "Executing")),
                 alignment: CellStatusbarAlignment.Left,
                 priority: Number.MAX_SAFE_INTEGER
             }];
@@ -298,10 +298,10 @@ let TimerCellStatusBarItem = class TimerCellStatusBarItem extends Disposable {
                 const rendererTitle = renderIssueLink ? `[${linkText}](command:workbench.action.openIssueReporter?${args})` : `**${linkText}**`;
                 renderTimes += `- ${rendererTitle} ${formatCellDuration(renderDuration[key])}\n`;
             }
-            renderTimes += `\n*${( localize(11752, "Use the links above to file an issue using the issue reporter."))}*\n`;
+            renderTimes += `\n*${( localize(12383, "Use the links above to file an issue using the issue reporter."))}*\n`;
             tooltip = {
                 value: ( localize(
-                    11753,
+                    12384,
                     "**Last Execution** {0}\n\n**Execution Time** {1}\n\n**Overhead Time** {2}\n\n**Render Times**\n\n{3}",
                     lastExecution,
                     formatCellDuration(executionDuration),
@@ -312,7 +312,7 @@ let TimerCellStatusBarItem = class TimerCellStatusBarItem extends Disposable {
             };
         }
         const executionText = this._isVerbose ? ( localize(
-            11754,
+            12385,
             "Last Execution: {0}, Duration: {1}",
             lastExecution,
             formatCellDuration(duration, false)

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget.js

@@ -348,9 +348,9 @@ let NotebookFindWidget = class NotebookFindWidget extends SimpleFindReplaceWidge
     }
     _getAriaLabel(label, currentMatch, searchString) {
         if (label === NLS_NO_RESULTS) {
-            return searchString === "" ? ( localize(11795, "{0} found", label)) : ( localize(11796, "{0} found for '{1}'", label, searchString));
+            return searchString === "" ? ( localize(12426, "{0} found", label)) : ( localize(12427, "{0} found for '{1}'", label, searchString));
         }
-        return localize(11797, "{0} found for '{1}'", label, searchString);
+        return localize(12428, "{0} found for '{1}'", label, searchString);
     }
     dispose() {
         this._notebookEditor?.removeClassName(FIND_SHOW_TRANSITION);

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/cellOperations.js

@@ -402,7 +402,7 @@ async function joinSelectedCells(bulkEditService, notificationService, context)
     const cellKind = cells[0].cellKind;
     const isSameKind = cells.every(cell => cell.cellKind === cellKind);
     if (!isSameKind) {
-        const message = ( localize(11853, "Cannot join cells of different kinds"));
+        const message = ( localize(12484, "Cannot join cells of different kinds"));
         return notificationService.warn(message);
     }
     const firstCell = cells[0];
@@ -431,7 +431,7 @@ async function joinSelectedCells(bulkEditService, notificationService, context)
     }
     if (edits.length) {
         await bulkEditService.apply(edits, {
-            quotableLabel: ( localize(11854, "Join Notebook Cells"))
+            quotableLabel: ( localize(12485, "Join Notebook Cells"))
         });
     }
 }