@codingame/monaco-vscode-mcp-service-override 28.4.0 → 29.0.0

package/vscode/src/vs/workbench/contrib/mcp/common/mcpGatewayToolBrokerChannel.js

@@ -16,8 +16,7 @@ class McpGatewayToolBrokerChannel extends Disposable {
         this._startupGracePeriodMs = _startupGracePeriodMs;
         this._onDidChangeTools = this._register(( new Emitter()));
         this._onDidChangeResources = this._register(( new Emitter()));
-        this._serverIdMap = ( new Map());
-        this._nextServerIndex = 0;
+        this._onDidChangeServers = this._register(( new Emitter()));
         this._startupGrace = ( new Map());
         this._logService.debug("[McpGateway][ToolBroker] Initialized");
         let toolsInitialized = false;
@@ -44,19 +43,23 @@ class McpGatewayToolBrokerChannel extends Disposable {
                 resourcesInitialized = true;
             }
         }));
+        let serversInitialized = false;
+        this._register(autorun(reader => {
+            const servers = this._mcpService.servers.read(reader);
+            if (serversInitialized) {
+                this._logService.debug("[McpGateway][ToolBroker] Servers changed, firing onDidChangeServers");
+                this._onDidChangeServers.fire(( servers.map(s => ({
+                    id: s.definition.id,
+                    label: s.definition.label
+                }))));
+            } else {
+                serversInitialized = true;
+            }
+        }));
     }
-    _getServerIndex(server) {
-        const defId = server.definition.id;
-        let index = this._serverIdMap.get(defId);
-        if (index === undefined) {
-            index = this._nextServerIndex++;
-            this._serverIdMap.set(defId, index);
-        }
-        return index;
-    }
-    _getServerByIndex(serverIndex) {
+    _getServerById(serverId) {
         for (const server of this._mcpService.servers.get()) {
-            if (this._getServerIndex(server) === serverIndex) {
+            if (server.definition.id === serverId) {
                 return server;
             }
         }
@@ -98,181 +101,193 @@ class McpGatewayToolBrokerChannel extends Disposable {
             return this._onDidChangeTools.event;
         case "onDidChangeResources":
             return this._onDidChangeResources.event;
+        case "onDidChangeServers":
+            return this._onDidChangeServers.event;
         }
         throw ( new Error(`Invalid listen: ${event}`));
     }
     async call(_ctx, command, arg, cancellationToken) {
         this._logService.debug(`[McpGateway][ToolBroker] IPC call: ${command}`);
         switch (command) {
-        case "listTools":
+        case "listServers":
+            {
+                const servers = this._listServers();
+                return servers;
+            }
+        case "listToolsForServer":
             {
-                const tools = await this._listTools();
+                const {
+                    serverId
+                } = arg;
+                const tools = await this._listToolsForServer(serverId);
                 return tools;
             }
-        case "callTool":
+        case "callToolForServer":
             {
                 const {
+                    serverId,
                     name,
                     args
                 } = arg;
-                const result = await this._callTool(name, args || {}, cancellationToken);
+                const result = await this._callToolForServer(serverId, name, args || {}, cancellationToken);
                 return result;
             }
-        case "listResources":
+        case "listResourcesForServer":
             {
-                const resources = await this._listResources();
+                const {
+                    serverId
+                } = arg;
+                const resources = await this._listResourcesForServer(serverId);
                 return resources;
             }
-        case "readResource":
+        case "readResourceForServer":
             {
                 const {
-                    serverIndex,
+                    serverId,
                     uri
                 } = arg;
-                const result = await this._readResource(serverIndex, uri, cancellationToken);
+                const result = await this._readResourceForServer(serverId, uri, cancellationToken);
                 return result;
             }
-        case "listResourceTemplates":
+        case "listResourceTemplatesForServer":
             {
-                const templates = await this._listResourceTemplates();
+                const {
+                    serverId
+                } = arg;
+                const templates = await this._listResourceTemplatesForServer(serverId);
                 return templates;
             }
         }
         throw ( new Error(`Invalid call: ${command}`));
     }
-    async _listTools() {
+    _listServers() {
         const servers = this._mcpService.servers.get();
-        const perServer = await Promise.all(( servers.map(async server => {
-            if (!(await this._shouldUseCachedData(server))) {
-                this._logService.debug(
-                    `[McpGateway][ToolBroker] Server '${server.definition.id}' not ready, skipping tool listing`
-                );
-                return [];
-            }
-            return ( server.tools.get().filter(t => t.visibility & McpToolVisibility.Model).map(t => t.definition));
-        })));
-        const mcpTools = perServer.flat();
+        const result = [];
+        for (const server of servers) {
+            result.push({
+                id: server.definition.id,
+                label: server.definition.label
+            });
+        }
         this._logService.debug(
-            `[McpGateway][ToolBroker] listTools result: ${mcpTools.length} tool(s): [${( mcpTools.map(t => t.name)).join(", ")}]`
+            `[McpGateway][ToolBroker] listServers result: ${result.length} server(s): [${( result.map(s => s.label)).join(", ")}]`
         );
-        return mcpTools;
+        return result;
     }
-    async _callTool(name, args, token = CancellationToken.None) {
-        this._logService.debug(
-            `[McpGateway][ToolBroker] callTool '${name}' with args: ${JSON.stringify(args)}`
-        );
-        for (const server of this._mcpService.servers.get()) {
-            const tool = server.tools.get().find(
-                t => t.definition.name === name && (t.visibility & McpToolVisibility.Model)
+    async _listToolsForServer(serverId) {
+        const server = this._getServerById(serverId);
+        if (!server) {
+            this._logService.warn(
+                `[McpGateway][ToolBroker] listToolsForServer: unknown server '${serverId}'`
             );
-            if (tool) {
-                this._logService.debug(
-                    `[McpGateway][ToolBroker] Found tool '${name}' on server '${server.definition.id}' (index=${this._getServerIndex(server)})`
-                );
-                const result = await tool.call(args, undefined, token);
-                this._logService.debug(
-                    `[McpGateway][ToolBroker] Tool '${name}' completed (isError=${result.isError ?? false}, content blocks=${result.content.length})`
-                );
-                return {
-                    result,
-                    serverIndex: this._getServerIndex(server)
-                };
-            }
+            return [];
+        }
+        if (!(await this._shouldUseCachedData(server))) {
+            this._logService.debug(
+                `[McpGateway][ToolBroker] Server '${serverId}' not ready, skipping tool listing`
+            );
+            return [];
         }
-        this._logService.warn(`[McpGateway][ToolBroker] Tool '${name}' not found on any server`);
-        throw ( new Error(`Unknown tool: ${name}`));
+        const tools = ( server.tools.get().filter(t => t.visibility & McpToolVisibility.Model).map(t => t.definition));
+        this._logService.debug(
+            `[McpGateway][ToolBroker] listToolsForServer '${serverId}': ${tools.length} tool(s)`
+        );
+        return tools;
     }
-    async _listResources() {
-        const results = [];
-        const servers = this._mcpService.servers.get();
+    async _callToolForServer(serverId, name, args, token = CancellationToken.None) {
         this._logService.debug(
-            `[McpGateway][ToolBroker] listResources: ${servers.length} server(s) known`
+            `[McpGateway][ToolBroker] callToolForServer '${serverId}' tool '${name}' with args: ${JSON.stringify(args)}`
         );
-        await Promise.all(( servers.map(async server => {
-            if (!(await this._shouldUseCachedData(server))) {
-                return;
-            }
-            const capabilities = server.capabilities.get();
-            if (!capabilities || !(capabilities & McpCapability.Resources)) {
-                this._logService.debug(
-                    `[McpGateway][ToolBroker] Server '${server.definition.id}' has no resource capability, skipping`
-                );
-                return;
-            }
-            try {
-                const resources = await McpServer.callOn(server, h => h.listResources());
-                this._logService.debug(
-                    `[McpGateway][ToolBroker] Server '${server.definition.id}' (index=${this._getServerIndex(server)}) listed ${resources.length} resource(s)`
-                );
-                results.push({
-                    serverIndex: this._getServerIndex(server),
-                    resources
-                });
-            } catch (error) {
-                this._logService.warn(
-                    `[McpGateway][ToolBroker] Server '${server.definition.id}' failed to list resources`,
-                    error
-                );
-            }
-        })));
+        const server = this._getServerById(serverId);
+        if (!server) {
+            throw ( new Error(`Unknown server: ${serverId}`));
+        }
+        const tool = server.tools.get().find(
+            t => t.definition.name === name && (t.visibility & McpToolVisibility.Model)
+        );
+        if (!tool) {
+            throw ( new Error(`Unknown tool '${name}' on server '${serverId}'`));
+        }
+        const result = await tool.call(args, undefined, token);
         this._logService.debug(
-            `[McpGateway][ToolBroker] listResources result: ${results.length} server(s) with resources`
+            `[McpGateway][ToolBroker] Tool '${name}' on '${serverId}' completed (isError=${result.isError ?? false}, content blocks=${result.content.length})`
         );
-        return results;
+        return result;
     }
-    async _readResource(serverIndex, uri, token = CancellationToken.None) {
-        const server = this._getServerByIndex(serverIndex);
+    async _listResourcesForServer(serverId) {
+        const server = this._getServerById(serverId);
         if (!server) {
             this._logService.warn(
-                `[McpGateway][ToolBroker] readResource: unknown server index ${serverIndex}`
+                `[McpGateway][ToolBroker] listResourcesForServer: unknown server '${serverId}'`
+            );
+            return [];
+        }
+        if (!(await this._shouldUseCachedData(server))) {
+            return [];
+        }
+        const capabilities = server.capabilities.get();
+        if (!capabilities || !(capabilities & McpCapability.Resources)) {
+            this._logService.debug(`[McpGateway][ToolBroker] Server '${serverId}' has no resource capability`);
+            return [];
+        }
+        try {
+            const resources = await McpServer.callOn(server, h => h.listResources());
+            this._logService.debug(
+                `[McpGateway][ToolBroker] Server '${serverId}' listed ${resources.length} resource(s)`
+            );
+            return resources;
+        } catch (error) {
+            this._logService.warn(
+                `[McpGateway][ToolBroker] Server '${serverId}' failed to list resources`,
+                error
             );
-            throw ( new Error(`Unknown server index: ${serverIndex}`));
+            return [];
+        }
+    }
+    async _readResourceForServer(serverId, uri, token = CancellationToken.None) {
+        const server = this._getServerById(serverId);
+        if (!server) {
+            throw ( new Error(`Unknown server: ${serverId}`));
         }
         this._logService.debug(
-            `[McpGateway][ToolBroker] readResource '${uri}' from server '${server.definition.id}' (index=${serverIndex})`
+            `[McpGateway][ToolBroker] readResourceForServer '${uri}' from server '${serverId}'`
         );
         const result = await McpServer.callOn(server, h => h.readResource({
             uri
         }, token), token);
         this._logService.debug(
-            `[McpGateway][ToolBroker] readResource returned ${result.contents.length} content(s)`
+            `[McpGateway][ToolBroker] readResourceForServer returned ${result.contents.length} content(s)`
         );
         return result;
     }
-    async _listResourceTemplates() {
-        const results = [];
-        const servers = this._mcpService.servers.get();
-        this._logService.debug(
-            `[McpGateway][ToolBroker] listResourceTemplates: ${servers.length} server(s) known`
-        );
-        await Promise.all(( servers.map(async server => {
-            if (!(await this._shouldUseCachedData(server))) {
-                return;
-            }
-            const capabilities = server.capabilities.get();
-            if (!capabilities || !(capabilities & McpCapability.Resources)) {
-                return;
-            }
-            try {
-                const resourceTemplates = await McpServer.callOn(server, h => h.listResourceTemplates());
-                this._logService.debug(
-                    `[McpGateway][ToolBroker] Server '${server.definition.id}' (index=${this._getServerIndex(server)}) listed ${resourceTemplates.length} resource template(s)`
-                );
-                results.push({
-                    serverIndex: this._getServerIndex(server),
-                    resourceTemplates
-                });
-            } catch (error) {
-                this._logService.warn(
-                    `[McpGateway][ToolBroker] Server '${server.definition.id}' failed to list resource templates`,
-                    error
-                );
-            }
-        })));
-        this._logService.debug(
-            `[McpGateway][ToolBroker] listResourceTemplates result: ${results.length} server(s) with templates`
-        );
-        return results;
+    async _listResourceTemplatesForServer(serverId) {
+        const server = this._getServerById(serverId);
+        if (!server) {
+            this._logService.warn(
+                `[McpGateway][ToolBroker] listResourceTemplatesForServer: unknown server '${serverId}'`
+            );
+            return [];
+        }
+        if (!(await this._shouldUseCachedData(server))) {
+            return [];
+        }
+        const capabilities = server.capabilities.get();
+        if (!capabilities || !(capabilities & McpCapability.Resources)) {
+            return [];
+        }
+        try {
+            const resourceTemplates = await McpServer.callOn(server, h => h.listResourceTemplates());
+            this._logService.debug(
+                `[McpGateway][ToolBroker] Server '${serverId}' listed ${resourceTemplates.length} resource template(s)`
+            );
+            return resourceTemplates;
+        } catch (error) {
+            this._logService.warn(
+                `[McpGateway][ToolBroker] Server '${serverId}' failed to list resource templates`,
+                error
+            );
+            return [];
+        }
     }
     async _ensureServerReady(server) {
         const cacheState = server.cacheState.get();

package/vscode/src/vs/workbench/contrib/mcp/common/mcpLanguageModelToolContribution.js

@@ -17,6 +17,7 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { mcpAppsEnabledConfig } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { isContributionEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
 import { getAttachableImageExtension, ChatResponseResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { LanguageModelPartAudience } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
@@ -49,6 +50,9 @@ let McpLanguageModelToolContribution = class McpLanguageModelToolContribution ex
             const servers = mcpService.servers.read(reader);
             const toDelete = ( new Set(( previous.keys())));
             for (const server of servers) {
+                if (!isContributionEnabled(server.enablement.read(reader))) {
+                    continue;
+                }
                 const previousRec = previous.get(server);
                 if (previousRec) {
                     toDelete.delete(server);
@@ -67,7 +71,7 @@ let McpLanguageModelToolContribution = class McpLanguageModelToolContribution ex
                     const toolSet = store.add(
                         this._toolsService.createToolSet(source, server.definition.id, referenceName, {
                             icon: Codicon.mcp,
-                            description: ( localize(10423, "{0}: All Tools", server.definition.label))
+                            description: ( localize(10673, "{0}: All Tools", server.definition.label))
                         })
                     );
                     return {
@@ -187,7 +191,7 @@ let McpToolImplementation = class McpToolImplementation {
         });
         const isSandboxedServer = sandboxEnabled === true;
         const mcpToolWarning = ( localize(
-            10424,
+            10674,
             "Note that MCP servers or malicious conversation content may attempt to misuse '{0}' through tools.",
             this._productService.nameShort
         ));
@@ -196,7 +200,7 @@ let McpToolImplementation = class McpToolImplementation {
         if (!isSandboxedServer) {
             confirm = {};
             if (!tool.definition.annotations?.readOnlyHint) {
-                confirm.title = ( new MarkdownString(( localize(10425, "Run {0}", title))));
+                confirm.title = ( new MarkdownString(( localize(10675, "Run {0}", title))));
                 confirm.message = ( new MarkdownString(tool.definition.description, {
                     supportThemeIcons: true
                 }));
@@ -210,9 +214,9 @@ let McpToolImplementation = class McpToolImplementation {
         const mcpUiEnabled = this._configurationService.getValue(mcpAppsEnabledConfig);
         return {
             confirmationMessages: confirm,
-            invocationMessage: ( new MarkdownString(( localize(10426, "Running {0}", title)))),
-            pastTenseMessage: ( new MarkdownString(( localize(10427, "Ran {0} ", title)))),
-            originMessage: ( localize(10428, "{0} (MCP Server)", server.definition.label)),
+            invocationMessage: ( new MarkdownString(( localize(10676, "Running {0}", title)))),
+            pastTenseMessage: ( new MarkdownString(( localize(10677, "Ran {0} ", title)))),
+            originMessage: ( localize(10678, "{0} (MCP Server)", server.definition.label)),
             toolSpecificData: {
                 kind: "input",
                 rawInput: context.parameters,

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.js

@@ -34,10 +34,10 @@ import { McpRegistryInputStorage } from './mcpRegistryInputStorage.js';
 import { IMcpSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service';
 import { McpServerConnection } from './mcpServerConnection.js';
 import { LazyCollectionState, UserInteractionRequiredError, McpServerTrust, McpStartServerInteraction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
-import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorunSelfDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
 const notTrustedNonce = "__vscode_not_trusted";
 let McpRegistry = class McpRegistry extends Disposable {
@@ -227,7 +227,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             if (errorOnUserInteraction) {
                 throw ( new UserInteractionRequiredError("workspaceTrust"));
             } else if (!(await this._workspaceTrustRequestService.requestWorkspaceTrust({
-                message: ( localize(10429, "This MCP server definition is defined in your workspace files."))
+                message: ( localize(10679, "This MCP server definition is defined in your workspace files."))
             }))) {
                 return false;
             }
@@ -305,7 +305,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             const originURI = r.definition.presentation?.origin?.uri || r.collection.presentation?.origin;
             let labelWithOrigin = originURI ? `[\`${r.definition.label}\`](${originURI})` : "`" + r.definition.label + "`";
             if (r.collection.source instanceof ExtensionIdentifier) {
-                labelWithOrigin += ` (${( localize(10430, "from {0}", r.collection.source.value))})`;
+                labelWithOrigin += ` (${( localize(10680, "from {0}", r.collection.source.value))})`;
             }
             return labelWithOrigin;
         }
@@ -315,12 +315,12 @@ let McpRegistry = class McpRegistry extends Disposable {
             const {
                 result
             } = await this._dialogService.prompt({
-                message: ( localize(10431, "Trust and run MCP server {0}?", def.definition.label)),
+                message: ( localize(10681, "Trust and run MCP server {0}?", def.definition.label)),
                 custom: {
                     icon: Codicon.shield,
                     markdownDetails: [{
                         markdown: ( new MarkdownString(( localize(
-                            10432,
+                            10682,
                             "The MCP server {0} was updated. MCP servers may add context to your chat session and lead to unexpected behavior. Do you want to trust and run this server?",
                             labelFor(def)
                         )))),
@@ -333,10 +333,10 @@ let McpRegistry = class McpRegistry extends Disposable {
                     }]
                 },
                 buttons: [{
-                    label: ( localize(10433, "Trust")),
+                    label: ( localize(10683, "Trust")),
                     run: () => true
                 }, {
-                    label: ( localize(10434, "Do not trust")),
+                    label: ( localize(10684, "Do not trust")),
                     run: () => false
                 }]
             });
@@ -346,12 +346,12 @@ let McpRegistry = class McpRegistry extends Disposable {
         const {
             result
         } = await this._dialogService.prompt({
-            message: ( localize(10435, "Trust and run {0} MCP servers?", definitions.length)),
+            message: ( localize(10685, "Trust and run {0} MCP servers?", definitions.length)),
             custom: {
                 icon: Codicon.shield,
                 markdownDetails: [{
                     markdown: ( new MarkdownString(( localize(
-                        10436,
+                        10686,
                         "Several updated MCP servers were discovered:\n\n{0}\n\n MCP servers may add context to your chat session and lead to unexpected behavior. Do you want to trust and run these server?",
                         list
                     )))),
@@ -364,13 +364,13 @@ let McpRegistry = class McpRegistry extends Disposable {
                 }]
             },
             buttons: [{
-                label: ( localize(10433, "Trust")),
+                label: ( localize(10683, "Trust")),
                 run: () => "all"
             }, {
-                label: ( localize(10437, "Pick Trusted")),
+                label: ( localize(10687, "Pick Trusted")),
                 run: () => "pick"
             }, {
-                label: ( localize(10434, "Do not trust")),
+                label: ( localize(10684, "Do not trust")),
                 run: () => "none"
             }]
         });
@@ -533,14 +533,14 @@ let McpRegistry = class McpRegistry extends Disposable {
             }
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(10438, "Error starting {0}: {1}", definition.label, String(e))),
+                message: ( localize(10688, "Error starting {0}: {1}", definition.label, String(e))),
                 actions: {
                     primary: collection.presentation?.origin && [{
                         id: "mcp.launchError.openConfig",
                         class: undefined,
                         enabled: true,
                         tooltip: "",
-                        label: ( localize(10439, "Open Configuration")),
+                        label: ( localize(10689, "Open Configuration")),
                         run: () => this._editorService.openEditor({
                             resource: collection.presentation.origin,
                             options: {

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingLog.js

@@ -41,7 +41,7 @@ let McpSamplingLog = class McpSamplingLog extends Disposable {
         }
         const parts = [];
         const total = record.bins.reduce((sum, value) => sum + value, 0);
-        parts.push(( localize(10440, "{0} total requests in the last 7 days.", total)));
+        parts.push(( localize(10690, "{0} total requests in the last 7 days.", total)));
         parts.push(this._formatRecentRequests(record));
         return parts.join("\n");
     }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingService.js

@@ -131,11 +131,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                10441,
+                10691,
                 "Allow MCP tools from \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                10442,
+                10692,
                 "The MCP server \"{0}\" has issued a request to make a language model call. Do you want to allow it to make requests during chat?",
                 opts.server.definition.label
             )), this.allowButtons(opts.server, "allowedDuringChat"));
@@ -149,11 +149,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                10443,
+                10693,
                 "Allow MCP server \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                10444,
+                10694,
                 "The MCP server \"{0}\" has issued a request to make a language model call. Do you want to allow it to make requests, outside of tool calls during chat?",
                 opts.server.definition.label
             )), this.allowButtons(opts.server, "allowedOutsideChat"));
@@ -165,12 +165,12 @@ let McpSamplingService = class McpSamplingService extends Disposable {
             throw McpError.notAllowed();
         } else if (model === ModelMatch.NoMatchingModel) {
             const newlyPickedModels = opts.isDuringToolCall ? await this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server) : await this._notify(( localize(
-                10445,
+                10695,
                 "MCP server \"{0}\" triggered a language model request, but it has no allowlisted models.",
                 opts.server.definition.label
             )), {
-                [( localize(10446, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
-                [( localize(10447, "Cancel"))]: () => Promise.resolve(undefined)
+                [( localize(10696, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
+                [( localize(10697, "Cancel"))]: () => Promise.resolve(undefined)
             });
             if (newlyPickedModels) {
                 return this._getMatchingModel(opts);
@@ -181,19 +181,19 @@ let McpSamplingService = class McpSamplingService extends Disposable {
     }
     allowButtons(server, key) {
         return {
-            [( localize(10448, "Allow in this Session"))]: async () => {
+            [( localize(10698, "Allow in this Session"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, true);
                 return true;
             },
-            [( localize(10449, "Always"))]: async () => {
+            [( localize(10699, "Always"))]: async () => {
                 await this.updateConfig(server, c => c[key] = true);
                 return true;
             },
-            [( localize(10450, "Not Now"))]: async () => {
+            [( localize(10700, "Not Now"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, false);
                 return false;
             },
-            [( localize(10451, "Never"))]: async () => {
+            [( localize(10701, "Never"))]: async () => {
                 await this.updateConfig(server, c => c[key] = false);
                 return false;
             }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSandboxService.d.ts

@@ -23,6 +23,7 @@ export declare class McpSandboxService extends Disposable implements IMcpSandbox
     private _sandboxSettingsId;
     private _remoteEnvDetailsPromise;
     private readonly _defaultAllowedDomains;
+    private _defaultAllowWritePaths;
     private _sandboxConfigPerConfigurationTarget;
     constructor(_fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _mcpResourceScannerService: IMcpResourceScannerService, _remoteAgentService: IRemoteAgentService);
     isEnabled(serverDef: McpServerDefinition, remoteAuthority?: string): Promise<boolean>;
@@ -44,4 +45,5 @@ export declare class McpSandboxService extends Disposable implements IMcpSandbox
     private _getDefaultAllowWrite;
     private _pathJoin;
     private _getPathDelimiter;
+    private _quoteShellArgument;
 }