@codingame/monaco-vscode-mcp-service-override 17.2.0 → 18.0.0

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

@@ -1,10 +1,11 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Sequencer, raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { raceCancellationError, Sequencer, AsyncIterableObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { parseTree, findNodeAtOffset, getNodePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { mapValues } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -23,16 +24,21 @@ import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
-import { mcpActivationEvent } from '@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { mcpActivationEvent } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { McpDevModeServerAttache } from './mcpDevMode.js';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpConnectionState, McpServerToolsState, extensionMcpCollectionPrefix, McpServerTransportType, McpConnectionFailedError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { McpConnectionState, McpConnectionFailedError, McpServerCacheState, extensionMcpCollectionPrefix, McpServerTransportType, mcpPromptReplaceSpecialChars, McpCapability, McpToolName, McpResourceURI } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpSamplingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { UriTemplate } from './uriTemplate.js';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
-import { disposableObservableValue, observableValue, transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
-import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
-import { autorunWithStore, autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/promise';
+import { observableValue, disposableObservableValue } 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 { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun, autorunWithStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
 
+var McpServer_1;
 const toolInvalidCharRe = /[^a-z0-9_-]/gi;
 let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
     constructor(scope, storageService) {
@@ -63,11 +69,11 @@ let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
         this.extensionServers.clear();
         this.didChange = true;
     }
-    getTools(definitionId) {
+    get(definitionId) {
         return this.cache.get(definitionId);
     }
-    storeTools(definitionId, nonce, tools) {
-        this.cache.set(definitionId, { ...this.cache.get(definitionId), nonce, tools });
+    store(definitionId, entry) {
+        this.cache.set(definitionId, entry);
         this.didChange = true;
     }
     getServers(collectionId) {
@@ -86,19 +92,75 @@ let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
 McpServerMetadataCache = ( __decorate([
     ( __param(1, IStorageService))
 ], McpServerMetadataCache));
-let McpServer = class McpServer extends Disposable {
-    get toolsFromCache() {
-        return this._toolCache.getTools(this.definition.id);
+class CachedPrimitive {
+    constructor(_definitionId, _cache, _fromCache, _toT) {
+        this._definitionId = _definitionId;
+        this._cache = _cache;
+        this._fromCache = _fromCache;
+        this._toT = _toT;
+        this.fromServerPromise = observableValue(this, undefined);
+        this.fromServer = derived(reader => this.fromServerPromise.read(reader)?.promiseResult.read(reader)?.data);
+        this.value = derived(reader => {
+            const serverTools = this.fromServer.read(reader);
+            const definitions = serverTools?.data ?? this.fromCache?.data ?? [];
+            return this._toT(definitions, reader);
+        });
+    }
+    get fromCache() {
+        const c = this._cache.get(this._definitionId);
+        return c ? { data: this._fromCache(c), nonce: c.nonce } : undefined;
+    }
+}
+let McpServer = McpServer_1 = class McpServer extends Disposable {
+    static async callOn(server, fn, token = CancellationToken.None) {
+        await server.start();
+        let ranOnce = false;
+        let d;
+        const callPromise = ( new Promise((resolve, reject) => {
+            d = autorun(reader => {
+                const connection = server.connection.read(reader);
+                if (!connection || ranOnce) {
+                    return;
+                }
+                const handler = connection.handler.read(reader);
+                if (!handler) {
+                    const state = connection.state.read(reader);
+                    if (state.state === McpConnectionState.Kind.Error) {
+                        reject(( new McpConnectionFailedError(`MCP server could not be started: ${state.message}`)));
+                        return;
+                    }
+                    else if (state.state === McpConnectionState.Kind.Stopped) {
+                        reject(( new McpConnectionFailedError('MCP server has stopped')));
+                        return;
+                    }
+                    else {
+                        return;
+                    }
+                }
+                resolve(fn(handler));
+                ranOnce = true;
+            });
+        }));
+        return raceCancellationError(callPromise, token).finally(() => d.dispose());
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    get tools() {
+        return this._tools.value;
+    }
+    get prompts() {
+        return this._prompts.value;
     }
     get trusted() {
         return this._mcpRegistry.getTrust(this.collection);
     }
-    constructor(collection, definition, explicitRoots, _requiresExtensionActivation, _toolCache, _mcpRegistry, workspacesService, _extensionService, _loggerService, _outputService, _telemetryService, _commandService, _instantiationService, _notificationService, _openerService) {
+    constructor(collection, definition, explicitRoots, _requiresExtensionActivation, _primitiveCache, toolPrefix, _mcpRegistry, workspacesService, _extensionService, _loggerService, _outputService, _telemetryService, _commandService, _instantiationService, _notificationService, _openerService, _samplingService) {
         super();
         this.collection = collection;
         this.definition = definition;
         this._requiresExtensionActivation = _requiresExtensionActivation;
-        this._toolCache = _toolCache;
+        this._primitiveCache = _primitiveCache;
         this._mcpRegistry = _mcpRegistry;
         this._extensionService = _extensionService;
         this._loggerService = _loggerService;
@@ -108,41 +170,42 @@ let McpServer = class McpServer extends Disposable {
         this._instantiationService = _instantiationService;
         this._notificationService = _notificationService;
         this._openerService = _openerService;
+        this._samplingService = _samplingService;
         this._connectionSequencer = ( new Sequencer());
         this._connection = this._register(disposableObservableValue(this, undefined));
         this.connection = this._connection;
         this.connectionState = derived(reader => this._connection.read(reader)?.state.read(reader) ?? { state: McpConnectionState.Kind.Stopped });
-        this.toolsFromServerPromise = observableValue(this, undefined);
-        this.toolsFromServer = derived(reader => this.toolsFromServerPromise.read(reader)?.promiseResult.read(reader)?.data);
-        this.toolsState = derived(reader => {
-            const currentNonce = () => this._mcpRegistry.collections.read(reader)
-                .find(c => c.id === this.collection.id)
-                ?.serverDefinitions.read(reader)
-                .find(d => d.id === this.definition.id)
-                ?.cacheNonce;
+        this._capabilities = observableValue('mcpserver.capabilities', undefined);
+        this.cacheState = derived(reader => {
+            const currentNonce = () => this._fullDefinitions.read(reader)?.server?.cacheNonce;
             const stateWhenServingFromCache = () => {
-                if (!this.toolsFromCache) {
-                    return McpServerToolsState.Unknown;
+                if (!this._tools.fromCache) {
+                    return McpServerCacheState.Unknown;
                 }
-                return currentNonce() === this.toolsFromCache.nonce ? McpServerToolsState.Cached : McpServerToolsState.Outdated;
+                return currentNonce() === this._tools.fromCache.nonce ? McpServerCacheState.Cached : McpServerCacheState.Outdated;
             };
-            const fromServer = this.toolsFromServerPromise.read(reader);
+            const fromServer = this._tools.fromServerPromise.read(reader);
             const connectionState = this.connectionState.read(reader);
-            const isIdle = McpConnectionState.canBeStarted(connectionState.state) && !fromServer;
+            const isIdle = McpConnectionState.canBeStarted(connectionState.state) || !fromServer;
             if (isIdle) {
                 return stateWhenServingFromCache();
             }
             const fromServerResult = fromServer?.promiseResult.read(reader);
             if (!fromServerResult) {
-                return this.toolsFromCache ? McpServerToolsState.RefreshingFromCached : McpServerToolsState.RefreshingFromUnknown;
+                return this._tools.fromCache ? McpServerCacheState.RefreshingFromCached : McpServerCacheState.RefreshingFromUnknown;
             }
             if (fromServerResult.error) {
                 return stateWhenServingFromCache();
             }
-            return fromServerResult.data?.nonce === currentNonce() ? McpServerToolsState.Live : McpServerToolsState.Outdated;
+            return fromServerResult.data?.nonce === currentNonce() ? McpServerCacheState.Live : McpServerCacheState.Outdated;
         });
+        this._lastModeDebugged = false;
+        this.runningToolCalls = 0;
+        this._fullDefinitions = this._mcpRegistry.getServerDefinition(this.collection, this.definition);
         this._loggerId = `mcpServer.${definition.id}`;
         this._logger = this._register(_loggerService.createLogger(this._loggerId, { hidden: true, name: `MCP: ${definition.label}` }));
+        const that = this;
+        this._register(this._instantiationService.createInstance(McpDevModeServerAttache, this, { get lastModeDebugged() { return that._lastModeDebugged; } }));
         this._register(toDisposable(() => _loggerService.deregisterLogger(this._loggerId)));
         const workspaces = explicitRoots
             ? observableValue(this, ( explicitRoots.map(uri => ({ uri, name: basename(uri) }))))
@@ -163,28 +226,56 @@ let McpServer = class McpServer extends Disposable {
             if (handler) {
                 this.populateLiveData(handler, cnx?.definition.cacheNonce, store);
             }
-            else {
+            else if (this._tools) {
                 this.resetLiveData();
             }
         }));
-        const toolPrefix = this._mcpRegistry.collectionToolPrefix(this.collection);
-        this.tools = derived(reader => {
-            const serverTools = this.toolsFromServer.read(reader);
-            const definitions = serverTools?.tools ?? this.toolsFromCache?.tools ?? [];
-            const prefix = toolPrefix.read(reader);
-            return ( definitions.map(def => ( new McpTool(this, prefix, def)))).sort((a, b) => a.compare(b));
-        });
+        this._tools = ( new CachedPrimitive(
+            this.definition.id,
+            this._primitiveCache,
+            (entry) => entry.tools,
+            (entry) => ( entry.map(def => ( new McpTool(this, toolPrefix, def)))).sort((a, b) => a.compare(b))
+        ));
+        this._prompts = ( new CachedPrimitive(
+            this.definition.id,
+            this._primitiveCache,
+            (entry) => entry.prompts || [],
+            (entry) => ( entry.map(e => ( new McpPrompt(this, e))))
+        ));
+        this._capabilities.set(this._primitiveCache.get(this.definition.id)?.capabilities, undefined);
+    }
+    readDefinitions() {
+        return this._fullDefinitions;
     }
     showOutput() {
         this._loggerService.setVisibility(this._loggerId, true);
         this._outputService.showChannel(this._loggerId);
     }
-    start(isFromInteraction) {
+    resources(token) {
+        const cts = ( new CancellationTokenSource(token));
+        return ( new AsyncIterableObject(async (emitter) => {
+            await McpServer_1.callOn(this, async (handler) => {
+                for await (const resource of handler.listResourcesIterable({}, cts.token)) {
+                    emitter.emitOne(( resource.map(r => ( new McpResource(this, r)))));
+                    if (cts.token.isCancellationRequested) {
+                        return;
+                    }
+                }
+            });
+        }, () => cts.dispose(true)));
+    }
+    resourceTemplates(token) {
+        return McpServer_1.callOn(this, async (handler) => {
+            const templates = await handler.listResourceTemplates({}, token);
+            return ( templates.map(t => ( new McpResourceTemplate(this, t))));
+        }, token);
+    }
+    start({ isFromInteraction, debug } = {}) {
         return this._connectionSequencer.queue(async () => {
             const activationEvent = mcpActivationEvent(this.collection.id.slice(extensionMcpCollectionPrefix.length));
             if (this._requiresExtensionActivation && !this._extensionService.activationEventIsDone(activationEvent)) {
                 await this._extensionService.activateByEvent(activationEvent);
-                await Promise.all(( this._mcpRegistry.delegates
+                await Promise.all(( this._mcpRegistry.delegates.get()
                     .map(r => r.waitForInitialProviderPromises())));
                 if (this._store.isDisposed) {
                     return { state: McpConnectionState.Kind.Stopped };
@@ -197,11 +288,13 @@ let McpServer = class McpServer extends Disposable {
                 this._connection.set(connection, undefined);
             }
             if (!connection) {
+                this._lastModeDebugged = !!debug;
                 connection = await this._mcpRegistry.resolveConnection({
                     logger: this._logger,
                     collectionRef: this.collection,
                     definitionRef: this.definition,
                     forceTrust: isFromInteraction,
+                    debug,
                 });
                 if (!connection) {
                     return { state: McpConnectionState.Kind.Stopped };
@@ -212,19 +305,28 @@ let McpServer = class McpServer extends Disposable {
                 }
                 this._connection.set(connection, undefined);
             }
+            if (isFromInteraction && connection.definition.devMode) {
+                this.showOutput();
+            }
             const start = Date.now();
-            const state = await connection.start();
+            const state = await connection.start({
+                createMessageRequestHandler: params => this._samplingService.sample({
+                    isDuringToolCall: true,
+                    server: this,
+                    params,
+                }).then(r => r.sample)
+            });
             this._telemetryService.publicLog2('mcp/serverBootState', {
                 state: McpConnectionState.toKindString(state.state),
                 time: Date.now() - start,
             });
             if (state.state === McpConnectionState.Kind.Error && isFromInteraction) {
-                this.showInteractiveError(connection, state);
+                this.showInteractiveError(connection, state, debug);
             }
             return state;
         });
     }
-    showInteractiveError(cnx, error) {
+    showInteractiveError(cnx, error, debug) {
         if (error.code === 'ENOENT' && cnx.launchDefinition.type === McpServerTransportType.Stdio) {
             let docsLink;
             switch (cnx.launchDefinition.command) {
@@ -236,17 +338,29 @@ let McpServer = class McpServer extends Disposable {
                     break;
             }
             const options = [{
-                    label: ( localize(7743, "Show Output")),
+                    label: ( localize(7968, "Show Output")),
                     run: () => this.showOutput(),
                 }];
+            if (cnx.definition.devMode?.debug?.type === 'debugpy' && debug) {
+                this._notificationService.prompt(Severity.Error, ( localize(
+                    7969,
+                    'The command "{0}" was not found. You can specify the path to debugpy in the `dev.debug.debugpyPath` option.',
+                    cnx.launchDefinition.command,
+                    cnx.definition.label
+                )), [...options, {
+                        label: ( localize(7970, 'View Docs')),
+                        run: () => this._openerService.open(( URI.parse('https://aka.ms/vscode-mcp-install/debugpy'))),
+                    }]);
+                return;
+            }
             if (docsLink) {
                 options.push({
-                    label: ( localize(7744, 'Install {0}', cnx.launchDefinition.command)),
+                    label: ( localize(7971, 'Install {0}', cnx.launchDefinition.command)),
                     run: () => this._openerService.open(( URI.parse(docsLink))),
                 });
             }
             this._notificationService.prompt(Severity.Error, ( localize(
-                7745,
+                7972,
                 'The command "{0}" needed to run {1} was not found.',
                 cnx.launchDefinition.command,
                 cnx.definition.label
@@ -254,7 +368,7 @@ let McpServer = class McpServer extends Disposable {
         }
         else {
             this._notificationService.warn(( localize(
-                7746,
+                7973,
                 'The MCP server {0} could not be started: {1}',
                 cnx.definition.label,
                 error.message
@@ -266,7 +380,8 @@ let McpServer = class McpServer extends Disposable {
     }
     resetLiveData() {
         transaction(tx => {
-            this.toolsFromServerPromise.set(undefined, tx);
+            this._tools.fromServerPromise.set(undefined, tx);
+            this._prompts.fromServerPromise.set(undefined, tx);
         });
     }
     async _normalizeTool(originalTool) {
@@ -304,7 +419,7 @@ let McpServer = class McpServer extends Disposable {
         const validated = [];
         for (const [i, result] of validations.entries()) {
             if ('error' in result) {
-                error += ( localize(7747, 'Tool `{0}` has invalid JSON parameters:', tools[i].name)) + '\n';
+                error += ( localize(7974, 'Tool `{0}` has invalid JSON parameters:', tools[i].name)) + '\n';
                 for (const message of result.error) {
                     error += `\t- ${message}\n`;
                 }
@@ -327,93 +442,143 @@ let McpServer = class McpServer extends Disposable {
             const toolPromise = handler.capabilities.tools ? handler.listTools({}, cts.token) : Promise.resolve([]);
             const toolPromiseSafe = toolPromise.then(async (tools) => {
                 handler.logger.info(`Discovered ${tools.length} tools`);
-                return { tools: await this._getValidatedTools(handler, tools), nonce: cacheNonce };
+                return { data: await this._getValidatedTools(handler, tools), nonce: cacheNonce };
             });
-            this.toolsFromServerPromise.set(( new ObservablePromise(toolPromiseSafe)), tx);
-            return [toolPromiseSafe];
+            this._tools.fromServerPromise.set(( new ObservablePromise(toolPromiseSafe)), tx);
+            return toolPromiseSafe;
+        };
+        const updatePrompts = (tx) => {
+            const promptsPromise = handler.capabilities.prompts ? handler.listPrompts({}, cts.token) : Promise.resolve([]);
+            const promptsPromiseSafe = promptsPromise.then(data => ({ data, nonce: cacheNonce }));
+            this._prompts.fromServerPromise.set(( new ObservablePromise(promptsPromiseSafe)), tx);
+            return promptsPromiseSafe;
         };
         store.add(handler.onDidChangeToolList(() => {
             handler.logger.info('Tool list changed, refreshing tools...');
             updateTools(undefined);
         }));
-        let promises;
+        store.add(handler.onDidChangePromptList(() => {
+            handler.logger.info('Prompts list changed, refreshing prompts...');
+            updatePrompts(undefined);
+        }));
         transaction(tx => {
-            promises = updateTools(tx);
-        });
-        Promise.all(promises).then(([{ tools }]) => {
-            this._toolCache.storeTools(this.definition.id, cacheNonce, tools);
-            this._telemetryService.publicLog2('mcp/serverBoot', {
-                supportsLogging: !!handler.capabilities.logging,
-                supportsPrompts: !!handler.capabilities.prompts,
-                supportsResources: !!handler.capabilities.resources,
-                toolCount: tools.length,
-                serverName: handler.serverInfo.name,
-                serverVersion: handler.serverInfo.version,
+            const capabilities = encodeCapabilities(handler.capabilities);
+            this._capabilities.set(capabilities, tx);
+            Promise.all([updateTools(tx), updatePrompts(tx)]).then(([{ data: tools }, { data: prompts }]) => {
+                this._primitiveCache.store(this.definition.id, {
+                    nonce: cacheNonce,
+                    tools,
+                    prompts,
+                    capabilities,
+                });
+                this._telemetryService.publicLog2('mcp/serverBoot', {
+                    supportsLogging: !!handler.capabilities.logging,
+                    supportsPrompts: !!handler.capabilities.prompts,
+                    supportsResources: !!handler.capabilities.resources,
+                    toolCount: tools.length,
+                    serverName: handler.serverInfo.name,
+                    serverVersion: handler.serverInfo.version,
+                });
             });
         });
     }
-    async callOn(fn, token = CancellationToken.None) {
-        await this.start();
-        let ranOnce = false;
-        let d;
-        const callPromise = ( new Promise((resolve, reject) => {
-            d = autorun(reader => {
-                const connection = this._connection.read(reader);
-                if (!connection || ranOnce) {
-                    return;
-                }
-                const handler = connection.handler.read(reader);
-                if (!handler) {
-                    const state = connection.state.read(reader);
-                    if (state.state === McpConnectionState.Kind.Error) {
-                        reject(( new McpConnectionFailedError(`MCP server could not be started: ${state.message}`)));
-                        return;
-                    }
-                    else if (state.state === McpConnectionState.Kind.Stopped) {
-                        reject(( new McpConnectionFailedError('MCP server has stopped')));
-                        return;
-                    }
-                    else {
-                        return;
-                    }
-                }
-                resolve(fn(handler));
-                ranOnce = true;
-            });
-        }));
-        return raceCancellationError(callPromise, token).finally(() => d.dispose());
-    }
 };
-McpServer = ( __decorate([
-    ( __param(5, IMcpRegistry)),
-    ( __param(6, IWorkspaceContextService)),
-    ( __param(7, IExtensionService)),
-    ( __param(8, ILoggerService)),
-    ( __param(9, IOutputService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, ICommandService)),
-    ( __param(12, IInstantiationService)),
-    ( __param(13, INotificationService)),
-    ( __param(14, IOpenerService))
+McpServer = McpServer_1 = ( __decorate([
+    ( __param(6, IMcpRegistry)),
+    ( __param(7, IWorkspaceContextService)),
+    ( __param(8, IExtensionService)),
+    ( __param(9, ILoggerService)),
+    ( __param(10, IOutputService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, ICommandService)),
+    ( __param(13, IInstantiationService)),
+    ( __param(14, INotificationService)),
+    ( __param(15, IOpenerService)),
+    ( __param(16, IMcpSamplingService))
 ], McpServer));
+class McpPrompt {
+    constructor(_server, _definition) {
+        this._server = _server;
+        this._definition = _definition;
+        this.id = mcpPromptReplaceSpecialChars(this._server.definition.label + '.' + _definition.name);
+        this.name = _definition.name;
+        this.description = _definition.description;
+        this.arguments = _definition.arguments || [];
+    }
+    async resolve(args, token) {
+        const result = await McpServer.callOn(this._server, h => h.getPrompt({ name: this._definition.name, arguments: args }, token), token);
+        return result.messages;
+    }
+    async complete(argument, prefix, token) {
+        const result = await McpServer.callOn(this._server, h => h.complete({
+            ref: { type: 'ref/prompt', name: this._definition.name },
+            argument: { name: argument, value: prefix, }
+        }, token), token);
+        return result.completion.values;
+    }
+}
+function encodeCapabilities(cap) {
+    let out = 0;
+    if (cap.logging) {
+        out |= McpCapability.Logging;
+    }
+    if (cap.completions) {
+        out |= McpCapability.Completions;
+    }
+    if (cap.prompts) {
+        out |= McpCapability.Prompts;
+        if (cap.prompts.listChanged) {
+            out |= McpCapability.PromptsListChanged;
+        }
+    }
+    if (cap.resources) {
+        out |= McpCapability.Resources;
+        if (cap.resources.subscribe) {
+            out |= McpCapability.ResourcesSubscribe;
+        }
+        if (cap.resources.listChanged) {
+            out |= McpCapability.ResourcesListChanged;
+        }
+    }
+    if (cap.tools) {
+        out |= McpCapability.Tools;
+        if (cap.tools.listChanged) {
+            out |= McpCapability.ToolsListChanged;
+        }
+    }
+    return out;
+}
 class McpTool {
     get definition() { return this._definition; }
     constructor(_server, idPrefix, _definition) {
         this._server = _server;
         this._definition = _definition;
-        this.id = (idPrefix + _definition.name).replaceAll('.', '_');
+        this.referenceName = _definition.name.replaceAll('.', '_');
+        this.id = (idPrefix + _definition.name).replaceAll('.', '_').slice(0, McpToolName.MaxLength);
     }
-    call(params, token) {
+    async call(params, token) {
         const name = this._definition.serverToolName ?? this._definition.name;
-        return this._server.callOn(h => h.callTool({ name, arguments: params }, token), token);
+        this._server.runningToolCalls++;
+        try {
+            return await McpServer.callOn(this._server, h => h.callTool({ name, arguments: params }, token), token);
+        }
+        finally {
+            this._server.runningToolCalls--;
+        }
     }
-    callWithProgress(params, progress, token) {
-        return this._callWithProgress(params, progress, token);
+    async callWithProgress(params, progress, token) {
+        this._server.runningToolCalls++;
+        try {
+            return await this._callWithProgress(params, progress, token);
+        }
+        finally {
+            this._server.runningToolCalls--;
+        }
     }
     _callWithProgress(params, progress, token, allowRetry = true) {
         const name = this._definition.serverToolName ?? this._definition.name;
         const progressToken = generateUuid();
-        return this._server.callOn(h => {
+        return McpServer.callOn(this._server, h => {
             let lastProgressN = 0;
             const listener = h.onDidReceiveProgressNotification((e) => {
                 if (e.params.progressToken === progressToken) {
@@ -449,7 +614,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
         notificationService.notify({
             severity: Severity.Warning,
             message: ( localize(
-                7748,
+                7975,
                 'MCP server `{0}` has tools with invalid parameters which will be omitted.',
                 serverName
             )),
@@ -459,7 +624,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
                         enabled: true,
                         id: 'mcpBadSchema.show',
                         tooltip: '',
-                        label: ( localize(7749, 'Show')),
+                        label: ( localize(7976, 'Show')),
                         run: () => {
                             editorService.openEditor({
                                 resource: undefined,
@@ -471,5 +636,37 @@ function warnInvalidTools(instaService, serverName, errorText) {
         });
     });
 }
+class McpResource {
+    constructor(server, original) {
+        this.mcpUri = original.uri;
+        this.uri = McpResourceURI.fromServer(server.definition, original.uri);
+        this.name = original.name;
+        this.description = original.description;
+        this.mimeType = original.mimeType;
+        this.sizeInBytes = original.size;
+    }
+}
+class McpResourceTemplate {
+    constructor(_server, _definition) {
+        this._server = _server;
+        this._definition = _definition;
+        this.name = _definition.name;
+        this.description = _definition.description;
+        this.mimeType = _definition.mimeType;
+        this.template = UriTemplate.parse(_definition.uriTemplate);
+    }
+    resolveURI(vars) {
+        const serverUri = this.template.resolve(vars);
+        return McpResourceURI.fromServer(this._server.definition, serverUri);
+    }
+    async complete(templatePart, prefix, alreadyResolved, token) {
+        const result = await McpServer.callOn(this._server, h => h.complete({
+            ref: { type: 'ref/resource', uri: this._definition.uriTemplate },
+            argument: { name: templatePart, value: prefix },
+            resolved: mapValues(alreadyResolved, v => Array.isArray(v) ? v.join('/') : v),
+        }, token), token);
+        return result.completion.values;
+    }
+}
 
 export { McpServer, McpServerMetadataCache, McpTool };

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

@@ -4,7 +4,7 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { ILogger } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log";
 import { IMcpHostDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
 import { McpServerRequestHandler } from "./mcpServerRequestHandler.js";
-import { IMcpServerConnection, McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpClientMethods, IMcpServerConnection, McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 export declare class McpServerConnection extends Disposable implements IMcpServerConnection {
     private readonly _collection;
     readonly definition: McpServerDefinition;
@@ -18,7 +18,7 @@ export declare class McpServerConnection extends Disposable implements IMcpServe
     readonly state: IObservable<McpConnectionState>;
     readonly handler: IObservable<McpServerRequestHandler | undefined>;
     constructor(_collection: McpCollectionDefinition, definition: McpServerDefinition, _delegate: IMcpHostDelegate, launchDefinition: McpServerLaunch, _logger: ILogger, _instantiationService: IInstantiationService);
-    start(): Promise<McpConnectionState>;
+    start(methods: IMcpClientMethods): Promise<McpConnectionState>;
     private adoptLaunch;
     stop(): Promise<void>;
     dispose(): void;