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

package/index.js

@@ -7,12 +7,12 @@ import { McpGalleryService } from './vscode/src/vs/platform/mcp/common/mcpGaller
 import { IAllowedMcpServersService, IMcpGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service';
 import { McpResourceScannerService } from './vscode/src/vs/platform/mcp/common/mcpResourceScannerService.js';
 import { IMcpResourceScannerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpResourceScannerService.service';
-import './vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.js';
 import { McpElicitationService } from './vscode/src/vs/workbench/contrib/mcp/browser/mcpElicitationService.js';
 import { McpWorkbenchService } from './vscode/src/vs/workbench/contrib/mcp/browser/mcpWorkbenchService.js';
 import { McpRegistry } from './vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.js';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
 import { McpSamplingService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingService.js';
+import { IMcpSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service';
 import { McpService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpService.js';
 import { IMcpElicitationService, IMcpSamplingService, IMcpWorkbenchService, IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { AuthenticationMcpAccessService } from './vscode/src/vs/workbench/services/authentication/browser/authenticationMcpAccessService.js';
@@ -24,6 +24,10 @@ import { IAuthenticationMcpUsageService } from '@codingame/monaco-vscode-api/vsc
 import { WorkbenchMcpGalleryManifestService } from './vscode/src/vs/workbench/services/mcp/browser/mcpGalleryManifestService.js';
 import { WorkbenchMcpManagementService } from './vscode/src/vs/workbench/services/mcp/browser/mcpWorkbenchManagementService.js';
 import { IWorkbenchMcpManagementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService.service';
+import { McpSandboxService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpSandboxService.js';
+import { IWorkbenchMcpGatewayService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpGatewayService.service';
+import { BrowserMcpGatewayService } from './vscode/src/vs/workbench/contrib/mcp/browser/mcpGatewayService.js';
+import './vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.js';
 
 function getServiceOverride() {
     return {
@@ -39,7 +43,9 @@ function getServiceOverride() {
         [IMcpElicitationService.toString()]: new SyncDescriptor(McpElicitationService, [], true),
         [IWorkbenchMcpManagementService.toString()]: new SyncDescriptor(WorkbenchMcpManagementService, [], true),
         [IAllowedMcpServersService.toString()]: new SyncDescriptor(AllowedMcpServersService, [], true),
-        [IMcpGalleryManifestService.toString()]: new SyncDescriptor(WorkbenchMcpGalleryManifestService, [], true)
+        [IMcpGalleryManifestService.toString()]: new SyncDescriptor(WorkbenchMcpGalleryManifestService, [], true),
+        [IMcpSandboxService.toString()]: new SyncDescriptor(McpSandboxService, [], true),
+        [IWorkbenchMcpGatewayService.toString()]: new SyncDescriptor(BrowserMcpGatewayService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-mcp-service-override",
-  "version": "26.2.2",
+  "version": "27.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - mcp service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "26.2.2"
+    "@codingame/monaco-vscode-api": "27.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/base/common/jsonRpcProtocol.d.ts

@@ -0,0 +1,66 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+export type JsonRpcId = string | number;
+export interface IJsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface IJsonRpcRequest {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+export interface IJsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+export interface IJsonRpcSuccessResponse {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: unknown;
+}
+export interface IJsonRpcErrorResponse {
+    jsonrpc: "2.0";
+    id?: JsonRpcId;
+    error: IJsonRpcError;
+}
+export type JsonRpcMessage = IJsonRpcRequest | IJsonRpcNotification | IJsonRpcSuccessResponse | IJsonRpcErrorResponse;
+export interface IJsonRpcProtocolHandlers {
+    handleRequest?(request: IJsonRpcRequest, token: CancellationToken): Promise<unknown> | unknown;
+    handleNotification?(notification: IJsonRpcNotification): void;
+}
+export declare class JsonRpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+/**
+ * Generic JSON-RPC 2.0 protocol helper.
+ */
+export declare class JsonRpcProtocol extends Disposable {
+    private readonly _send;
+    private readonly _handlers;
+    private static readonly ParseError;
+    private static readonly MethodNotFound;
+    private static readonly InternalError;
+    private _nextRequestId;
+    private readonly _pendingRequests;
+    constructor(_send: (message: JsonRpcMessage) => void, _handlers: IJsonRpcProtocolHandlers);
+    sendNotification(notification: Omit<IJsonRpcNotification, "jsonrpc">): void;
+    sendRequest<T = unknown>(request: Omit<IJsonRpcRequest, "jsonrpc" | "id">, token?: CancellationToken, onCancel?: (id: JsonRpcId) => void): Promise<T>;
+    handleMessage(message: JsonRpcMessage | JsonRpcMessage[]): Promise<void>;
+    cancelPendingRequest(id: JsonRpcId): void;
+    cancelAllRequests(): void;
+    private _handleMessage;
+    private _handleResult;
+    private _handleError;
+    private _handleRequest;
+    dispose(): void;
+    static createParseError(message: string, data?: unknown): IJsonRpcErrorResponse;
+}
+export declare function isJsonRpcRequest(message: JsonRpcMessage): message is IJsonRpcRequest;
+export declare function isJsonRpcResponse(message: JsonRpcMessage): message is IJsonRpcSuccessResponse | IJsonRpcErrorResponse;
+export declare function isJsonRpcNotification(message: JsonRpcMessage): message is IJsonRpcNotification;

package/vscode/src/vs/base/common/jsonRpcProtocol.js

@@ -0,0 +1,216 @@
+
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+class JsonRpcError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+class JsonRpcProtocol extends Disposable {
+    static {
+        this.ParseError = -32700;
+    }
+    static {
+        this.MethodNotFound = -32601;
+    }
+    static {
+        this.InternalError = -32603;
+    }
+    constructor(_send, _handlers) {
+        super();
+        this._send = _send;
+        this._handlers = _handlers;
+        this._nextRequestId = 1;
+        this._pendingRequests = ( new Map());
+    }
+    sendNotification(notification) {
+        this._send({
+            jsonrpc: "2.0",
+            ...notification
+        });
+    }
+    sendRequest(request, token = CancellationToken.None, onCancel) {
+        if (this._store.isDisposed) {
+            return Promise.reject(( new CancellationError()));
+        }
+        const id = this._nextRequestId++;
+        const promise = ( new DeferredPromise());
+        const cts = ( new CancellationTokenSource());
+        this._pendingRequests.set(id, {
+            promise,
+            cts
+        });
+        const cancelListener = token.onCancellationRequested(() => {
+            if (!promise.isSettled) {
+                this._pendingRequests.delete(id);
+                cts.cancel();
+                onCancel?.(id);
+                promise.cancel();
+            }
+            cancelListener.dispose();
+        });
+        this._send({
+            jsonrpc: "2.0",
+            id,
+            ...request
+        });
+        return promise.p.finally(() => {
+            cancelListener.dispose();
+            this._pendingRequests.delete(id);
+            cts.dispose(true);
+        });
+    }
+    async handleMessage(message) {
+        if (Array.isArray(message)) {
+            for (const single of message) {
+                await this._handleMessage(single);
+            }
+            return;
+        }
+        await this._handleMessage(message);
+    }
+    cancelPendingRequest(id) {
+        const request = this._pendingRequests.get(id);
+        if (request) {
+            this._pendingRequests.delete(id);
+            request.cts.cancel();
+            request.promise.cancel();
+            request.cts.dispose(true);
+        }
+    }
+    cancelAllRequests() {
+        for (const [id, pending] of this._pendingRequests) {
+            this._pendingRequests.delete(id);
+            pending.cts.cancel();
+            pending.promise.cancel();
+            pending.cts.dispose(true);
+        }
+    }
+    async _handleMessage(message) {
+        if (isJsonRpcResponse(message)) {
+            if (hasKey(message, {
+                result: true
+            })) {
+                this._handleResult(message);
+            } else {
+                this._handleError(message);
+            }
+        }
+        if (isJsonRpcRequest(message)) {
+            await this._handleRequest(message);
+        }
+        if (isJsonRpcNotification(message)) {
+            this._handlers.handleNotification?.(message);
+        }
+    }
+    _handleResult(response) {
+        const request = this._pendingRequests.get(response.id);
+        if (request) {
+            this._pendingRequests.delete(response.id);
+            request.promise.complete(response.result);
+            request.cts.dispose(true);
+        }
+    }
+    _handleError(response) {
+        if (response.id === undefined) {
+            return;
+        }
+        const request = this._pendingRequests.get(response.id);
+        if (request) {
+            this._pendingRequests.delete(response.id);
+            request.promise.error(( new JsonRpcError(response.error.code, response.error.message, response.error.data)));
+            request.cts.dispose(true);
+        }
+    }
+    async _handleRequest(request) {
+        if (!this._handlers.handleRequest) {
+            this._send({
+                jsonrpc: "2.0",
+                id: request.id,
+                error: {
+                    code: JsonRpcProtocol.MethodNotFound,
+                    message: `Method not found: ${request.method}`
+                }
+            });
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        this._register(toDisposable(() => cts.dispose(true)));
+        try {
+            const resultOrThenable = this._handlers.handleRequest(request, cts.token);
+            const result = isThenable(resultOrThenable) ? await resultOrThenable : resultOrThenable;
+            this._send({
+                jsonrpc: "2.0",
+                id: request.id,
+                result
+            });
+        } catch (error) {
+            if (error instanceof JsonRpcError) {
+                this._send({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    error: {
+                        code: error.code,
+                        message: error.message,
+                        data: error.data
+                    }
+                });
+            } else {
+                this._send({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    error: {
+                        code: JsonRpcProtocol.InternalError,
+                        message: error instanceof Error ? error.message : "Internal error"
+                    }
+                });
+            }
+        } finally {
+            cts.dispose(true);
+        }
+    }
+    dispose() {
+        this.cancelAllRequests();
+        super.dispose();
+    }
+    static createParseError(message, data) {
+        return {
+            jsonrpc: "2.0",
+            error: {
+                code: JsonRpcProtocol.ParseError,
+                message,
+                data
+            }
+        };
+    }
+}
+function isJsonRpcRequest(message) {
+    return "method" in message && "id" in message && (typeof message.id === "string" || typeof message.id === "number");
+}
+function isJsonRpcResponse(message) {
+    return hasKey(message, {
+        id: true,
+        result: true
+    }) || hasKey(message, {
+        id: true,
+        error: true
+    });
+}
+function isJsonRpcNotification(message) {
+    return hasKey(message, {
+        method: true
+    }) && !hasKey(message, {
+        id: true
+    });
+}
+function isThenable(value) {
+    return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+
+export { JsonRpcError, JsonRpcProtocol, isJsonRpcNotification, isJsonRpcRequest, isJsonRpcResponse };

package/vscode/src/vs/platform/mcp/common/allowedMcpServersService.js

@@ -27,7 +27,7 @@ let AllowedMcpServersService = class AllowedMcpServersService extends Disposable
             query: `@id:${mcpAccessConfig}`
         }).toString());
         return (new MarkdownString(localize(
-            2002,
+            2033,
             "Model Context Protocol servers are disabled in the Editor. Please check your [settings]({0}).",
             settingsCommandLink
         )));

package/vscode/src/vs/platform/mcp/common/mcpGalleryService.js

@@ -456,7 +456,7 @@ let McpGalleryService = class McpGalleryService extends Disposable {
     async getReadme(gallery, token) {
         const readmeUrl = gallery.readmeUrl;
         if (!readmeUrl) {
-            return Promise.resolve(( localize(2003, "No README available")));
+            return Promise.resolve(( localize(2034, "No README available")));
         }
         const uri = ( URI.parse(readmeUrl));
         if (uri.scheme === Schemas.file) {
@@ -468,7 +468,7 @@ let McpGalleryService = class McpGalleryService extends Disposable {
             }
         }
         if (uri.authority !== "raw.githubusercontent.com") {
-            return ( new MarkdownString(( localize(2004, "You can find information about this server [here]({0})", readmeUrl)))).value;
+            return ( new MarkdownString(( localize(2035, "You can find information about this server [here]({0})", readmeUrl)))).value;
         }
         const context = await this.requestService.request({
             type: "GET",

package/vscode/src/vs/platform/mcp/common/mcpGateway.d.ts

@@ -0,0 +1,39 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { MCP } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/modelContextProtocol";
+export declare const McpGatewayChannelName = "mcpGateway";
+export declare const McpGatewayToolBrokerChannelName = "mcpGatewayToolBroker";
+export interface IGatewayCallToolResult {
+    result: MCP.CallToolResult;
+    serverIndex: number;
+}
+export interface IGatewayServerResources {
+    serverIndex: number;
+    resources: readonly MCP.Resource[];
+}
+export interface IGatewayServerResourceTemplates {
+    serverIndex: number;
+    resourceTemplates: readonly MCP.ResourceTemplate[];
+}
+export interface IMcpGatewayToolInvoker {
+    readonly onDidChangeTools: Event<void>;
+    readonly onDidChangeResources: Event<void>;
+    listTools(): Promise<readonly MCP.Tool[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<IGatewayCallToolResult>;
+    listResources(): Promise<readonly IGatewayServerResources[]>;
+    readResource(serverIndex: number, uri: string): Promise<MCP.ReadResourceResult>;
+    listResourceTemplates(): Promise<readonly IGatewayServerResourceTemplates[]>;
+}
+/**
+ * Result of creating an MCP gateway.
+ */
+export interface IMcpGatewayInfo {
+    /**
+     * The address of the HTTP endpoint for this gateway.
+     */
+    readonly address: URI;
+    /**
+     * The unique identifier for this gateway, used for disposal.
+     */
+    readonly gatewayId: string;
+}

package/vscode/src/vs/platform/mcp/common/mcpGateway.js

@@ -0,0 +1,6 @@
+
+
+const McpGatewayChannelName = 'mcpGateway';
+const McpGatewayToolBrokerChannelName = 'mcpGatewayToolBroker';
+
+export { McpGatewayChannelName, McpGatewayToolBrokerChannelName };

package/vscode/src/vs/platform/mcp/common/mcpResourceScannerService.d.ts

@@ -6,11 +6,12 @@ import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/plat
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 import { IInstallableMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement";
-import { IMcpServerConfiguration, IMcpServerVariable } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
+import { IMcpSandboxConfiguration, IMcpServerConfiguration, IMcpServerVariable } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
 import { IMcpResourceScannerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpResourceScannerService.service";
 export interface IScannedMcpServers {
     servers?: IStringDictionary<Mutable<IMcpServerConfiguration>>;
     inputs?: IMcpServerVariable[];
+    sandbox?: IMcpSandboxConfiguration;
 }
 export type McpResourceTarget = ConfigurationTarget.USER | ConfigurationTarget.WORKSPACE | ConfigurationTarget.WORKSPACE_FOLDER;
 export declare class McpResourceScannerService extends Disposable implements IMcpResourceScannerService {

package/vscode/src/vs/platform/mcp/common/mcpResourceScannerService.js

@@ -42,7 +42,8 @@ let McpResourceScannerService = class McpResourceScannerService extends Disposab
             }
             return {
                 servers: existingServers,
-                inputs: updatedInputs
+                inputs: updatedInputs,
+                sandbox: scannedMcpServers.sandbox
             };
         });
     }
@@ -147,31 +148,33 @@ let McpResourceScannerService = class McpResourceScannerService extends Disposab
     }
     fromUserMcpServers(scannedMcpServers) {
         const userMcpServers = {
-            inputs: scannedMcpServers.inputs
+            inputs: scannedMcpServers.inputs,
+            sandbox: scannedMcpServers.sandbox
         };
         const servers = Object.entries(scannedMcpServers.servers ?? {});
         if (servers.length > 0) {
             userMcpServers.servers = {};
             for (const [serverName, server] of servers) {
-                userMcpServers.servers[serverName] = this.sanitizeServer(server);
+                userMcpServers.servers[serverName] = this.sanitizeServer(server, scannedMcpServers.sandbox);
             }
         }
         return userMcpServers;
     }
     fromWorkspaceFolderMcpServers(scannedWorkspaceFolderMcpServers) {
         const scannedMcpServers = {
-            inputs: scannedWorkspaceFolderMcpServers.inputs
+            inputs: scannedWorkspaceFolderMcpServers.inputs,
+            sandbox: scannedWorkspaceFolderMcpServers.sandbox
         };
         const servers = Object.entries(scannedWorkspaceFolderMcpServers.servers ?? {});
         if (servers.length > 0) {
             scannedMcpServers.servers = {};
             for (const [serverName, config] of servers) {
-                scannedMcpServers.servers[serverName] = this.sanitizeServer(config);
+                scannedMcpServers.servers[serverName] = this.sanitizeServer(config, scannedWorkspaceFolderMcpServers.sandbox);
             }
         }
         return scannedMcpServers;
     }
-    sanitizeServer(serverOrConfig) {
+    sanitizeServer(serverOrConfig, sandbox) {
         let server;
         if (serverOrConfig.config) {
             const oldScannedMcpServer = serverOrConfig;
@@ -186,6 +189,9 @@ let McpResourceScannerService = class McpResourceScannerService extends Disposab
         if (server.type === undefined || (server.type !== McpServerType.REMOTE && server.type !== McpServerType.LOCAL)) {
             server.type = server.command ? McpServerType.LOCAL : McpServerType.REMOTE;
         }
+        if (sandbox && server.type === McpServerType.LOCAL && !server.sandbox && server.sandboxEnabled) {
+            server.sandbox = sandbox;
+        }
         return server;
     }
     getResourceAccessQueue(file) {

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

@@ -17,6 +17,7 @@ import { ExtensionMcpDiscovery } from '../common/discovery/extensionMcpDiscovery
 import { InstalledMcpServersDiscovery } from '../common/discovery/installedMcpServersDiscovery.js';
 import { mcpDiscoveryRegistry } from '../common/discovery/mcpDiscovery.js';
 import { RemoteNativeMpcDiscovery } from '../common/discovery/nativeMcpRemoteDiscovery.js';
+import { PluginMcpDiscovery } from '../common/discovery/pluginMcpDiscovery.js';
 import { CursorWorkspaceMcpDiscoveryAdapter } from '../common/discovery/workspaceMcpDiscoveryAdapter.js';
 import { McpCommandIds } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
 import { mcpServerSchema } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
@@ -25,9 +26,12 @@ import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpD
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { McpLanguageModelToolContribution } from '../common/mcpLanguageModelToolContribution.js';
 import '../common/mcpRegistry.js';
+import '../common/mcpSandboxService.js';
 import { McpResourceFilesystem } from '../common/mcpResourceFilesystem.js';
 import '../common/mcpSamplingService.js';
 import '../common/mcpService.js';
+import './mcpGatewayService.js';
+import { McpGatewayToolBrokerContribution } from './mcpGatewayToolBrokerContribution.js';
 import { McpAddContextContribution } from './mcpAddContextContribution.js';
 import { ListMcpServerCommand, McpServerOptionsCommand, McpConfirmationServerOptionsCommand, ResetMcpTrustCommand, ResetMcpCachedTools, AddConfigurationAction, InstallFromManifestAction, RemoveStoredInput, EditStoredInput, StartServer, StopServer, ShowOutput, RestartServer, ShowConfiguration, McpBrowseCommand, OpenUserMcpResourceCommand, OpenRemoteUserMcpResourceCommand, OpenWorkspaceMcpResourceCommand, OpenWorkspaceFolderMcpResourceCommand, ShowInstalledMcpServersCommand, McpBrowseResourcesCommand, McpConfigureSamplingModels, McpStartPromptingServerCommand, McpSkipCurrentAutostartCommand, MCPServerActionRendering } from './mcpCommands.js';
 import { McpDiscovery } from './mcpDiscovery.js';
@@ -35,8 +39,8 @@ import './mcpElicitationService.js';
 import { McpLanguageFeatures } from './mcpLanguageFeatures.js';
 import { McpConfigMigrationContribution } from './mcpMigration.js';
 import { McpResourceQuickAccess } from './mcpResourceQuickAccess.js';
-import { McpServerEditor } from './mcpServerEditor.js';
-import { McpServerEditorInput } from './mcpServerEditorInput.js';
+import { McpServerEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpServerEditor';
+import { McpServerEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpServerEditorInput';
 import { McpServersViewsContribution } from './mcpServersView.js';
 import { MCPContextsInitialisation } from './mcpWorkbenchService.js';
 
@@ -44,6 +48,7 @@ mcpDiscoveryRegistry.register(( new SyncDescriptor(RemoteNativeMpcDiscovery)));
 mcpDiscoveryRegistry.register(( new SyncDescriptor(InstalledMcpServersDiscovery)));
 mcpDiscoveryRegistry.register(( new SyncDescriptor(ExtensionMcpDiscovery)));
 mcpDiscoveryRegistry.register(( new SyncDescriptor(CursorWorkspaceMcpDiscoveryAdapter)));
+mcpDiscoveryRegistry.register(( new SyncDescriptor(PluginMcpDiscovery)));
 registerWorkbenchContribution2("mcpDiscovery", McpDiscovery, WorkbenchPhase.AfterRestored);
 registerWorkbenchContribution2("mcpContextKeys", McpContextKeysController, WorkbenchPhase.BlockRestore);
 registerWorkbenchContribution2("mcpLanguageFeatures", McpLanguageFeatures, WorkbenchPhase.Eventually);
@@ -57,6 +62,11 @@ registerWorkbenchContribution2(
     McpLanguageModelToolContribution,
     WorkbenchPhase.AfterRestored
 );
+registerWorkbenchContribution2(
+    "mcpGatewayToolBrokerRemote",
+    McpGatewayToolBrokerContribution,
+    WorkbenchPhase.AfterRestored
+);
 registerAction2(ListMcpServerCommand);
 registerAction2(McpServerOptionsCommand);
 registerAction2(McpConfirmationServerOptionsCommand);
@@ -105,16 +115,16 @@ registerWorkbenchContribution2(
 const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
 jsonRegistry.registerSchema(mcpSchemaId, mcpServerSchema);
 ( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
-    EditorPaneDescriptor.create(McpServerEditor, McpServerEditor.ID, ( localize(9213, "MCP Server"))),
+    EditorPaneDescriptor.create(McpServerEditor, McpServerEditor.ID, ( localize(9908, "MCP Server"))),
     [( new SyncDescriptor(McpServerEditorInput))]
 );
 ( Registry.as(Extensions$1.Quickaccess)).registerQuickAccessProvider({
     ctor: McpResourceQuickAccess,
     prefix: McpResourceQuickAccess.PREFIX,
     when: ChatContextKeys.enabled,
-    placeholder: ( localize(9214, "Filter to an MCP resource")),
+    placeholder: ( localize(9909, "Filter to an MCP resource")),
     helpEntries: [{
-        description: ( localize(9215, "MCP Server Resources")),
+        description: ( localize(9910, "MCP Server Resources")),
         commandId: McpCommandIds.AddConfiguration
     }]
 });

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

@@ -43,7 +43,7 @@ let McpAddContextContribution = class McpAddContextContribution extends Disposab
     _registerAddContextMenu() {
         this._addContextMenu.value = this._chatContextPickService.registerChatContextItem({
             type: "pickerPick",
-            label: ( localize(9216, "MCP Resources...")),
+            label: ( localize(9911, "MCP Resources...")),
             icon: Codicon.mcp,
             isEnabled(widget) {
                 return !!widget.attachmentCapabilities.supportsMCPAttachments;
@@ -51,7 +51,7 @@ let McpAddContextContribution = class McpAddContextContribution extends Disposab
             asPicker: () => {
                 const helper = this._instantiationService.createInstance(McpResourcePickHelper);
                 return {
-                    placeholder: ( localize(9217, "Select MCP Resource...")),
+                    placeholder: ( localize(9912, "Select MCP Resource...")),
                     picks: (_query, token) => this._getResourcePicks(token, helper),
                     goBack: () => {
                         return helper.navigateBack();