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

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

@@ -0,0 +1,114 @@
+
+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 { 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';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { log } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { McpServerRequestHandler } from './mcpServerRequestHandler.js';
+import { McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+let McpServerConnection = class McpServerConnection extends Disposable {
+    constructor(_collection, definition, _delegate, launchDefinition, _logger, _instantiationService) {
+        super();
+        this._collection = _collection;
+        this.definition = definition;
+        this._delegate = _delegate;
+        this.launchDefinition = launchDefinition;
+        this._logger = _logger;
+        this._instantiationService = _instantiationService;
+        this._launch = this._register(( new MutableDisposable()));
+        this._state = observableValue('mcpServerState', { state: McpConnectionState.Kind.Stopped });
+        this._requestHandler = observableValue('mcpServerRequestHandler', undefined);
+        this.state = this._state;
+        this.handler = this._requestHandler;
+    }
+    async start() {
+        const currentState = this._state.get();
+        if (!McpConnectionState.canBeStarted(currentState.state)) {
+            return this._waitForState(McpConnectionState.Kind.Running, McpConnectionState.Kind.Error);
+        }
+        this._launch.value = undefined;
+        this._state.set({ state: McpConnectionState.Kind.Starting }, undefined);
+        this._logger.info(( localize(7664, 'Starting server {0}', this.definition.label)));
+        try {
+            const launch = this._delegate.start(this._collection, this.definition, this.launchDefinition);
+            this._launch.value = this.adoptLaunch(launch);
+            return this._waitForState(McpConnectionState.Kind.Running, McpConnectionState.Kind.Error);
+        }
+        catch (e) {
+            const errorState = {
+                state: McpConnectionState.Kind.Error,
+                message: e instanceof Error ? e.message : String(e)
+            };
+            this._state.set(errorState, undefined);
+            return errorState;
+        }
+    }
+    adoptLaunch(launch) {
+        const store = ( new DisposableStore());
+        const cts = ( new CancellationTokenSource());
+        store.add(toDisposable(() => cts.dispose(true)));
+        store.add(launch);
+        store.add(launch.onDidLog(({ level, message }) => {
+            log(this._logger, level, message);
+        }));
+        let didStart = false;
+        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)))));
+            if (state.state === McpConnectionState.Kind.Running && !didStart) {
+                didStart = true;
+                McpServerRequestHandler.create(this._instantiationService, launch, this._logger, cts.token).then(handler => {
+                    if (!store.isDisposed) {
+                        this._requestHandler.set(handler, undefined);
+                    }
+                    else {
+                        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);
+                    }
+                });
+            }
+        }));
+        return { dispose: () => store.dispose(), object: launch };
+    }
+    async stop() {
+        this._logger.info(( localize(7666, 'Stopping server {0}', this.definition.label)));
+        this._launch.value?.object.stop();
+        await this._waitForState(McpConnectionState.Kind.Stopped, McpConnectionState.Kind.Error);
+    }
+    dispose() {
+        this._requestHandler.get()?.dispose();
+        super.dispose();
+        this._state.set({ state: McpConnectionState.Kind.Stopped }, undefined);
+    }
+    _waitForState(...kinds) {
+        const current = this._state.get();
+        if (kinds.includes(current.state)) {
+            return Promise.resolve(current);
+        }
+        return ( new Promise(resolve => {
+            const disposable = autorun(reader => {
+                const state = this._state.read(reader);
+                if (kinds.includes(state.state)) {
+                    disposable.dispose();
+                    resolve(state);
+                }
+            });
+        }));
+    }
+};
+McpServerConnection = ( __decorate([
+    ( __param(5, IInstantiationService))
+], McpServerConnection));
+
+export { McpServerConnection };

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

@@ -0,0 +1,63 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { IMcpMessageTransport } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
+import { MCP } from "./modelContextProtocol.js";
+export interface McpRoot {
+    uri: string;
+    name?: string;
+}
+export declare class McpServerRequestHandler extends Disposable {
+    private readonly launch;
+    readonly logger: ILogger;
+    private _nextRequestId;
+    private readonly _pendingRequests;
+    private _hasAnnouncedRoots;
+    private _roots;
+    set roots(roots: MCP.Root[]);
+    private _serverInit;
+    get capabilities(): MCP.ServerCapabilities;
+    private readonly _onDidReceiveCancelledNotification;
+    readonly onDidReceiveCancelledNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.CancelledNotification>;
+    private readonly _onDidReceiveProgressNotification;
+    readonly onDidReceiveProgressNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.ProgressNotification>;
+    private readonly _onDidChangeResourceList;
+    readonly onDidChangeResourceList: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _onDidUpdateResource;
+    readonly onDidUpdateResource: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.ResourceUpdatedNotification>;
+    private readonly _onDidChangeToolList;
+    readonly onDidChangeToolList: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _onDidChangePromptList;
+    readonly onDidChangePromptList: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    static create(instaService: IInstantiationService, launch: IMcpMessageTransport, logger: ILogger, token?: CancellationToken): Promise<McpServerRequestHandler>;
+    protected constructor(launch: IMcpMessageTransport, logger: ILogger);
+    private sendRequest;
+    private send;
+    private sendRequestPaginated;
+    private sendNotification;
+    private handleMessage;
+    private handleResult;
+    private handleError;
+    private handleServerRequest;
+    private handleServerNotification;
+    private handleCancelledNotification;
+    private handleLoggingNotification;
+    private respondToRequest;
+    private handlePing;
+    private handleRootsList;
+    private cancelAllRequests;
+    dispose(): void;
+    initialize(params: MCP.InitializeRequest["params"], token?: CancellationToken): Promise<MCP.InitializeResult>;
+    listResources(params?: MCP.ListResourcesRequest["params"], token?: CancellationToken): Promise<MCP.Resource[]>;
+    readResource(params: MCP.ReadResourceRequest["params"], token?: CancellationToken): Promise<MCP.ReadResourceResult>;
+    listResourceTemplates(params?: MCP.ListResourceTemplatesRequest["params"], token?: CancellationToken): Promise<MCP.ResourceTemplate[]>;
+    subscribe(params: MCP.SubscribeRequest["params"], token?: CancellationToken): Promise<MCP.EmptyResult>;
+    unsubscribe(params: MCP.UnsubscribeRequest["params"], token?: CancellationToken): Promise<MCP.EmptyResult>;
+    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>;
+    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

@@ -0,0 +1,318 @@
+
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { IntervalTimer, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { canLog, LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { McpConnectionState, MpcResponseError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { MCP } from './modelContextProtocol.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+class McpServerRequestHandler extends Disposable {
+    set roots(roots) {
+        if (!equals(this._roots, roots)) {
+            this._roots = roots;
+            if (this._hasAnnouncedRoots) {
+                this.sendNotification({ method: 'notifications/roots/list_changed' });
+                this._hasAnnouncedRoots = false;
+            }
+        }
+    }
+    get capabilities() {
+        return this._serverInit.capabilities;
+    }
+    static async create(instaService, launch, logger, token) {
+        const mcp = ( new McpServerRequestHandler(launch, logger));
+        const store = ( new DisposableStore());
+        try {
+            const timer = store.add(( new IntervalTimer()));
+            timer.cancelAndSet(() => {
+                logger.info('Waiting for server to respond to `initialize` request...');
+            }, 5000);
+            await instaService.invokeFunction(async (accessor) => {
+                const productService = accessor.get(IProductService);
+                const initialized = await mcp.sendRequest({
+                    method: 'initialize',
+                    params: {
+                        protocolVersion: MCP.LATEST_PROTOCOL_VERSION,
+                        capabilities: {
+                            roots: { listChanged: true },
+                        },
+                        clientInfo: {
+                            name: productService.nameLong,
+                            version: productService.version,
+                        }
+                    }
+                }, token);
+                mcp._serverInit = initialized;
+                mcp.sendNotification({
+                    method: 'notifications/initialized'
+                });
+            });
+            return mcp;
+        }
+        catch (e) {
+            mcp.dispose();
+            throw e;
+        }
+        finally {
+            store.dispose();
+        }
+    }
+    constructor(launch, logger) {
+        super();
+        this.launch = launch;
+        this.logger = logger;
+        this._nextRequestId = 1;
+        this._pendingRequests = ( new Map());
+        this._hasAnnouncedRoots = false;
+        this._roots = [];
+        this._onDidReceiveCancelledNotification = this._register(( new Emitter()));
+        this.onDidReceiveCancelledNotification = this._onDidReceiveCancelledNotification.event;
+        this._onDidReceiveProgressNotification = this._register(( new Emitter()));
+        this.onDidReceiveProgressNotification = this._onDidReceiveProgressNotification.event;
+        this._onDidChangeResourceList = this._register(( new Emitter()));
+        this.onDidChangeResourceList = this._onDidChangeResourceList.event;
+        this._onDidUpdateResource = this._register(( new Emitter()));
+        this.onDidUpdateResource = this._onDidUpdateResource.event;
+        this._onDidChangeToolList = this._register(( new Emitter()));
+        this.onDidChangeToolList = this._onDidChangeToolList.event;
+        this._onDidChangePromptList = this._register(( new Emitter()));
+        this.onDidChangePromptList = this._onDidChangePromptList.event;
+        this._register(launch.onDidReceiveMessage(message => this.handleMessage(message)));
+        this._register(autorun(reader => {
+            const state = launch.state.read(reader).state;
+            if (state === McpConnectionState.Kind.Error || state === McpConnectionState.Kind.Stopped) {
+                this.cancelAllRequests();
+            }
+        }));
+    }
+    async sendRequest(request, token = CancellationToken.None) {
+        if (this._store.isDisposed) {
+            return Promise.reject(( new CancellationError()));
+        }
+        const id = this._nextRequestId++;
+        const jsonRpcRequest = {
+            jsonrpc: MCP.JSONRPC_VERSION,
+            id,
+            ...request
+        };
+        const promise = ( new DeferredPromise());
+        this._pendingRequests.set(id, { promise });
+        const cancelListener = token.onCancellationRequested(() => {
+            if (!promise.isSettled) {
+                this._pendingRequests.delete(id);
+                this.sendNotification({ method: 'notifications/cancelled', params: { requestId: id } });
+                promise.cancel();
+            }
+            cancelListener.dispose();
+        });
+        this.send(jsonRpcRequest);
+        const ret = promise.p.finally(() => {
+            cancelListener.dispose();
+            this._pendingRequests.delete(id);
+        });
+        return ret;
+    }
+    send(mcp) {
+        if (canLog(this.logger.getLevel(), LogLevel.Debug)) {
+            this.logger.debug(`[editor -> server] ${JSON.stringify(mcp)}`);
+        }
+        this.launch.send(mcp);
+    }
+    async sendRequestPaginated(method, getItems, initialParams, token = CancellationToken.None) {
+        let allItems = [];
+        let nextCursor = undefined;
+        do {
+            const params = {
+                ...initialParams,
+                cursor: nextCursor
+            };
+            const result = await this.sendRequest({ method, params }, token);
+            allItems = allItems.concat(getItems(result));
+            nextCursor = result.nextCursor;
+        } while (nextCursor !== undefined && !token.isCancellationRequested);
+        return allItems;
+    }
+    sendNotification(notification) {
+        this.send({ ...notification, jsonrpc: MCP.JSONRPC_VERSION });
+    }
+    handleMessage(message) {
+        if (canLog(this.logger.getLevel(), LogLevel.Debug)) {
+            this.logger.debug(`[server <- editor] ${JSON.stringify(message)}`);
+        }
+        if ('id' in message) {
+            if ('result' in message) {
+                this.handleResult(message);
+            }
+            else if ('error' in message) {
+                this.handleError(message);
+            }
+        }
+        if ('method' in message) {
+            if ('id' in message) {
+                this.handleServerRequest(message);
+            }
+            else {
+                this.handleServerNotification(message);
+            }
+        }
+    }
+    handleResult(response) {
+        const request = this._pendingRequests.get(response.id);
+        if (request) {
+            this._pendingRequests.delete(response.id);
+            request.promise.complete(response.result);
+        }
+    }
+    handleError(response) {
+        const request = this._pendingRequests.get(response.id);
+        if (request) {
+            this._pendingRequests.delete(response.id);
+            request.promise.error(( new MpcResponseError(response.error.message, response.error.code, response.error.data)));
+        }
+    }
+    handleServerRequest(request) {
+        switch (request.method) {
+            case 'ping':
+                return this.respondToRequest(request, this.handlePing(request));
+            case 'roots/list':
+                return this.respondToRequest(request, this.handleRootsList(request));
+            default: {
+                const errorResponse = {
+                    jsonrpc: MCP.JSONRPC_VERSION,
+                    id: request.id,
+                    error: {
+                        code: MCP.METHOD_NOT_FOUND,
+                        message: `Method not found: ${request.method}`
+                    }
+                };
+                this.send(errorResponse);
+                break;
+            }
+        }
+    }
+    handleServerNotification(request) {
+        switch (request.method) {
+            case 'notifications/message':
+                return this.handleLoggingNotification(request);
+            case 'notifications/cancelled':
+                this._onDidReceiveCancelledNotification.fire(request);
+                return this.handleCancelledNotification(request);
+            case 'notifications/progress':
+                this._onDidReceiveProgressNotification.fire(request);
+                return;
+            case 'notifications/resources/list_changed':
+                this._onDidChangeResourceList.fire();
+                return;
+            case 'notifications/resources/updated':
+                this._onDidUpdateResource.fire(request);
+                return;
+            case 'notifications/tools/list_changed':
+                this._onDidChangeToolList.fire();
+                return;
+            case 'notifications/prompts/list_changed':
+                this._onDidChangePromptList.fire();
+                return;
+        }
+    }
+    handleCancelledNotification(request) {
+        const pendingRequest = this._pendingRequests.get(request.params.requestId);
+        if (pendingRequest) {
+            this._pendingRequests.delete(request.params.requestId);
+            pendingRequest.promise.cancel();
+        }
+    }
+    handleLoggingNotification(request) {
+        let contents = typeof request.params.data === 'string' ? request.params.data : JSON.stringify(request.params.data);
+        if (request.params.logger) {
+            contents = `${request.params.logger}: ${contents}`;
+        }
+        switch (request.params?.level) {
+            case 'debug':
+                this.logger.debug(contents);
+                break;
+            case 'info':
+            case 'notice':
+                this.logger.info(contents);
+                break;
+            case 'warning':
+                this.logger.warn(contents);
+                break;
+            case 'error':
+            case 'critical':
+            case 'alert':
+            case 'emergency':
+                this.logger.error(contents);
+                break;
+            default:
+                this.logger.info(contents);
+                break;
+        }
+    }
+    respondToRequest(request, result) {
+        const response = {
+            jsonrpc: MCP.JSONRPC_VERSION,
+            id: request.id,
+            result
+        };
+        this.send(response);
+    }
+    handlePing(_request) {
+        return {};
+    }
+    handleRootsList(_request) {
+        this._hasAnnouncedRoots = true;
+        return { roots: this._roots };
+    }
+    cancelAllRequests() {
+        this._pendingRequests.forEach(pending => pending.promise.cancel());
+        this._pendingRequests.clear();
+    }
+    dispose() {
+        this.cancelAllRequests();
+        super.dispose();
+    }
+    initialize(params, token) {
+        return this.sendRequest({ method: 'initialize', params }, token);
+    }
+    listResources(params, token) {
+        return this.sendRequestPaginated('resources/list', result => result.resources, params, token);
+    }
+    readResource(params, token) {
+        return this.sendRequest({ method: 'resources/read', params }, token);
+    }
+    listResourceTemplates(params, token) {
+        return this.sendRequestPaginated('resources/templates/list', result => result.resourceTemplates, params, token);
+    }
+    subscribe(params, token) {
+        return this.sendRequest({ method: 'resources/subscribe', params }, token);
+    }
+    unsubscribe(params, token) {
+        return this.sendRequest({ method: 'resources/unsubscribe', params }, token);
+    }
+    listPrompts(params, token) {
+        return this.sendRequestPaginated('prompts/list', result => result.prompts, params, token);
+    }
+    getPrompt(params, token) {
+        return this.sendRequest({ method: 'prompts/get', params }, token);
+    }
+    listTools(params, token) {
+        return this.sendRequestPaginated('tools/list', result => result.tools, params, token);
+    }
+    callTool(params, token) {
+        return this.sendRequest({ method: 'tools/call', params }, token);
+    }
+    setLevel(params, token) {
+        return this.sendRequest({ method: 'logging/setLevel', params }, token);
+    }
+    complete(params, token) {
+        return this.sendRequest({ method: 'completion/complete', params }, token);
+    }
+}
+
+export { McpServerRequestHandler };

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

@@ -0,0 +1,27 @@
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { McpServerMetadataCache } from "./mcpServer.js";
+import { IMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+export declare class McpService extends Disposable implements IMcpService {
+    private readonly _instantiationService;
+    private readonly _mcpRegistry;
+    private readonly _toolsService;
+    private readonly _logService;
+    _serviceBrand: undefined;
+    private readonly _servers;
+    readonly servers: IObservable<readonly IMcpServer[]>;
+    get lazyCollectionState(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes").LazyCollectionState>;
+    protected readonly userCache: McpServerMetadataCache;
+    protected readonly workspaceCache: McpServerMetadataCache;
+    constructor(_instantiationService: IInstantiationService, _mcpRegistry: IMcpRegistry, _toolsService: ILanguageModelToolsService, _logService: ILogService);
+    resetCaches(): void;
+    activateCollections(): Promise<void>;
+    private _syncTools;
+    private _updateCollectedServers;
+    dispose(): void;
+}