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

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

@@ -0,0 +1,220 @@
+
+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 { 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 { 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';
+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 { 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 { 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';
+import { observableValue, transaction } 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 McpService = class McpService extends Disposable {
+    get lazyCollectionState() { return this._mcpRegistry.lazyCollectionState; }
+    constructor(_instantiationService, _mcpRegistry, _toolsService, _logService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._mcpRegistry = _mcpRegistry;
+        this._toolsService = _toolsService;
+        this._logService = _logService;
+        this._servers = observableValue(this, []);
+        this.servers = ( this._servers.map(servers => ( servers.map(s => s.object))));
+        this.userCache = this._register(_instantiationService.createInstance(McpServerMetadataCache, StorageScope.PROFILE));
+        this.workspaceCache = this._register(_instantiationService.createInstance(McpServerMetadataCache, StorageScope.WORKSPACE));
+        const updateThrottle = this._store.add(( new RunOnceScheduler(() => this._updateCollectedServers(), 500)));
+        this._register(autorun(reader => {
+            for (const collection of this._mcpRegistry.collections.read(reader)) {
+                collection.serverDefinitions.read(reader);
+            }
+            updateThrottle.schedule(500);
+        }));
+    }
+    resetCaches() {
+        this.userCache.reset();
+        this.workspaceCache.reset();
+    }
+    async activateCollections() {
+        const collections = await this._mcpRegistry.discoverCollections();
+        const collectionIds = ( new Set(( collections.map(c => c.id))));
+        this._updateCollectedServers();
+        const todo = [];
+        for (const { object: server } of this._servers.get()) {
+            if (( collectionIds.has(server.collection.id))) {
+                const state = server.toolsState.get();
+                if (state === McpServerToolsState.Unknown) {
+                    todo.push(server.start());
+                }
+            }
+        }
+        await Promise.all(todo);
+    }
+    _syncTools(server, store) {
+        const tools = ( new Map());
+        store.add(autorun(reader => {
+            const toDelete = ( new Set(( tools.keys())));
+            for (const tool of server.tools.read(reader)) {
+                const existing = tools.get(tool.id);
+                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 },
+                    icon: Codicon.tools,
+                    displayName: tool.definition.name,
+                    toolReferenceName: tool.definition.name,
+                    modelDescription: tool.definition.description ?? '',
+                    userDescription: tool.definition.description ?? '',
+                    inputSchema: tool.definition.inputSchema,
+                    canBeReferencedInPrompt: true,
+                    supportsToolPicker: true,
+                    runsInWorkspace: collection?.scope === StorageScope.WORKSPACE || !!collection?.remoteAuthority,
+                    tags: ['mcp'],
+                };
+                if (existing) {
+                    if (!equals(existing.toolData, toolData)) {
+                        existing.toolData = toolData;
+                        existing.toolDispose.dispose();
+                        existing.toolDispose = this._toolsService.registerToolData(toolData);
+                    }
+                    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)),
+                    });
+                }
+            }
+            for (const id of toDelete) {
+                const tool = tools.get(id);
+                if (tool) {
+                    tool.toolDispose.dispose();
+                    tool.implDispose.dispose();
+                    tools.delete(id);
+                }
+            }
+        }));
+        store.add(toDisposable(() => {
+            for (const tool of ( tools.values())) {
+                tool.toolDispose.dispose();
+                tool.implDispose.dispose();
+            }
+        }));
+    }
+    _updateCollectedServers() {
+        const definitions = this._mcpRegistry.collections.get().flatMap(collectionDefinition => ( collectionDefinition.serverDefinitions.get().map(serverDefinition => ({
+            serverDefinition,
+            collectionDefinition,
+        }))));
+        const nextDefinitions = ( new Set(definitions));
+        const currentServers = this._servers.get();
+        const nextServers = [];
+        const pushMatch = (match, rec) => {
+            nextDefinitions.delete(match);
+            nextServers.push(rec);
+            const connection = rec.object.connection.get();
+            if (connection && !McpServerDefinition.equals(connection.definition, match.serverDefinition)) {
+                rec.object.stop();
+                this._logService.debug(`MCP server ${rec.object.definition.id} stopped because the definition changed`);
+            }
+        };
+        for (const server of currentServers) {
+            const match = definitions.find(d => defsEqual(server.object, d));
+            if (match) {
+                pushMatch(match, server);
+            }
+            else {
+                server.dispose();
+            }
+        }
+        for (const def of nextDefinitions) {
+            const store = ( new DisposableStore());
+            const object = this._instantiationService.createInstance(McpServer, def.collectionDefinition, def.serverDefinition, def.serverDefinition.roots, !!def.collectionDefinition.lazy, def.collectionDefinition.scope === StorageScope.WORKSPACE ? this.workspaceCache : this.userCache);
+            store.add(object);
+            this._syncTools(object, store);
+            nextServers.push({ object, dispose: () => store.dispose() });
+        }
+        transaction(tx => {
+            this._servers.set(nextServers, tx);
+        });
+    }
+    dispose() {
+        this._servers.get().forEach(s => s.dispose());
+        super.dispose();
+    }
+};
+McpService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IMcpRegistry)),
+    ( __param(2, ILanguageModelToolsService)),
+    ( __param(3, ILogService))
+], McpService));
+function defsEqual(server, def) {
+    return server.collection.id === def.collectionDefinition.id && server.definition.id === def.serverDefinition.id;
+}
+let McpToolImplementation = class McpToolImplementation {
+    constructor(_tool, _server, _productService) {
+        this._tool = _tool;
+        this._server = _server;
+        this._productService = _productService;
+    }
+    async prepareToolInvocation(parameters) {
+        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.",
+            '$(info)',
+            server.definition.label,
+            this._productService.nameShort
+        ));
+        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 })),
+                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)))),
+            toolSpecificData: {
+                kind: 'input',
+                rawInput: parameters
+            }
+        };
+    }
+    async invoke(invocation, _countTokens, token) {
+        const result = {
+            content: []
+        };
+        const outputParts = [];
+        const callResult = await this._tool.call(invocation.parameters, token);
+        for (const item of callResult.content) {
+            if (item.type === 'text') {
+                result.content.push({
+                    kind: 'text',
+                    value: item.text
+                });
+                outputParts.push(item.text);
+            }
+        }
+        result.toolResultDetails = {
+            input: JSON.stringify(invocation.parameters, undefined, 2),
+            output: outputParts.join('\n')
+        };
+        return result;
+    }
+};
+McpToolImplementation = ( __decorate([
+    ( __param(2, IProductService))
+], McpToolImplementation));
+
+export { McpService };

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

@@ -0,0 +1,374 @@
+export declare namespace MCP {
+    type JSONRPCMessage = JSONRPCRequest | JSONRPCNotification | JSONRPCResponse | JSONRPCError;
+    const LATEST_PROTOCOL_VERSION = "2024-11-05";
+    const JSONRPC_VERSION = "2.0";
+    type ProgressToken = string | number;
+    type Cursor = string;
+    interface Request {
+        method: string;
+        params?: {
+            _meta?: {
+                progressToken?: ProgressToken;
+            };
+            [key: string]: unknown;
+        };
+    }
+    interface Notification {
+        method: string;
+        params?: {
+            _meta?: {
+                [key: string]: unknown;
+            };
+            [key: string]: unknown;
+        };
+    }
+    interface Result {
+        _meta?: {
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    }
+    type RequestId = string | number;
+    interface JSONRPCRequest extends Request {
+        jsonrpc: typeof JSONRPC_VERSION;
+        id: RequestId;
+    }
+    interface JSONRPCNotification extends Notification {
+        jsonrpc: typeof JSONRPC_VERSION;
+    }
+    interface JSONRPCResponse {
+        jsonrpc: typeof JSONRPC_VERSION;
+        id: RequestId;
+        result: Result;
+    }
+    const PARSE_ERROR = -32700;
+    const INVALID_REQUEST = -32600;
+    const METHOD_NOT_FOUND = -32601;
+    const INVALID_PARAMS = -32602;
+    const INTERNAL_ERROR = -32603;
+    interface JSONRPCError {
+        jsonrpc: typeof JSONRPC_VERSION;
+        id: RequestId;
+        error: {
+            code: number;
+            message: string;
+            data?: unknown;
+        };
+    }
+    type EmptyResult = Result;
+    interface CancelledNotification extends Notification {
+        method: "notifications/cancelled";
+        params: {
+            requestId: RequestId;
+            reason?: string;
+        };
+    }
+    interface InitializeRequest extends Request {
+        method: "initialize";
+        params: {
+            protocolVersion: string;
+            capabilities: ClientCapabilities;
+            clientInfo: Implementation;
+        };
+    }
+    interface InitializeResult extends Result {
+        protocolVersion: string;
+        capabilities: ServerCapabilities;
+        serverInfo: Implementation;
+        instructions?: string;
+    }
+    interface InitializedNotification extends Notification {
+        method: "notifications/initialized";
+    }
+    interface ClientCapabilities {
+        experimental?: {
+            [key: string]: object;
+        };
+        roots?: {
+            listChanged?: boolean;
+        };
+        sampling?: object;
+    }
+    interface ServerCapabilities {
+        experimental?: {
+            [key: string]: object;
+        };
+        logging?: object;
+        prompts?: {
+            listChanged?: boolean;
+        };
+        resources?: {
+            subscribe?: boolean;
+            listChanged?: boolean;
+        };
+        tools?: {
+            listChanged?: boolean;
+        };
+    }
+    interface Implementation {
+        name: string;
+        version: string;
+    }
+    interface PingRequest extends Request {
+        method: "ping";
+    }
+    interface ProgressNotification extends Notification {
+        method: "notifications/progress";
+        params: {
+            progressToken: ProgressToken;
+            progress: number;
+            total?: number;
+        };
+    }
+    interface PaginatedRequest extends Request {
+        params?: {
+            cursor?: Cursor;
+        };
+    }
+    interface PaginatedResult extends Result {
+        nextCursor?: Cursor;
+    }
+    interface ListResourcesRequest extends PaginatedRequest {
+        method: "resources/list";
+    }
+    interface ListResourcesResult extends PaginatedResult {
+        resources: Resource[];
+    }
+    interface ListResourceTemplatesRequest extends PaginatedRequest {
+        method: "resources/templates/list";
+    }
+    interface ListResourceTemplatesResult extends PaginatedResult {
+        resourceTemplates: ResourceTemplate[];
+    }
+    interface ReadResourceRequest extends Request {
+        method: "resources/read";
+        params: {
+            uri: string;
+        };
+    }
+    interface ReadResourceResult extends Result {
+        contents: (TextResourceContents | BlobResourceContents)[];
+    }
+    interface ResourceListChangedNotification extends Notification {
+        method: "notifications/resources/list_changed";
+    }
+    interface SubscribeRequest extends Request {
+        method: "resources/subscribe";
+        params: {
+            uri: string;
+        };
+    }
+    interface UnsubscribeRequest extends Request {
+        method: "resources/unsubscribe";
+        params: {
+            uri: string;
+        };
+    }
+    interface ResourceUpdatedNotification extends Notification {
+        method: "notifications/resources/updated";
+        params: {
+            uri: string;
+        };
+    }
+    interface Resource extends Annotated {
+        uri: string;
+        name: string;
+        description?: string;
+        mimeType?: string;
+        size?: number;
+    }
+    interface ResourceTemplate extends Annotated {
+        uriTemplate: string;
+        name: string;
+        description?: string;
+        mimeType?: string;
+    }
+    interface ResourceContents {
+        uri: string;
+        mimeType?: string;
+    }
+    interface TextResourceContents extends ResourceContents {
+        text: string;
+    }
+    interface BlobResourceContents extends ResourceContents {
+        blob: string;
+    }
+    interface ListPromptsRequest extends PaginatedRequest {
+        method: "prompts/list";
+    }
+    interface ListPromptsResult extends PaginatedResult {
+        prompts: Prompt[];
+    }
+    interface GetPromptRequest extends Request {
+        method: "prompts/get";
+        params: {
+            name: string;
+            arguments?: {
+                [key: string]: string;
+            };
+        };
+    }
+    interface GetPromptResult extends Result {
+        description?: string;
+        messages: PromptMessage[];
+    }
+    interface Prompt {
+        name: string;
+        description?: string;
+        arguments?: PromptArgument[];
+    }
+    interface PromptArgument {
+        name: string;
+        description?: string;
+        required?: boolean;
+    }
+    type Role = "user" | "assistant";
+    interface PromptMessage {
+        role: Role;
+        content: TextContent | ImageContent | EmbeddedResource;
+    }
+    interface EmbeddedResource extends Annotated {
+        type: "resource";
+        resource: TextResourceContents | BlobResourceContents;
+    }
+    interface PromptListChangedNotification extends Notification {
+        method: "notifications/prompts/list_changed";
+    }
+    interface ListToolsRequest extends PaginatedRequest {
+        method: "tools/list";
+    }
+    interface ListToolsResult extends PaginatedResult {
+        tools: Tool[];
+    }
+    interface CallToolResult extends Result {
+        content: (TextContent | ImageContent | EmbeddedResource)[];
+        isError?: boolean;
+    }
+    interface CallToolRequest extends Request {
+        method: "tools/call";
+        params: {
+            name: string;
+            arguments?: {
+                [key: string]: unknown;
+            };
+        };
+    }
+    interface ToolListChangedNotification extends Notification {
+        method: "notifications/tools/list_changed";
+    }
+    interface Tool {
+        name: string;
+        description?: string;
+        inputSchema: {
+            type: "object";
+            properties?: {
+                [key: string]: object;
+            };
+            required?: string[];
+        };
+    }
+    interface SetLevelRequest extends Request {
+        method: "logging/setLevel";
+        params: {
+            level: LoggingLevel;
+        };
+    }
+    interface LoggingMessageNotification extends Notification {
+        method: "notifications/message";
+        params: {
+            level: LoggingLevel;
+            logger?: string;
+            data: unknown;
+        };
+    }
+    type LoggingLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+    interface CreateMessageRequest extends Request {
+        method: "sampling/createMessage";
+        params: {
+            messages: SamplingMessage[];
+            modelPreferences?: ModelPreferences;
+            systemPrompt?: string;
+            includeContext?: "none" | "thisServer" | "allServers";
+            temperature?: number;
+            maxTokens: number;
+            stopSequences?: string[];
+            metadata?: object;
+        };
+    }
+    interface CreateMessageResult extends Result, SamplingMessage {
+        model: string;
+        stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string;
+    }
+    interface SamplingMessage {
+        role: Role;
+        content: TextContent | ImageContent;
+    }
+    interface Annotated {
+        annotations?: {
+            audience?: Role[];
+            priority?: number;
+        };
+    }
+    interface TextContent extends Annotated {
+        type: "text";
+        text: string;
+    }
+    interface ImageContent extends Annotated {
+        type: "image";
+        data: string;
+        mimeType: string;
+    }
+    interface ModelPreferences {
+        hints?: ModelHint[];
+        costPriority?: number;
+        speedPriority?: number;
+        intelligencePriority?: number;
+    }
+    interface ModelHint {
+        name?: string;
+    }
+    interface CompleteRequest extends Request {
+        method: "completion/complete";
+        params: {
+            ref: PromptReference | ResourceReference;
+            argument: {
+                name: string;
+                value: string;
+            };
+        };
+    }
+    interface CompleteResult extends Result {
+        completion: {
+            values: string[];
+            total?: number;
+            hasMore?: boolean;
+        };
+    }
+    interface ResourceReference {
+        type: "ref/resource";
+        uri: string;
+    }
+    interface PromptReference {
+        type: "ref/prompt";
+        name: string;
+    }
+    interface ListRootsRequest extends Request {
+        method: "roots/list";
+    }
+    interface ListRootsResult extends Result {
+        roots: Root[];
+    }
+    interface Root {
+        uri: string;
+        name?: string;
+    }
+    interface RootsListChangedNotification extends Notification {
+        method: "notifications/roots/list_changed";
+    }
+    type ClientRequest = PingRequest | InitializeRequest | CompleteRequest | SetLevelRequest | GetPromptRequest | ListPromptsRequest | ListResourcesRequest | ListResourceTemplatesRequest | ReadResourceRequest | SubscribeRequest | UnsubscribeRequest | CallToolRequest | ListToolsRequest;
+    type ClientNotification = CancelledNotification | ProgressNotification | InitializedNotification | RootsListChangedNotification;
+    type ClientResult = EmptyResult | CreateMessageResult | ListRootsResult;
+    type ServerRequest = PingRequest | CreateMessageRequest | ListRootsRequest;
+    type ServerNotification = CancelledNotification | ProgressNotification | LoggingMessageNotification | ResourceUpdatedNotification | ResourceListChangedNotification | ToolListChangedNotification | PromptListChangedNotification;
+    type ServerResult = EmptyResult | InitializeResult | CompleteResult | GetPromptResult | ListPromptsResult | ListResourcesResult | ListResourceTemplatesResult | ReadResourceResult | CallToolResult | ListToolsResult;
+}

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

@@ -0,0 +1,14 @@
+
+
+var MCP;
+(function (MCP) {
+    MCP.LATEST_PROTOCOL_VERSION = "2024-11-05";
+    MCP.JSONRPC_VERSION = "2.0";
+    MCP.PARSE_ERROR = -32700;
+    MCP.INVALID_REQUEST = -32600;
+    MCP.METHOD_NOT_FOUND = -32601;
+    MCP.INVALID_PARAMS = -32602;
+    MCP.INTERNAL_ERROR = -32603;
+})(MCP || (MCP = {}));
+
+export { MCP };