@codingame/monaco-vscode-mcp-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/extensionMcpDiscovery.js

@@ -141,20 +141,20 @@ let ExtensionMcpDiscovery = ExtensionMcpDiscovery_1 = class ExtensionMcpDiscover
     }
     static _validate(user) {
         if (!Array.isArray(user.value)) {
-            user.collector.error(( localize(9493, "Expected an array of MCP collections")));
+            user.collector.error(( localize(10188, "Expected an array of MCP collections")));
             return false;
         }
         for (const contribution of user.value) {
             if (typeof contribution.id !== "string" || isFalsyOrWhitespace(contribution.id)) {
-                user.collector.error(( localize(9494, "Expected 'id' to be a non-empty string.")));
+                user.collector.error(( localize(10189, "Expected 'id' to be a non-empty string.")));
                 return false;
             }
             if (typeof contribution.label !== "string" || isFalsyOrWhitespace(contribution.label)) {
-                user.collector.error(( localize(9495, "Expected 'label' to be a non-empty string.")));
+                user.collector.error(( localize(10190, "Expected 'label' to be a non-empty string.")));
                 return false;
             }
             if (contribution.when !== undefined && (typeof contribution.when !== "string" || isFalsyOrWhitespace(contribution.when))) {
-                user.collector.error(( localize(9496, "Expected 'when' to be a non-empty string.")));
+                user.collector.error(( localize(10191, "Expected 'when' to be a non-empty string.")));
                 return false;
             }
         }

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/installedMcpServersDiscovery.js

@@ -94,6 +94,8 @@ let InstalledMcpServersDiscovery = class InstalledMcpServersDiscovery extends Di
                     id: `${collectionId}.${server.name}`,
                     label: server.name,
                     launch,
+                    sandboxEnabled: config.type === "http" ? undefined : config.sandboxEnabled,
+                    sandbox: config.type === "http" || !config.sandboxEnabled ? undefined : config.sandbox,
                     cacheNonce: await McpServerLaunch.hash(launch),
                     roots: mcpConfigPath?.workspaceFolder ? [mcpConfigPath.workspaceFolder.uri] : undefined,
                     variableReplacement: {

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/nativeMcpDiscoveryAbstract.js

@@ -86,7 +86,7 @@ let NativeFilesystemMcpDiscovery = class NativeFilesystemMcpDiscovery extends Fi
         this.suffix = "";
         if (remoteAuthority) {
             this.suffix = " " + ( localize(
-                9497,
+                10192,
                 " on {0}",
                 labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority)
             ));

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

@@ -0,0 +1,15 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpDiscovery } from "./mcpDiscovery.js";
+export declare class PluginMcpDiscovery extends Disposable implements IMcpDiscovery {
+    private readonly _agentPluginService;
+    private readonly _mcpRegistry;
+    readonly fromGallery = false;
+    private readonly _collections;
+    constructor(_agentPluginService: IAgentPluginService, _mcpRegistry: IMcpRegistry);
+    start(): void;
+    private createCollectionState;
+    private _toServerDefinition;
+    private _toLaunch;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/pluginMcpDiscovery.js

@@ -0,0 +1,106 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable, DisposableResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpCollectionSortOrder, McpServerTrust, McpServerTransportType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let PluginMcpDiscovery = class PluginMcpDiscovery extends Disposable {
+    constructor(_agentPluginService, _mcpRegistry) {
+        super();
+        this._agentPluginService = _agentPluginService;
+        this._mcpRegistry = _mcpRegistry;
+        this.fromGallery = false;
+        this._collections = this._register(( new DisposableResourceMap()));
+    }
+    start() {
+        this._register(autorun(reader => {
+            const plugins = this._agentPluginService.plugins.read(reader);
+            const seen = ( new ResourceSet());
+            for (const plugin of plugins) {
+                seen.add(plugin.uri);
+                let collectionState = this._collections.get(plugin.uri);
+                if (!collectionState) {
+                    collectionState = this.createCollectionState(plugin);
+                    this._collections.set(plugin.uri, collectionState);
+                }
+            }
+            for (const [pluginUri] of this._collections) {
+                if (!( seen.has(pluginUri))) {
+                    this._collections.deleteAndDispose(pluginUri);
+                }
+            }
+        }));
+    }
+    createCollectionState(plugin) {
+        const collectionId = `plugin.${plugin.uri}`;
+        return this._mcpRegistry.registerCollection({
+            id: collectionId,
+            label: `${basename(plugin.uri)} (Agent Plugin)`,
+            remoteAuthority: plugin.uri.scheme === Schemas.vscodeRemote ? plugin.uri.authority : null,
+            configTarget: ConfigurationTarget.USER,
+            scope: StorageScope.PROFILE,
+            trustBehavior: McpServerTrust.Kind.Trusted,
+            serverDefinitions: ( plugin.mcpServerDefinitions.map(defs => ( defs.map(d => this._toServerDefinition(collectionId, d))).filter(isDefined))),
+            presentation: {
+                origin: plugin.uri,
+                order: McpCollectionSortOrder.Plugin
+            }
+        });
+    }
+    _toServerDefinition(
+        collectionId,
+        {
+            name,
+            configuration
+        }
+    ) {
+        const launch = this._toLaunch(configuration);
+        if (!launch) {
+            return undefined;
+        }
+        return {
+            id: `${collectionId}.${name}`,
+            label: name,
+            launch,
+            cacheNonce: String(hash(launch))
+        };
+    }
+    _toLaunch(config) {
+        if (config.type === McpServerType.LOCAL) {
+            return {
+                type: McpServerTransportType.Stdio,
+                command: config.command,
+                args: config.args ? [...config.args] : [],
+                env: config.env ? {
+                    ...config.env
+                } : {},
+                envFile: config.envFile,
+                cwd: config.cwd
+            };
+        }
+        try {
+            return {
+                type: McpServerTransportType.HTTP,
+                uri: ( URI.parse(config.url)),
+                headers: Object.entries(config.headers ?? {})
+            };
+        } catch {
+            return undefined;
+        }
+    }
+};
+PluginMcpDiscovery = ( __decorate([( __param(0, IAgentPluginService)), ( __param(1, IMcpRegistry))], PluginMcpDiscovery));
+
+export { PluginMcpDiscovery };

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

@@ -14,19 +14,19 @@ var McpContextKeys;
 (function(McpContextKeys) {
     McpContextKeys.serverCount = ( new RawContextKey("mcp.serverCount", undefined, {
         type: "number",
-        description: ( localize(9529, "Context key that has the number of registered MCP servers"))
+        description: ( localize(10233, "Context key that has the number of registered MCP servers"))
     }));
     McpContextKeys.hasUnknownTools = ( new RawContextKey("mcp.hasUnknownTools", undefined, {
         type: "boolean",
-        description: ( localize(9530, "Indicates whether there are MCP servers with unknown tools."))
+        description: ( localize(10234, "Indicates whether there are MCP servers with unknown tools."))
     }));
     McpContextKeys.hasServersWithErrors = ( new RawContextKey("mcp.hasServersWithErrors", undefined, {
         type: "boolean",
-        description: ( localize(9531, "Indicates whether there are any MCP servers with errors."))
+        description: ( localize(10235, "Indicates whether there are any MCP servers with errors."))
     }));
     McpContextKeys.toolsCount = ( new RawContextKey("mcp.toolsCount", undefined, {
         type: "number",
-        description: ( localize(9532, "Context key that has the number of registered MCP tools"))
+        description: ( localize(10236, "Context key that has the number of registered MCP tools"))
     }));
 })(McpContextKeys || (McpContextKeys = {}));
 let McpContextKeysController = class McpContextKeysController extends Disposable {

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

@@ -0,0 +1,23 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IServerChannel } from "@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc";
+import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+export declare class McpGatewayToolBrokerChannel extends Disposable implements IServerChannel<unknown> {
+    private readonly _mcpService;
+    private readonly _onDidChangeTools;
+    private readonly _onDidChangeResources;
+    private readonly _serverIdMap;
+    private _nextServerIndex;
+    constructor(_mcpService: IMcpService);
+    private _getServerIndex;
+    private _getServerByIndex;
+    listen<T>(_ctx: unknown, event: string): Event<T>;
+    call<T>(_ctx: unknown, command: string, arg?: unknown, cancellationToken?: CancellationToken): Promise<T>;
+    private _listTools;
+    private _callTool;
+    private _listResources;
+    private _readResource;
+    private _listResourceTemplates;
+    private _ensureServerReady;
+}

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

@@ -0,0 +1,202 @@
+
+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 { McpServer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpServer';
+import { McpServerCacheState, McpToolVisibility, McpCapability } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+class McpGatewayToolBrokerChannel extends Disposable {
+    constructor(_mcpService) {
+        super();
+        this._mcpService = _mcpService;
+        this._onDidChangeTools = this._register(( new Emitter()));
+        this._onDidChangeResources = this._register(( new Emitter()));
+        this._serverIdMap = ( new Map());
+        this._nextServerIndex = 0;
+        let toolsInitialized = false;
+        this._register(autorun(reader => {
+            for (const server of this._mcpService.servers.read(reader)) {
+                server.tools.read(reader);
+            }
+            if (toolsInitialized) {
+                this._onDidChangeTools.fire();
+            } else {
+                toolsInitialized = true;
+            }
+        }));
+        let resourcesInitialized = false;
+        this._register(autorun(reader => {
+            for (const server of this._mcpService.servers.read(reader)) {
+                server.capabilities.read(reader);
+            }
+            if (resourcesInitialized) {
+                this._onDidChangeResources.fire();
+            } else {
+                resourcesInitialized = 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) {
+        for (const server of this._mcpService.servers.get()) {
+            if (this._getServerIndex(server) === serverIndex) {
+                return server;
+            }
+        }
+        return undefined;
+    }
+    listen(_ctx, event) {
+        switch (event) {
+        case "onDidChangeTools":
+            return this._onDidChangeTools.event;
+        case "onDidChangeResources":
+            return this._onDidChangeResources.event;
+        }
+        throw ( new Error(`Invalid listen: ${event}`));
+    }
+    async call(_ctx, command, arg, cancellationToken) {
+        switch (command) {
+        case "listTools":
+            {
+                const tools = await this._listTools();
+                return tools;
+            }
+        case "callTool":
+            {
+                const {
+                    name,
+                    args
+                } = arg;
+                const result = await this._callTool(name, args || {}, cancellationToken);
+                return result;
+            }
+        case "listResources":
+            {
+                const resources = await this._listResources();
+                return resources;
+            }
+        case "readResource":
+            {
+                const {
+                    serverIndex,
+                    uri
+                } = arg;
+                const result = await this._readResource(serverIndex, uri, cancellationToken);
+                return result;
+            }
+        case "listResourceTemplates":
+            {
+                const templates = await this._listResourceTemplates();
+                return templates;
+            }
+        }
+        throw ( new Error(`Invalid call: ${command}`));
+    }
+    async _listTools() {
+        const mcpTools = [];
+        const servers = this._mcpService.servers.get();
+        await Promise.all(( servers.map(server => this._ensureServerReady(server))));
+        for (const server of servers) {
+            const cacheState = server.cacheState.get();
+            if (cacheState !== McpServerCacheState.Live && cacheState !== McpServerCacheState.Cached && cacheState !== McpServerCacheState.RefreshingFromCached) {
+                continue;
+            }
+            for (const tool of server.tools.get()) {
+                if (!(tool.visibility & McpToolVisibility.Model)) {
+                    continue;
+                }
+                mcpTools.push(tool.definition);
+            }
+        }
+        return mcpTools;
+    }
+    async _callTool(name, args, token = CancellationToken.None) {
+        for (const server of this._mcpService.servers.get()) {
+            const tool = server.tools.get().find(
+                t => t.definition.name === name && (t.visibility & McpToolVisibility.Model)
+            );
+            if (tool) {
+                const result = await tool.call(args, undefined, token);
+                return {
+                    result,
+                    serverIndex: this._getServerIndex(server)
+                };
+            }
+        }
+        throw ( new Error(`Unknown tool: ${name}`));
+    }
+    async _listResources() {
+        const results = [];
+        const servers = this._mcpService.servers.get();
+        await Promise.all(( servers.map(async server => {
+            await this._ensureServerReady(server);
+            const capabilities = server.capabilities.get();
+            if (!capabilities || !(capabilities & McpCapability.Resources)) {
+                return;
+            }
+            try {
+                const resources = await McpServer.callOn(server, h => h.listResources());
+                results.push({
+                    serverIndex: this._getServerIndex(server),
+                    resources
+                });
+            } catch {}
+        })));
+        return results;
+    }
+    async _readResource(serverIndex, uri, token = CancellationToken.None) {
+        const server = this._getServerByIndex(serverIndex);
+        if (!server) {
+            throw ( new Error(`Unknown server index: ${serverIndex}`));
+        }
+        return McpServer.callOn(server, h => h.readResource({
+            uri
+        }, token), token);
+    }
+    async _listResourceTemplates() {
+        const results = [];
+        const servers = this._mcpService.servers.get();
+        await Promise.all(( servers.map(async server => {
+            await this._ensureServerReady(server);
+            const capabilities = server.capabilities.get();
+            if (!capabilities || !(capabilities & McpCapability.Resources)) {
+                return;
+            }
+            try {
+                const resourceTemplates = await McpServer.callOn(server, h => h.listResourceTemplates());
+                results.push({
+                    serverIndex: this._getServerIndex(server),
+                    resourceTemplates
+                });
+            } catch {}
+        })));
+        return results;
+    }
+    async _ensureServerReady(server) {
+        const cacheState = server.cacheState.get();
+        if (cacheState !== McpServerCacheState.Unknown && cacheState !== McpServerCacheState.Outdated) {
+            return true;
+        }
+        try {
+            return await startServerAndWaitForLiveTools(server, {
+                promptType: "all-untrusted",
+                errorOnUserInteraction: true
+            });
+        } catch {
+            return false;
+        }
+    }
+}
+
+export { McpGatewayToolBrokerChannel };

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

@@ -25,6 +25,7 @@ import { McpToolVisibility, McpToolResourceLinkMimeType, McpResourceURI } from '
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { mcpServerToSourceData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { McpServer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpServer';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let McpLanguageModelToolContribution = class McpLanguageModelToolContribution extends Disposable {
@@ -66,7 +67,7 @@ let McpLanguageModelToolContribution = class McpLanguageModelToolContribution ex
                     const toolSet = store.add(
                         this._toolsService.createToolSet(source, server.definition.id, referenceName, {
                             icon: Codicon.mcp,
-                            description: ( localize(9533, "{0}: All Tools", server.definition.label))
+                            description: ( localize(10237, "{0}: All Tools", server.definition.label))
                         })
                     );
                     return {
@@ -181,30 +182,37 @@ let McpToolImplementation = class McpToolImplementation {
     async prepareToolInvocation(context) {
         const tool = this._tool;
         const server = this._server;
+        const sandboxEnabled = await McpServer.callOn(server, async (_handler, connection) => {
+            return connection.definition.sandboxEnabled;
+        });
+        const isSandboxedServer = sandboxEnabled === true;
         const mcpToolWarning = ( localize(
-            9534,
+            10238,
             "Note that MCP servers or malicious conversation content may attempt to misuse '{0}' through tools.",
             this._productService.nameShort
         ));
         const title = tool.definition.annotations?.title || tool.definition.title || ("`" + tool.definition.name + "`");
-        const confirm = {};
-        if (!tool.definition.annotations?.readOnlyHint) {
-            confirm.title = ( new MarkdownString(( localize(9535, "Run {0}", title))));
-            confirm.message = ( new MarkdownString(tool.definition.description, {
-                supportThemeIcons: true
-            }));
-            confirm.disclaimer = mcpToolWarning;
-            confirm.allowAutoConfirm = true;
-        }
-        if (tool.definition.annotations?.openWorldHint) {
-            confirm.confirmResults = true;
+        let confirm;
+        if (!isSandboxedServer) {
+            confirm = {};
+            if (!tool.definition.annotations?.readOnlyHint) {
+                confirm.title = ( new MarkdownString(( localize(10239, "Run {0}", title))));
+                confirm.message = ( new MarkdownString(tool.definition.description, {
+                    supportThemeIcons: true
+                }));
+                confirm.disclaimer = mcpToolWarning;
+                confirm.allowAutoConfirm = true;
+            }
+            if (tool.definition.annotations?.openWorldHint) {
+                confirm.confirmResults = true;
+            }
         }
         const mcpUiEnabled = this._configurationService.getValue(mcpAppsEnabledConfig);
         return {
             confirmationMessages: confirm,
-            invocationMessage: ( new MarkdownString(( localize(9536, "Running {0}", title)))),
-            pastTenseMessage: ( new MarkdownString(( localize(9537, "Ran {0} ", title)))),
-            originMessage: ( localize(9538, "{0} (MCP Server)", server.definition.label)),
+            invocationMessage: ( new MarkdownString(( localize(10240, "Running {0}", title)))),
+            pastTenseMessage: ( new MarkdownString(( localize(10241, "Ran {0} ", title)))),
+            originMessage: ( localize(10242, "{0} (MCP Server)", server.definition.label)),
             toolSpecificData: {
                 kind: "input",
                 rawInput: context.parameters,
@@ -222,7 +230,7 @@ let McpToolImplementation = class McpToolImplementation {
         };
         const callResult = await this._tool.callWithProgress(invocation.parameters, progress, {
             chatRequestId: invocation.chatRequestId,
-            chatSessionId: invocation.context?.sessionId
+            chatSessionResource: invocation.context?.sessionResource
         }, token);
         const details = {
             input: JSON.stringify(invocation.parameters, undefined, 2),

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

@@ -10,13 +10,12 @@ import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/pla
 import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
 import { StorageScope } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage";
 import { IWorkspaceFolderData } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
-import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
-import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
 import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
 import { IResolvedValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IMcpHostDelegate, IMcpResolveConnectionOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
 import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service";
 import { IMcpServerConnection, LazyCollectionState, McpCollectionDefinition, McpDefinitionReference, McpServerDefinition } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 export declare class McpRegistry extends Disposable implements IMcpRegistry {
     private readonly _instantiationService;
@@ -27,8 +26,7 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     private readonly _quickInputService;
     private readonly _labelService;
     private readonly _logService;
-    private readonly _workspaceTrustManagementService;
-    private readonly _workspaceTrustRequestService;
+    private readonly _mcpSandboxService;
     readonly _serviceBrand: undefined;
     private readonly _collections;
     private readonly _delegates;
@@ -44,7 +42,7 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     get delegates(): IObservable<readonly IMcpHostDelegate[]>;
     private readonly _onDidChangeInputs;
     readonly onDidChangeInputs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
-    constructor(_instantiationService: IInstantiationService, _configurationResolverService: IConfigurationResolverService, _dialogService: IDialogService, _notificationService: INotificationService, _editorService: IEditorService, configurationService: IConfigurationService, _quickInputService: IQuickInputService, _labelService: ILabelService, _logService: ILogService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _workspaceTrustRequestService: IWorkspaceTrustRequestService);
+    constructor(_instantiationService: IInstantiationService, _configurationResolverService: IConfigurationResolverService, _dialogService: IDialogService, _notificationService: INotificationService, _editorService: IEditorService, configurationService: IConfigurationService, _quickInputService: IQuickInputService, _labelService: ILabelService, _logService: ILogService, _mcpSandboxService: IMcpSandboxService);
     registerDelegate(delegate: IMcpHostDelegate): IDisposable;
     registerCollection(collection: McpCollectionDefinition): IDisposable;
     getServerDefinition(collectionRef: McpDefinitionReference, definitionRef: McpDefinitionReference): IObservable<{