@codingame/monaco-vscode-mcp-service-override 16.0.0

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

@@ -0,0 +1,27 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ISecretStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/secrets/common/secrets.service";
+import { StorageScope, 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 { IResolvedValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression";
+export declare class McpRegistryInputStorage extends Disposable {
+    private readonly _scope;
+    private readonly _storageService;
+    private readonly _secretStorageService;
+    private readonly _logService;
+    private static secretSequencer;
+    private readonly _secretsSealerSequencer;
+    private readonly _getEncryptionKey;
+    private _didChange;
+    private _record;
+    constructor(_scope: StorageScope, _target: StorageTarget, _storageService: IStorageService, _secretStorageService: ISecretStorageService, _logService: ILogService);
+    clearAll(): void;
+    clear(inputKey: string): Promise<void>;
+    getMap(): Promise<{
+        [x: string]: IResolvedValue;
+    }>;
+    setPlainText(values: Record<string, IResolvedValue>): Promise<void>;
+    setSecrets(values: Record<string, IResolvedValue>): Promise<void>;
+    private _sealSecrets;
+    private _unsealSecrets;
+}

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

@@ -0,0 +1,134 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { encodeBase64, VSBuffer, decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isEmptyObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ISecretStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/secrets/common/secrets.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+
+var McpRegistryInputStorage_1;
+const MCP_ENCRYPTION_KEY_NAME = 'mcpEncryptionKey';
+const MCP_ENCRYPTION_KEY_ALGORITHM = 'AES-GCM';
+const MCP_ENCRYPTION_KEY_LEN = 256;
+const MCP_ENCRYPTION_IV_LENGTH = 12;
+const MCP_DATA_STORED_VERSION = 1;
+const MCP_DATA_STORED_KEY = 'mcpInputs';
+let McpRegistryInputStorage = class McpRegistryInputStorage extends Disposable {
+    static { McpRegistryInputStorage_1 = this; }
+    static { this.secretSequencer = ( new Sequencer()); }
+    constructor(_scope, _target, _storageService, _secretStorageService, _logService) {
+        super();
+        this._scope = _scope;
+        this._storageService = _storageService;
+        this._secretStorageService = _secretStorageService;
+        this._logService = _logService;
+        this._secretsSealerSequencer = ( new Sequencer());
+        this._getEncryptionKey = ( new Lazy(() => {
+            return McpRegistryInputStorage_1.secretSequencer.queue(async () => {
+                const existing = await this._secretStorageService.get(MCP_ENCRYPTION_KEY_NAME);
+                if (existing) {
+                    try {
+                        const parsed = JSON.parse(existing);
+                        return await crypto.subtle.importKey('jwk', parsed, MCP_ENCRYPTION_KEY_ALGORITHM, false, ['encrypt', 'decrypt']);
+                    }
+                    catch {
+                    }
+                }
+                const key = await crypto.subtle.generateKey({ name: MCP_ENCRYPTION_KEY_ALGORITHM, length: MCP_ENCRYPTION_KEY_LEN }, true, ['encrypt', 'decrypt']);
+                const exported = await crypto.subtle.exportKey('jwk', key);
+                await this._secretStorageService.set(MCP_ENCRYPTION_KEY_NAME, JSON.stringify(exported));
+                return key;
+            });
+        }));
+        this._didChange = false;
+        this._record = ( new Lazy(() => {
+            const stored = this._storageService.getObject(MCP_DATA_STORED_KEY, this._scope);
+            return stored?.version === MCP_DATA_STORED_VERSION ? { ...stored } : { version: MCP_DATA_STORED_VERSION, values: {} };
+        }));
+        this._register(_storageService.onWillSaveState(() => {
+            if (this._didChange) {
+                this._storageService.store(MCP_DATA_STORED_KEY, {
+                    version: MCP_DATA_STORED_VERSION,
+                    values: this._record.value.values,
+                    secrets: this._record.value.secrets,
+                }, this._scope, _target);
+                this._didChange = false;
+            }
+        }));
+    }
+    clearAll() {
+        this._record.value.values = {};
+        this._record.value.secrets = undefined;
+        this._record.value.unsealedSecrets = undefined;
+        this._didChange = true;
+    }
+    async clear(inputKey) {
+        const secrets = await this._unsealSecrets();
+        delete this._record.value.values[inputKey];
+        this._didChange = true;
+        if (secrets.hasOwnProperty(inputKey)) {
+            delete secrets[inputKey];
+            await this._sealSecrets();
+        }
+    }
+    async getMap() {
+        const secrets = await this._unsealSecrets();
+        return { ...this._record.value.values, ...secrets };
+    }
+    async setPlainText(values) {
+        Object.assign(this._record.value.values, values);
+        this._didChange = true;
+    }
+    async setSecrets(values) {
+        const unsealed = await this._unsealSecrets();
+        Object.assign(unsealed, values);
+        await this._sealSecrets();
+    }
+    async _sealSecrets() {
+        const key = await this._getEncryptionKey.value;
+        return this._secretsSealerSequencer.queue(async () => {
+            if (!this._record.value.unsealedSecrets || isEmptyObject(this._record.value.unsealedSecrets)) {
+                this._record.value.secrets = undefined;
+                return;
+            }
+            const toSeal = JSON.stringify(this._record.value.unsealedSecrets);
+            const iv = crypto.getRandomValues(( new Uint8Array(MCP_ENCRYPTION_IV_LENGTH)));
+            const encrypted = await crypto.subtle.encrypt({ name: MCP_ENCRYPTION_KEY_ALGORITHM, iv: iv.buffer }, key, ( new TextEncoder()).encode(toSeal).buffer);
+            const enc = encodeBase64(VSBuffer.wrap(( new Uint8Array(encrypted))));
+            this._record.value.secrets = { iv: encodeBase64(VSBuffer.wrap(iv)), value: enc };
+            this._didChange = true;
+        });
+    }
+    async _unsealSecrets() {
+        if (!this._record.value.secrets) {
+            return this._record.value.unsealedSecrets ??= {};
+        }
+        if (this._record.value.unsealedSecrets) {
+            return this._record.value.unsealedSecrets;
+        }
+        try {
+            const key = await this._getEncryptionKey.value;
+            const iv = decodeBase64(this._record.value.secrets.iv);
+            const encrypted = decodeBase64(this._record.value.secrets.value);
+            const decrypted = await crypto.subtle.decrypt({ name: MCP_ENCRYPTION_KEY_ALGORITHM, iv: iv.buffer }, key, encrypted.buffer);
+            const unsealedSecrets = JSON.parse(( new TextDecoder()).decode(decrypted));
+            this._record.value.unsealedSecrets = unsealedSecrets;
+            return unsealedSecrets;
+        }
+        catch (e) {
+            this._logService.warn('Error unsealing MCP secrets', e);
+            this._record.value.secrets = undefined;
+        }
+        return {};
+    }
+};
+McpRegistryInputStorage = McpRegistryInputStorage_1 = ( __decorate([
+    ( __param(2, IStorageService)),
+    ( __param(3, ISecretStorageService)),
+    ( __param(4, ILogService))
+], McpRegistryInputStorage));
+
+export { McpRegistryInputStorage };

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

@@ -0,0 +1,77 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { ILoggerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.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 { 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 IServerCacheEntry {
+    readonly servers: readonly McpServerDefinition.Serialized[];
+}
+export declare class McpServerMetadataCache extends Disposable {
+    private didChange;
+    private readonly cache;
+    private readonly extensionServers;
+    constructor(scope: StorageScope, storageService: IStorageService);
+    reset(): void;
+    getTools(definitionId: string): readonly IValidatedMcpTool[] | undefined;
+    storeTools(definitionId: string, tools: readonly IValidatedMcpTool[]): void;
+    getServers(collectionId: string): IServerCacheEntry | undefined;
+    storeServers(collectionId: string, entry: IServerCacheEntry | undefined): void;
+}
+interface IValidatedMcpTool extends MCP.Tool {
+    serverToolName: string;
+}
+export declare class McpServer extends Disposable implements IMcpServer {
+    readonly collection: McpCollectionReference;
+    readonly definition: McpDefinitionReference;
+    private readonly _requiresExtensionActivation;
+    private readonly _toolCache;
+    private readonly _mcpRegistry;
+    private readonly _extensionService;
+    private readonly _loggerService;
+    private readonly _outputService;
+    private readonly _telemetryService;
+    private readonly _commandService;
+    private readonly _instantiationService;
+    private readonly _connectionSequencer;
+    private readonly _connection;
+    readonly connection: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<IMcpServerConnection | undefined, void> & IDisposable;
+    readonly connectionState: IObservable<McpConnectionState>;
+    private get toolsFromCache();
+    private readonly toolsFromServerPromise;
+    private readonly toolsFromServer;
+    readonly tools: IObservable<readonly IMcpTool[]>;
+    readonly toolsState: IObservable<McpServerToolsState>;
+    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);
+    showOutput(): void;
+    start(isFromInteraction?: boolean): Promise<McpConnectionState>;
+    stop(): Promise<void>;
+    private resetLiveData;
+    private _normalizeTool;
+    private _getValidatedTools;
+    private populateLiveData;
+    callOn<R>(fn: (handler: McpServerRequestHandler) => Promise<R>, token?: CancellationToken): Promise<R>;
+}
+export declare class McpTool implements IMcpTool {
+    private readonly _server;
+    private readonly _definition;
+    readonly id: string;
+    get definition(): MCP.Tool;
+    constructor(_server: McpServer, idPrefix: string, _definition: IValidatedMcpTool);
+    call(params: Record<string, unknown>, token?: CancellationToken): Promise<MCP.CallToolResult>;
+}
+export {};

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

@@ -0,0 +1,383 @@
+
+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 { 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 { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.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 { 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 { 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 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';
+
+const toolInvalidCharRe = /[^a-z0-9_-]/gi;
+let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
+    constructor(scope, storageService) {
+        super();
+        this.didChange = false;
+        this.cache = ( new LRUCache(128));
+        this.extensionServers = ( new Map());
+        const storageKey = 'mcpToolCache';
+        this._register(storageService.onWillSaveState(() => {
+            if (this.didChange) {
+                storageService.store(storageKey, {
+                    extensionServers: [...this.extensionServers],
+                    serverTools: this.cache.toJSON(),
+                }, scope, StorageTarget.MACHINE);
+                this.didChange = false;
+            }
+        }));
+        try {
+            const cached = storageService.getObject(storageKey, scope);
+            this.extensionServers = ( new Map(cached?.extensionServers ?? []));
+            cached?.serverTools?.forEach(([k, v]) => this.cache.set(k, v));
+        }
+        catch {
+        }
+    }
+    reset() {
+        this.cache.clear();
+        this.extensionServers.clear();
+        this.didChange = true;
+    }
+    getTools(definitionId) {
+        return this.cache.get(definitionId)?.tools;
+    }
+    storeTools(definitionId, tools) {
+        this.cache.set(definitionId, { ...this.cache.get(definitionId), tools });
+        this.didChange = true;
+    }
+    getServers(collectionId) {
+        return this.extensionServers.get(collectionId);
+    }
+    storeServers(collectionId, entry) {
+        if (entry) {
+            this.extensionServers.set(collectionId, entry);
+        }
+        else {
+            this.extensionServers.delete(collectionId);
+        }
+        this.didChange = true;
+    }
+};
+McpServerMetadataCache = ( __decorate([
+    ( __param(1, IStorageService))
+], McpServerMetadataCache));
+let McpServer = class McpServer extends Disposable {
+    get toolsFromCache() {
+        return this._toolCache.getTools(this.definition.id);
+    }
+    get trusted() {
+        return this._mcpRegistry.getTrust(this.collection);
+    }
+    constructor(collection, definition, explicitRoots, _requiresExtensionActivation, _toolCache, _mcpRegistry, workspacesService, _extensionService, _loggerService, _outputService, _telemetryService, _commandService, _instantiationService) {
+        super();
+        this.collection = collection;
+        this.definition = definition;
+        this._requiresExtensionActivation = _requiresExtensionActivation;
+        this._toolCache = _toolCache;
+        this._mcpRegistry = _mcpRegistry;
+        this._extensionService = _extensionService;
+        this._loggerService = _loggerService;
+        this._outputService = _outputService;
+        this._telemetryService = _telemetryService;
+        this._commandService = _commandService;
+        this._instantiationService = _instantiationService;
+        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 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;
+            }
+            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;
+        });
+        this._loggerId = `mcpServer.${definition.id}`;
+        this._logger = this._register(_loggerService.createLogger(this._loggerId, { hidden: true, name: `MCP: ${definition.label}` }));
+        this._register(toDisposable(() => _loggerService.deregisterLogger(this._loggerId)));
+        const workspaces = explicitRoots
+            ? observableValue(this, ( explicitRoots.map(uri => ({ uri, name: basename(uri) }))))
+            : observableFromEvent(this, workspacesService.onDidChangeWorkspaceFolders, () => workspacesService.getWorkspace().folders);
+        this._register(autorunWithStore(reader => {
+            const cnx = this._connection.read(reader)?.handler.read(reader);
+            if (!cnx) {
+                return;
+            }
+            cnx.roots = ( workspaces.read(reader).map(wf => ({
+                uri: ( wf.uri.toString()),
+                name: wf.name,
+            })));
+        }));
+        this._register(autorunWithStore((reader, store) => {
+            const cnx = this._connection.read(reader)?.handler.read(reader);
+            if (cnx) {
+                this.populateLiveData(cnx, 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 prefix = toolPrefix.read(reader);
+            return ( definitions.map(def => ( new McpTool(this, prefix, def))));
+        });
+    }
+    showOutput() {
+        this._loggerService.setVisibility(this._loggerId, true);
+        this._outputService.showChannel(this._loggerId);
+    }
+    start(isFromInteraction) {
+        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
+                    .map(r => r.waitForInitialProviderPromises())));
+                if (this._store.isDisposed) {
+                    return { state: McpConnectionState.Kind.Stopped };
+                }
+            }
+            let connection = this._connection.get();
+            if (connection && McpConnectionState.canBeStarted(connection.state.get().state)) {
+                connection.dispose();
+                connection = undefined;
+                this._connection.set(connection, undefined);
+            }
+            if (!connection) {
+                connection = await this._mcpRegistry.resolveConnection({
+                    logger: this._logger,
+                    collectionRef: this.collection,
+                    definitionRef: this.definition,
+                    forceTrust: isFromInteraction,
+                });
+                if (!connection) {
+                    return { state: McpConnectionState.Kind.Stopped };
+                }
+                if (this._store.isDisposed) {
+                    connection.dispose();
+                    return { state: McpConnectionState.Kind.Stopped };
+                }
+                this._connection.set(connection, undefined);
+            }
+            const start = Date.now();
+            const state = await connection.start();
+            this._telemetryService.publicLog2('mcp/serverBootState', {
+                state: McpConnectionState.toKindString(state.state),
+                time: Date.now() - start,
+            });
+            return state;
+        });
+    }
+    stop() {
+        return this._connection.get()?.stop() || Promise.resolve();
+    }
+    resetLiveData() {
+        transaction(tx => {
+            this.toolsFromServerPromise.set(undefined, tx);
+        });
+    }
+    async _normalizeTool(originalTool) {
+        const tool = { ...originalTool, serverToolName: originalTool.name };
+        if (!tool.description) {
+            this._logger.warn(`Tool ${tool.name} does not have a description. Tools must be accurately described to be called`);
+            tool.description = '<empty>';
+        }
+        if (toolInvalidCharRe.test(tool.name)) {
+            this._logger.warn(`Tool ${JSON.stringify(tool.name)} is invalid. Tools names may only contain [a-z0-9_-]`);
+            tool.name = tool.name.replace(toolInvalidCharRe, '_');
+        }
+        let diagnostics = [];
+        const toolJson = JSON.stringify(tool.inputSchema);
+        try {
+            const schemaUri = ( URI.parse('https://json-schema.org/draft-07/schema'));
+            diagnostics = (await this._commandService.executeCommand('json.validate', schemaUri, toolJson)) || [];
+        }
+        catch (e) {
+        }
+        if (!diagnostics.length) {
+            return tool;
+        }
+        const tree = parseTree(toolJson);
+        const messages = ( diagnostics.map(d => {
+            const node = findNodeAtOffset(tree, d.range[0].character);
+            const path = node && `/${getNodePath(node).join('/')}`;
+            return d.message + (path ? ` (at ${path})` : '');
+        }));
+        return { error: messages };
+    }
+    async _getValidatedTools(handler, tools) {
+        let error = '';
+        const validations = await Promise.all(( tools.map(t => this._normalizeTool(t))));
+        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';
+                for (const message of result.error) {
+                    error += `\t- ${message}\n`;
+                }
+                error += `\t- Schema: ${JSON.stringify(tools[i].inputSchema)}\n\n`;
+            }
+            else {
+                validated.push(result);
+            }
+        }
+        if (error) {
+            handler.logger.warn(`${tools.length - validated.length} tools have invalid JSON schemas and will be omitted`);
+            warnInvalidTools(this._instantiationService, this.definition.label, error);
+        }
+        return validated;
+    }
+    populateLiveData(handler, 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);
+            });
+            this.toolsFromServerPromise.set(( new ObservablePromise(toolPromiseSafe)), tx);
+            return [toolPromise];
+        };
+        store.add(handler.onDidChangeToolList(() => {
+            handler.logger.info('Tool list changed, refreshing tools...');
+            updateTools(undefined);
+        }));
+        let promises;
+        transaction(tx => {
+            promises = updateTools(tx);
+        });
+        Promise.all(promises).then(([tools]) => {
+            this._telemetryService.publicLog2('mcp/serverBoot', {
+                supportsLogging: !!handler.capabilities.logging,
+                supportsPrompts: !!handler.capabilities.prompts,
+                supportsResources: !!handler.capabilities.resources,
+                toolCount: tools.length,
+            });
+        });
+    }
+    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))
+], McpServer));
+class McpTool {
+    get definition() { return this._definition; }
+    constructor(_server, idPrefix, _definition) {
+        this._server = _server;
+        this._definition = _definition;
+        this.id = (idPrefix + _definition.name).replaceAll('.', '_');
+    }
+    call(params, token) {
+        const name = this._definition.serverToolName ?? this._definition.name;
+        return this._server.callOn(h => h.callTool({ name, arguments: params }), token);
+    }
+}
+function warnInvalidTools(instaService, serverName, errorText) {
+    instaService.invokeFunction((accessor) => {
+        const notificationService = accessor.get(INotificationService);
+        const editorService = accessor.get(IEditorService);
+        notificationService.notify({
+            severity: Severity.Warning,
+            message: ( localize(
+                7662,
+                'MCP server `{0}` has tools with invalid parameters which will be omitted.',
+                serverName
+            )),
+            actions: {
+                primary: [{
+                        class: undefined,
+                        enabled: true,
+                        id: 'mcpBadSchema.show',
+                        tooltip: '',
+                        label: ( localize(7663, 'Show')),
+                        run: () => {
+                            editorService.openEditor({
+                                resource: undefined,
+                                contents: errorText,
+                            });
+                        }
+                    }]
+            }
+        });
+    });
+}
+
+export { McpServer, McpServerMetadataCache, McpTool };

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

@@ -0,0 +1,26 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+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";
+export declare class McpServerConnection extends Disposable implements IMcpServerConnection {
+    private readonly _collection;
+    readonly definition: McpServerDefinition;
+    private readonly _delegate;
+    readonly launchDefinition: McpServerLaunch;
+    private readonly _logger;
+    private readonly _instantiationService;
+    private readonly _launch;
+    private readonly _state;
+    private readonly _requestHandler;
+    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>;
+    private adoptLaunch;
+    stop(): Promise<void>;
+    dispose(): void;
+    private _waitForState;
+}