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

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

@@ -25,16 +25,16 @@ import { IURLService } from '@codingame/monaco-vscode-api/vscode/vs/platform/url
 import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { WORKSPACE_STANDALONE_CONFIGURATIONS, MCP_CONFIGURATION_KEY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configuration/common/configuration';
-import { ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { MODAL_GROUP, ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { LocalMcpServerScope, USER_CONFIG_ID, REMOTE_USER_CONFIG_ID, WORKSPACE_CONFIG_ID, WORKSPACE_FOLDER_CONFIG_ID_PREFIX } from '../../../services/mcp/common/mcpWorkbenchManagementService.js';
+import { LocalMcpServerScope, USER_CONFIG_ID, REMOTE_USER_CONFIG_ID, WORKSPACE_CONFIG_ID, WORKSPACE_FOLDER_CONFIG_ID_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService';
 import { IWorkbenchMcpManagementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService.service';
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { mcpConfigurationSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
 import { McpServerEnablementState, McpCollectionSortOrder, McpServerInstallState, McpServersGalleryStatusContext, HasInstalledMcpServersContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpService, IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
-import { McpServerEditorInput } from './mcpServerEditorInput.js';
+import { McpServerEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpServerEditorInput';
 import { IMcpGalleryManifestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpGalleryManifest.service';
 import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
@@ -442,7 +442,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
             const existing = result.get(server.name);
             if (existing) {
                 this.logService.warn(( localize(
-                    9487,
+                    10368,
                     "Overwriting mcp server '{0}' from {1} with {2}.",
                     server.name,
                     server.mcpResource.path,
@@ -455,7 +455,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
             const existing = result.get(server.name);
             if (existing) {
                 this.logService.warn(( localize(
-                    9487,
+                    10368,
                     "Overwriting mcp server '{0}' from {1} with {2}.",
                     server.name,
                     server.mcpResource.path,
@@ -468,7 +468,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
     }
     canInstall(mcpServer) {
         if (!(mcpServer instanceof McpWorkbenchServer)) {
-            return ( new MarkdownString()).appendText(( localize(9488, "The provided object is not an mcp server.")));
+            return ( new MarkdownString()).appendText(( localize(10369, "The provided object is not an mcp server.")));
         }
         if (mcpServer.gallery) {
             const result = this.mcpManagementService.canInstall(mcpServer.gallery);
@@ -485,7 +485,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
             return result;
         }
         return ( new MarkdownString()).appendText(( localize(
-            9489,
+            10370,
             "Cannot install the '{0}' MCP Server because it is not available in this setup.",
             mcpServer.label
         )));
@@ -592,7 +592,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
             id: USER_CONFIG_ID,
             key: "userLocalValue",
             target: ConfigurationTarget.USER_LOCAL,
-            label: ( localize(9490, "Global in {0}", this.productService.nameShort)),
+            label: ( localize(10371, "Global in {0}", this.productService.nameShort)),
             scope: StorageScope.PROFILE,
             order: McpCollectionSortOrder.User,
             uri: mcpResource,
@@ -747,10 +747,11 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
         await this.extensionsWorkbenchService.openSearch(`@mcp ${searchValue}`, preserveFoucs);
     }
     async open(extension, options) {
+        const useModal = this.configurationService.getValue("extensions.allowOpenInModalEditor");
         await this.editorService.openEditor(
             this.instantiationService.createInstance(McpServerEditorInput, extension),
             options,
-            ACTIVE_GROUP
+            useModal ? MODAL_GROUP : ACTIVE_GROUP
         );
     }
     getInstallState(extension) {
@@ -789,7 +790,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
                 message: {
                     severity: Severity.Warning,
                     text: ( new MarkdownString(( localize(
-                        9491,
+                        10372,
                         "This MCP Server is disabled because MCP servers are configured to be disabled in the Editor. Please check your [settings]({0}).",
                         settingsCommandLink
                     ))))
@@ -803,7 +804,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
                     message: {
                         severity: Severity.Warning,
                         text: ( new MarkdownString(( localize(
-                            9492,
+                            10373,
                             "This MCP Server is disabled because it is configured to be disabled in the Editor. Please check your [settings]({0}).",
                             settingsCommandLink
                         ))))
@@ -817,7 +818,7 @@ let McpWorkbenchService = class McpWorkbenchService extends Disposable {
                     message: {
                         severity: Severity.Warning,
                         text: ( new MarkdownString(( localize(
-                            9492,
+                            10373,
                             "This MCP Server is disabled because it is configured to be disabled in the Editor. Please check your [settings]({0}).",
                             settingsCommandLink
                         ))))

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(10374, "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(10375, "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(10376, "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(10377, "Expected 'when' to be a non-empty string.")));
                 return false;
             }
         }

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

@@ -88,12 +88,14 @@ let InstalledMcpServersDiscovery = class InstalledMcpServersDiscovery extends Di
                     args: config.args || [],
                     env: config.env || {},
                     envFile: config.envFile,
-                    cwd: config.cwd
+                    cwd: config.cwd,
+                    sandbox: server.rootSandbox
                 };
                 definitions[1].push({
                     id: `${collectionId}.${server.name}`,
                     label: server.name,
                     launch,
+                    sandboxEnabled: config.type === "http" ? undefined : config.sandboxEnabled,
                     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,
+                10378,
                 " on {0}",
                 labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority)
             ));

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

@@ -22,7 +22,8 @@ async function claudeConfigToServerDefinition(idPrefix, contents, cwd) {
             command: server.command,
             env: server.env || {},
             envFile: undefined,
-            cwd: cwd?.fsPath
+            cwd: cwd?.fsPath,
+            sandbox: undefined
         };
         return {
             id: `${idPrefix}.${name}`,

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 { 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: `${plugin.label} (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,
+                sandbox: undefined
+            };
+        }
+        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(10419, "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(10420, "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(10421, "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(10422, "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,39 @@
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+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 _logService;
+    private readonly _startupGracePeriodMs;
+    private readonly _onDidChangeTools;
+    private readonly _onDidChangeResources;
+    private readonly _serverIdMap;
+    private _nextServerIndex;
+    /**
+     * Per-server promise that races server startup against the grace period timeout.
+     * Once set for a server, subsequent list calls await the already-resolved promise
+     * and return immediately instead of waiting again.
+     *
+     * The `resolved` flag tracks whether the promise has settled. If a server's
+     * cacheState regresses to Unknown/Outdated after the promise resolved (e.g.
+     * after a cache reset), `_waitForStartup` discards the stale entry and creates
+     * a fresh race so the server gets another chance to start.
+     */
+    private readonly _startupGrace;
+    constructor(_mcpService: IMcpService, _logService: ILogService, _startupGracePeriodMs?: number);
+    private _getServerIndex;
+    private _getServerByIndex;
+    private _waitForStartup;
+    private _shouldUseCachedData;
+    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,302 @@
+
+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, _logService, _startupGracePeriodMs = 5000) {
+        super();
+        this._mcpService = _mcpService;
+        this._logService = _logService;
+        this._startupGracePeriodMs = _startupGracePeriodMs;
+        this._onDidChangeTools = this._register(( new Emitter()));
+        this._onDidChangeResources = this._register(( new Emitter()));
+        this._serverIdMap = ( new Map());
+        this._nextServerIndex = 0;
+        this._startupGrace = ( new Map());
+        this._logService.debug("[McpGateway][ToolBroker] Initialized");
+        let toolsInitialized = false;
+        this._register(autorun(reader => {
+            for (const server of this._mcpService.servers.read(reader)) {
+                server.tools.read(reader);
+            }
+            if (toolsInitialized) {
+                this._logService.debug("[McpGateway][ToolBroker] Tools changed, firing onDidChangeTools");
+                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._logService.debug("[McpGateway][ToolBroker] Resources changed, firing onDidChangeResources");
+                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;
+    }
+    _waitForStartup(server) {
+        const id = server.definition.id;
+        const existing = this._startupGrace.get(id);
+        if (existing?.resolved) {
+            const state = server.cacheState.get();
+            if (state === McpServerCacheState.Unknown || state === McpServerCacheState.Outdated) {
+                this._startupGrace.delete(id);
+            }
+        }
+        if (!( this._startupGrace.has(id))) {
+            const entry = {
+                promise: Promise.race([this._ensureServerReady(server), ( new Promise(resolve => setTimeout(() => resolve(false), this._startupGracePeriodMs)))]),
+                resolved: false
+            };
+            entry.promise.then(() => {
+                entry.resolved = true;
+            });
+            this._startupGrace.set(id, entry);
+        }
+        return this._startupGrace.get(id).promise;
+    }
+    async _shouldUseCachedData(server) {
+        const cacheState = server.cacheState.get();
+        if (cacheState === McpServerCacheState.Unknown || cacheState === McpServerCacheState.Outdated) {
+            await this._waitForStartup(server);
+            const newState = server.cacheState.get();
+            return newState === McpServerCacheState.Live || newState === McpServerCacheState.Cached || newState === McpServerCacheState.RefreshingFromCached;
+        }
+        return cacheState === McpServerCacheState.Live || cacheState === McpServerCacheState.Cached || cacheState === McpServerCacheState.RefreshingFromCached;
+    }
+    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) {
+        this._logService.debug(`[McpGateway][ToolBroker] IPC call: ${command}`);
+        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 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();
+        this._logService.debug(
+            `[McpGateway][ToolBroker] listTools result: ${mcpTools.length} tool(s): [${( mcpTools.map(t => t.name)).join(", ")}]`
+        );
+        return mcpTools;
+    }
+    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)
+            );
+            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)
+                };
+            }
+        }
+        this._logService.warn(`[McpGateway][ToolBroker] Tool '${name}' not found on any server`);
+        throw ( new Error(`Unknown tool: ${name}`));
+    }
+    async _listResources() {
+        const results = [];
+        const servers = this._mcpService.servers.get();
+        this._logService.debug(
+            `[McpGateway][ToolBroker] listResources: ${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)) {
+                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
+                );
+            }
+        })));
+        this._logService.debug(
+            `[McpGateway][ToolBroker] listResources result: ${results.length} server(s) with resources`
+        );
+        return results;
+    }
+    async _readResource(serverIndex, uri, token = CancellationToken.None) {
+        const server = this._getServerByIndex(serverIndex);
+        if (!server) {
+            this._logService.warn(
+                `[McpGateway][ToolBroker] readResource: unknown server index ${serverIndex}`
+            );
+            throw ( new Error(`Unknown server index: ${serverIndex}`));
+        }
+        this._logService.debug(
+            `[McpGateway][ToolBroker] readResource '${uri}' from server '${server.definition.id}' (index=${serverIndex})`
+        );
+        const result = await McpServer.callOn(server, h => h.readResource({
+            uri
+        }, token), token);
+        this._logService.debug(
+            `[McpGateway][ToolBroker] readResource 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 _ensureServerReady(server) {
+        const cacheState = server.cacheState.get();
+        if (cacheState !== McpServerCacheState.Unknown && cacheState !== McpServerCacheState.Outdated) {
+            return true;
+        }
+        this._logService.debug(
+            `[McpGateway][ToolBroker] Server '${server.definition.id}' not ready (cacheState=${cacheState}), starting...`
+        );
+        try {
+            const ready = await startServerAndWaitForLiveTools(server, {
+                promptType: "all-untrusted",
+                errorOnUserInteraction: true
+            });
+            this._logService.debug(`[McpGateway][ToolBroker] Server '${server.definition.id}' ready=${ready}`);
+            return ready;
+        } catch (error) {
+            this._logService.warn(
+                `[McpGateway][ToolBroker] Server '${server.definition.id}' failed to start`,
+                error
+            );
+            return false;
+        }
+    }
+}
+
+export { McpGatewayToolBrokerChannel };