@codingame/monaco-vscode-mcp-service-override 16.1.1 → 17.0.0

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

@@ -3,18 +3,25 @@ import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILoggerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
 import { StorageScope } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.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 { ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
 import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
 import { McpServerRequestHandler } from "./mcpServerRequestHandler.js";
 import { IMcpServer, IMcpServerConnection, IMcpTool, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerDefinition, McpServerToolsState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 import { MCP } from "./modelContextProtocol.js";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+interface IToolCacheEntry {
+    readonly nonce: string | undefined;
+    readonly tools: readonly IValidatedMcpTool[];
+}
 interface IServerCacheEntry {
     readonly servers: readonly McpServerDefinition.Serialized[];
 }
@@ -24,8 +31,8 @@ export declare class McpServerMetadataCache extends Disposable {
     private readonly extensionServers;
     constructor(scope: StorageScope, storageService: IStorageService);
     reset(): void;
-    getTools(definitionId: string): readonly IValidatedMcpTool[] | undefined;
-    storeTools(definitionId: string, tools: readonly IValidatedMcpTool[]): void;
+    getTools(definitionId: string): IToolCacheEntry | undefined;
+    storeTools(definitionId: string, nonce: string | undefined, tools: readonly IValidatedMcpTool[]): void;
     getServers(collectionId: string): IServerCacheEntry | undefined;
     storeServers(collectionId: string, entry: IServerCacheEntry | undefined): void;
 }
@@ -44,6 +51,8 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _telemetryService;
     private readonly _commandService;
     private readonly _instantiationService;
+    private readonly _notificationService;
+    private readonly _openerService;
     private readonly _connectionSequencer;
     private readonly _connection;
     readonly connection: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<IMcpServerConnection | undefined, void> & IDisposable;
@@ -56,9 +65,10 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _loggerId;
     private readonly _logger;
     get trusted(): IObservable<boolean | undefined>;
-    constructor(collection: McpCollectionReference, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _toolCache: McpServerMetadataCache, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService);
+    constructor(collection: McpCollectionReference, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _toolCache: McpServerMetadataCache, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _openerService: IOpenerService);
     showOutput(): void;
     start(isFromInteraction?: boolean): Promise<McpConnectionState>;
+    private showInteractiveError;
     stop(): Promise<void>;
     private resetLiveData;
     private _normalizeTool;
@@ -73,5 +83,8 @@ export declare class McpTool implements IMcpTool {
     get definition(): MCP.Tool;
     constructor(_server: McpServer, idPrefix: string, _definition: IValidatedMcpTool);
     call(params: Record<string, unknown>, token?: CancellationToken): Promise<MCP.CallToolResult>;
+    callWithProgress(params: Record<string, unknown>, progress: ToolProgress, token?: CancellationToken): Promise<MCP.CallToolResult>;
+    _callWithProgress(params: Record<string, unknown>, progress: ToolProgress, token?: CancellationToken, allowRetry?: boolean): Promise<MCP.CallToolResult>;
+    compare(other: IMcpTool): number;
 }
 export {};

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

@@ -1,35 +1,37 @@
 
 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 { parseTree, findNodeAtOffset, getNodePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
 import { CancellationTokenSource, CancellationToken } 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 '@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';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+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-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { mcpActivationEvent } from '@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpConnectionState, McpServerToolsState, extensionMcpCollectionPrefix, McpConnectionFailedError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
-import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { McpConnectionState, McpServerToolsState, extensionMcpCollectionPrefix, McpServerTransportType, McpConnectionFailedError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 import { 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-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common/vscode/vs/base/common/observableInternal/promise';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/promise';
 
 const toolInvalidCharRe = /[^a-z0-9_-]/gi;
 let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
@@ -62,10 +64,10 @@ let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
         this.didChange = true;
     }
     getTools(definitionId) {
-        return this.cache.get(definitionId)?.tools;
+        return this.cache.get(definitionId);
     }
-    storeTools(definitionId, tools) {
-        this.cache.set(definitionId, { ...this.cache.get(definitionId), tools });
+    storeTools(definitionId, nonce, tools) {
+        this.cache.set(definitionId, { ...this.cache.get(definitionId), nonce, tools });
         this.didChange = true;
     }
     getServers(collectionId) {
@@ -91,7 +93,7 @@ let McpServer = class McpServer extends Disposable {
     get trusted() {
         return this._mcpRegistry.getTrust(this.collection);
     }
-    constructor(collection, definition, explicitRoots, _requiresExtensionActivation, _toolCache, _mcpRegistry, workspacesService, _extensionService, _loggerService, _outputService, _telemetryService, _commandService, _instantiationService) {
+    constructor(collection, definition, explicitRoots, _requiresExtensionActivation, _toolCache, _mcpRegistry, workspacesService, _extensionService, _loggerService, _outputService, _telemetryService, _commandService, _instantiationService, _notificationService, _openerService) {
         super();
         this.collection = collection;
         this.definition = definition;
@@ -104,6 +106,8 @@ let McpServer = class McpServer extends Disposable {
         this._telemetryService = _telemetryService;
         this._commandService = _commandService;
         this._instantiationService = _instantiationService;
+        this._notificationService = _notificationService;
+        this._openerService = _openerService;
         this._connectionSequencer = ( new Sequencer());
         this._connection = this._register(disposableObservableValue(this, undefined));
         this.connection = this._connection;
@@ -111,17 +115,31 @@ let McpServer = class McpServer extends Disposable {
         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;
+            const stateWhenServingFromCache = () => {
+                if (!this.toolsFromCache) {
+                    return McpServerToolsState.Unknown;
+                }
+                return currentNonce() === this.toolsFromCache.nonce ? McpServerToolsState.Cached : McpServerToolsState.Outdated;
+            };
             const fromServer = this.toolsFromServerPromise.read(reader);
             const connectionState = this.connectionState.read(reader);
             const isIdle = McpConnectionState.canBeStarted(connectionState.state) && !fromServer;
             if (isIdle) {
-                return this.toolsFromCache ? McpServerToolsState.Cached : McpServerToolsState.Unknown;
+                return stateWhenServingFromCache();
             }
             const fromServerResult = fromServer?.promiseResult.read(reader);
             if (!fromServerResult) {
                 return this.toolsFromCache ? McpServerToolsState.RefreshingFromCached : McpServerToolsState.RefreshingFromUnknown;
             }
-            return fromServerResult.error ? (this.toolsFromCache ? McpServerToolsState.Cached : McpServerToolsState.Unknown) : McpServerToolsState.Live;
+            if (fromServerResult.error) {
+                return stateWhenServingFromCache();
+            }
+            return fromServerResult.data?.nonce === currentNonce() ? McpServerToolsState.Live : McpServerToolsState.Outdated;
         });
         this._loggerId = `mcpServer.${definition.id}`;
         this._logger = this._register(_loggerService.createLogger(this._loggerId, { hidden: true, name: `MCP: ${definition.label}` }));
@@ -140,26 +158,21 @@ let McpServer = class McpServer extends Disposable {
             })));
         }));
         this._register(autorunWithStore((reader, store) => {
-            const cnx = this._connection.read(reader)?.handler.read(reader);
-            if (cnx) {
-                this.populateLiveData(cnx, store);
+            const cnx = this._connection.read(reader);
+            const handler = cnx?.handler.read(reader);
+            if (handler) {
+                this.populateLiveData(handler, cnx?.definition.cacheNonce, store);
             }
             else {
                 this.resetLiveData();
             }
         }));
-        this._register(autorun(reader => {
-            const tools = this.toolsFromServer.read(reader);
-            if (tools) {
-                this._toolCache.storeTools(definition.id, tools);
-            }
-        }));
         const toolPrefix = this._mcpRegistry.collectionToolPrefix(this.collection);
         this.tools = derived(reader => {
             const serverTools = this.toolsFromServer.read(reader);
-            const definitions = serverTools ?? this.toolsFromCache ?? [];
+            const definitions = serverTools?.tools ?? this.toolsFromCache?.tools ?? [];
             const prefix = toolPrefix.read(reader);
-            return ( definitions.map(def => ( new McpTool(this, prefix, def))));
+            return ( definitions.map(def => ( new McpTool(this, prefix, def)))).sort((a, b) => a.compare(b));
         });
     }
     showOutput() {
@@ -205,9 +218,49 @@ let McpServer = class McpServer extends Disposable {
                 state: McpConnectionState.toKindString(state.state),
                 time: Date.now() - start,
             });
+            if (state.state === McpConnectionState.Kind.Error && isFromInteraction) {
+                this.showInteractiveError(connection, state);
+            }
             return state;
         });
     }
+    showInteractiveError(cnx, error) {
+        if (error.code === 'ENOENT' && cnx.launchDefinition.type === McpServerTransportType.Stdio) {
+            let docsLink;
+            switch (cnx.launchDefinition.command) {
+                case 'uvx':
+                    docsLink = `https://aka.ms/vscode-mcp-install/uvx`;
+                    break;
+                case 'npx':
+                    docsLink = `https://aka.ms/vscode-mcp-install/npx`;
+                    break;
+            }
+            const options = [{
+                    label: ( localize(7743, "Show Output")),
+                    run: () => this.showOutput(),
+                }];
+            if (docsLink) {
+                options.push({
+                    label: ( localize(7744, 'Install {0}', cnx.launchDefinition.command)),
+                    run: () => this._openerService.open(( URI.parse(docsLink))),
+                });
+            }
+            this._notificationService.prompt(Severity.Error, ( localize(
+                7745,
+                'The command "{0}" needed to run {1} was not found.',
+                cnx.launchDefinition.command,
+                cnx.definition.label
+            )), options);
+        }
+        else {
+            this._notificationService.warn(( localize(
+                7746,
+                'The MCP server {0} could not be started: {1}',
+                cnx.definition.label,
+                error.message
+            )));
+        }
+    }
     stop() {
         return this._connection.get()?.stop() || Promise.resolve();
     }
@@ -251,7 +304,7 @@ let McpServer = class McpServer extends Disposable {
         const validated = [];
         for (const [i, result] of validations.entries()) {
             if ('error' in result) {
-                error += ( localize(7661, 'Tool `{0}` has invalid JSON parameters:', tools[i].name)) + '\n';
+                error += ( localize(7747, 'Tool `{0}` has invalid JSON parameters:', tools[i].name)) + '\n';
                 for (const message of result.error) {
                     error += `\t- ${message}\n`;
                 }
@@ -267,17 +320,17 @@ let McpServer = class McpServer extends Disposable {
         }
         return validated;
     }
-    populateLiveData(handler, store) {
+    populateLiveData(handler, cacheNonce, store) {
         const cts = ( new CancellationTokenSource());
         store.add(toDisposable(() => cts.dispose(true)));
         const updateTools = (tx) => {
             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 this._getValidatedTools(handler, tools);
+                return { tools: await this._getValidatedTools(handler, tools), nonce: cacheNonce };
             });
             this.toolsFromServerPromise.set(( new ObservablePromise(toolPromiseSafe)), tx);
-            return [toolPromise];
+            return [toolPromiseSafe];
         };
         store.add(handler.onDidChangeToolList(() => {
             handler.logger.info('Tool list changed, refreshing tools...');
@@ -287,12 +340,15 @@ let McpServer = class McpServer extends Disposable {
         transaction(tx => {
             promises = updateTools(tx);
         });
-        Promise.all(promises).then(([tools]) => {
+        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,
             });
         });
     }
@@ -336,7 +392,9 @@ McpServer = ( __decorate([
     ( __param(9, IOutputService)),
     ( __param(10, ITelemetryService)),
     ( __param(11, ICommandService)),
-    ( __param(12, IInstantiationService))
+    ( __param(12, IInstantiationService)),
+    ( __param(13, INotificationService)),
+    ( __param(14, IOpenerService))
 ], McpServer));
 class McpTool {
     get definition() { return this._definition; }
@@ -347,7 +405,41 @@ class McpTool {
     }
     call(params, token) {
         const name = this._definition.serverToolName ?? this._definition.name;
-        return this._server.callOn(h => h.callTool({ name, arguments: params }), token);
+        return this._server.callOn(h => h.callTool({ name, arguments: params }, token), token);
+    }
+    callWithProgress(params, progress, token) {
+        return this._callWithProgress(params, progress, token);
+    }
+    _callWithProgress(params, progress, token, allowRetry = true) {
+        const name = this._definition.serverToolName ?? this._definition.name;
+        const progressToken = generateUuid();
+        return this._server.callOn(h => {
+            let lastProgressN = 0;
+            const listener = h.onDidReceiveProgressNotification((e) => {
+                if (e.params.progressToken === progressToken) {
+                    progress.report({
+                        message: e.params.message,
+                        increment: e.params.progress - lastProgressN,
+                        total: e.params.total,
+                    });
+                    lastProgressN = e.params.progress;
+                }
+            });
+            return h.callTool({ name, arguments: params, _meta: { progressToken } }, token)
+                .finally(() => listener.dispose())
+                .catch(err => {
+                const state = this._server.connectionState.get();
+                if (allowRetry && state.state === McpConnectionState.Kind.Error && state.shouldRetry) {
+                    return this._callWithProgress(params, progress, token, false);
+                }
+                else {
+                    throw err;
+                }
+            });
+        }, token);
+    }
+    compare(other) {
+        return this._definition.name.localeCompare(other.definition.name);
     }
 }
 function warnInvalidTools(instaService, serverName, errorText) {
@@ -357,7 +449,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
         notificationService.notify({
             severity: Severity.Warning,
             message: ( localize(
-                7662,
+                7748,
                 'MCP server `{0}` has tools with invalid parameters which will be omitted.',
                 serverName
             )),
@@ -367,7 +459,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
                         enabled: true,
                         id: 'mcpBadSchema.show',
                         tooltip: '',
-                        label: ( localize(7663, 'Show')),
+                        label: ( localize(7749, 'Show')),
                         run: () => {
                             editorService.openEditor({
                                 resource: undefined,

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

@@ -1,6 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { 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, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -33,7 +34,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         }
         this._launch.value = undefined;
         this._state.set({ state: McpConnectionState.Kind.Starting }, undefined);
-        this._logger.info(( localize(7664, 'Starting server {0}', this.definition.label)));
+        this._logger.info(( localize(7750, 'Starting server {0}', this.definition.label)));
         try {
             const launch = this._delegate.start(this._collection, this.definition, this.launchDefinition);
             this._launch.value = this.adoptLaunch(launch);
@@ -60,7 +61,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         store.add(autorun(reader => {
             const state = launch.state.read(reader);
             this._state.set(state, undefined);
-            this._logger.info(( localize(7665, 'Connection state: {0}', (McpConnectionState.toString(state)))));
+            this._logger.info(( localize(7751, 'Connection state: {0}', (McpConnectionState.toString(state)))));
             if (state.state === McpConnectionState.Kind.Running && !didStart) {
                 didStart = true;
                 McpServerRequestHandler.create(this._instantiationService, launch, this._logger, cts.token).then(handler => {
@@ -71,18 +72,25 @@ let McpServerConnection = class McpServerConnection extends Disposable {
                         handler.dispose();
                     }
                 }, err => {
-                    store.dispose();
                     if (!store.isDisposed) {
-                        this._logger.error(err);
-                        this._state.set({ state: McpConnectionState.Kind.Error, message: `Could not initialize MCP server: ${err.message}` }, undefined);
+                        let message = err.message;
+                        if (err instanceof CancellationError) {
+                            message = 'Server exited before responding to `initialize` request.';
+                            this._logger.error(message);
+                        }
+                        else {
+                            this._logger.error(err);
+                        }
+                        this._state.set({ state: McpConnectionState.Kind.Error, message }, undefined);
                     }
+                    store.dispose();
                 });
             }
         }));
         return { dispose: () => store.dispose(), object: launch };
     }
     async stop() {
-        this._logger.info(( localize(7666, 'Stopping server {0}', this.definition.label)));
+        this._logger.info(( localize(7752, 'Stopping server {0}', this.definition.label)));
         this._launch.value?.object.stop();
         await this._waitForState(McpConnectionState.Kind.Stopped, McpConnectionState.Kind.Error);
     }

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

@@ -18,6 +18,7 @@ export declare class McpServerRequestHandler extends Disposable {
     set roots(roots: MCP.Root[]);
     private _serverInit;
     get capabilities(): MCP.ServerCapabilities;
+    get serverInfo(): MCP.Implementation;
     private readonly _onDidReceiveCancelledNotification;
     readonly onDidReceiveCancelledNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.CancelledNotification>;
     private readonly _onDidReceiveProgressNotification;
@@ -57,7 +58,7 @@ export declare class McpServerRequestHandler extends Disposable {
     listPrompts(params?: MCP.ListPromptsRequest["params"], token?: CancellationToken): Promise<MCP.Prompt[]>;
     getPrompt(params: MCP.GetPromptRequest["params"], token?: CancellationToken): Promise<MCP.GetPromptResult>;
     listTools(params?: MCP.ListToolsRequest["params"], token?: CancellationToken): Promise<MCP.Tool[]>;
-    callTool(params: MCP.CallToolRequest["params"], token?: CancellationToken): Promise<MCP.CallToolResult>;
+    callTool(params: MCP.CallToolRequest["params"] & MCP.Request["params"], token?: CancellationToken): Promise<MCP.CallToolResult>;
     setLevel(params: MCP.SetLevelRequest["params"], token?: CancellationToken): Promise<MCP.EmptyResult>;
     complete(params: MCP.CompleteRequest["params"], token?: CancellationToken): Promise<MCP.CompleteResult>;
 }

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

@@ -25,6 +25,9 @@ class McpServerRequestHandler extends Disposable {
     get capabilities() {
         return this._serverInit.capabilities;
     }
+    get serverInfo() {
+        return this._serverInit.serverInfo;
+    }
     static async create(instaService, launch, logger, token) {
         const mcp = ( new McpServerRequestHandler(launch, logger));
         const store = ( new DisposableStore());

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

@@ -1,9 +1,10 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { Disposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MarkdownString, markdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -12,6 +13,7 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { McpCommandIds } from '@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
 import { McpServerMetadataCache, McpServer } from './mcpServer.js';
 import { McpServerToolsState, McpServerDefinition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
@@ -66,47 +68,48 @@ let McpService = class McpService extends Disposable {
                 const collection = this._mcpRegistry.collections.get().find(c => c.id === server.collection.id);
                 const toolData = {
                     id: tool.id,
-                    source: { type: 'mcp', collectionId: server.collection.id, definitionId: server.definition.id },
+                    source: { type: 'mcp', label: server.definition.label, collectionId: server.collection.id, definitionId: server.definition.id },
                     icon: Codicon.tools,
-                    displayName: tool.definition.name,
+                    displayName: tool.definition.annotations?.title || tool.definition.name,
                     toolReferenceName: tool.definition.name,
                     modelDescription: tool.definition.description ?? '',
                     userDescription: tool.definition.description ?? '',
                     inputSchema: tool.definition.inputSchema,
                     canBeReferencedInPrompt: true,
                     supportsToolPicker: true,
+                    alwaysDisplayInputOutput: true,
                     runsInWorkspace: collection?.scope === StorageScope.WORKSPACE || !!collection?.remoteAuthority,
                     tags: ['mcp'],
                 };
+                const registerTool = (store) => {
+                    store.add(this._toolsService.registerToolData(toolData));
+                    store.add(this._toolsService.registerToolImplementation(tool.id, this._instantiationService.createInstance(McpToolImplementation, tool, server)));
+                };
                 if (existing) {
                     if (!equals(existing.toolData, toolData)) {
                         existing.toolData = toolData;
-                        existing.toolDispose.dispose();
-                        existing.toolDispose = this._toolsService.registerToolData(toolData);
+                        existing.store.clear();
+                        registerTool(store);
                     }
                     toDelete.delete(tool.id);
                 }
                 else {
-                    tools.set(tool.id, {
-                        toolData,
-                        toolDispose: this._toolsService.registerToolData(toolData),
-                        implDispose: this._toolsService.registerToolImplementation(tool.id, this._instantiationService.createInstance(McpToolImplementation, tool, server)),
-                    });
+                    const store = ( new DisposableStore());
+                    registerTool(store);
+                    tools.set(tool.id, { toolData, store });
                 }
             }
             for (const id of toDelete) {
                 const tool = tools.get(id);
                 if (tool) {
-                    tool.toolDispose.dispose();
-                    tool.implDispose.dispose();
+                    tool.store.dispose();
                     tools.delete(id);
                 }
             }
         }));
         store.add(toDisposable(() => {
             for (const tool of ( tools.values())) {
-                tool.toolDispose.dispose();
-                tool.implDispose.dispose();
+                tool.store.dispose();
             }
         }));
     }
@@ -171,45 +174,61 @@ let McpToolImplementation = class McpToolImplementation {
         const tool = this._tool;
         const server = this._server;
         const mcpToolWarning = ( localize(
-            7667,
-            "{0} This tool is from \'{1}\' (MCP Server). Note that MCP servers or malicious conversation content may attempt to misuse '{2}' through tools. Please carefully review any requested actions.",
+            7753,
+            "{0} Note that MCP servers or malicious conversation content may attempt to misuse '{1}' through tools.",
             '$(info)',
-            server.definition.label,
             this._productService.nameShort
         ));
+        const needsConfirmation = !tool.definition.annotations?.readOnlyHint;
+        const title = tool.definition.annotations?.title || ('`' + tool.definition.name + '`');
+        const subtitle = ( localize(7754, "{0} (MCP Server)", server.definition.label));
         return {
-            confirmationMessages: {
-                title: ( localize(7668, "Run `{0}`", tool.definition.name, server.definition.label)),
-                message: ( new MarkdownString(( localize(7669, "{0}\n\n {1}", tool.definition.description, mcpToolWarning)), { supportThemeIcons: true })),
+            confirmationMessages: needsConfirmation ? {
+                title: ( localize(7755, "Run {0}", title)),
+                message: ( new MarkdownString(( localize(7756, "{0}\n\n {1}", tool.definition.description, mcpToolWarning)), { supportThemeIcons: true })),
                 allowAutoConfirm: true,
-            },
-            invocationMessage: ( new MarkdownString(( localize(7670, "Running `{0}`", tool.definition.name, server.definition.label)))),
-            pastTenseMessage: ( new MarkdownString(( localize(7671, "Ran `{0}` ", tool.definition.name, server.definition.label)))),
+            } : undefined,
+            invocationMessage: ( new MarkdownString(( localize(7757, "Running {0}", title)))),
+            pastTenseMessage: ( new MarkdownString(( localize(7758, "Ran {0} ", title)))),
+            originMessage: ( new MarkdownString(markdownCommandLink({
+                id: McpCommandIds.ShowConfiguration,
+                title: subtitle,
+                arguments: [server.collection.id, server.definition.id],
+            }), { isTrusted: true })),
             toolSpecificData: {
                 kind: 'input',
                 rawInput: parameters
             }
         };
     }
-    async invoke(invocation, _countTokens, token) {
+    async invoke(invocation, _countTokens, progress, token) {
         const result = {
             content: []
         };
-        const outputParts = [];
-        const callResult = await this._tool.call(invocation.parameters, token);
+        const callResult = await this._tool.callWithProgress(invocation.parameters, progress, token);
+        const details = {
+            input: JSON.stringify(invocation.parameters, undefined, 2),
+            output: [],
+            isError: callResult.isError === true,
+        };
         for (const item of callResult.content) {
             if (item.type === 'text') {
+                details.output.push({ type: 'text', value: item.text });
                 result.content.push({
                     kind: 'text',
                     value: item.text
                 });
-                outputParts.push(item.text);
             }
+            else if (item.type === 'image' || item.type === 'audio') {
+                details.output.push({ type: 'data', mimeType: item.mimeType, value64: item.data });
+                result.content.push({
+                    kind: 'data',
+                    value: { mimeType: item.mimeType, data: decodeBase64(item.data) }
+                });
+            }
+            else ;
         }
-        result.toolResultDetails = {
-            input: JSON.stringify(invocation.parameters, undefined, 2),
-            output: outputParts.join('\n')
-        };
+        result.toolResultDetails = details;
         return result;
     }
 };