@codingame/monaco-vscode-api 17.2.1 → 18.0.0

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

@@ -1,10 +1,18 @@
 
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { equals } from '../../../../base/common/arrays.js';
 import { assertNever } from '../../../../base/common/assert.js';
+import { encodeHex, VSBuffer, decodeHex } from '../../../../base/common/buffer.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
 import { equals as equals$1 } from '../../../../base/common/objects.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { IMcpWorkbenchService } from './mcpTypes.service.js';
+import { MCP } from './modelContextProtocol.js';
 
 const extensionMcpCollectionPrefix = 'ext.';
 function extensionPrefixedIdentifier(identifier, id) {
@@ -51,7 +59,8 @@ var McpServerDefinition;
             && equals(a.roots, b.roots, (a, b) => ( a.toString()) === ( b.toString()))
             && equals$1(a.launch, b.launch)
             && equals$1(a.presentation, b.presentation)
-            && equals$1(a.variableReplacement, b.variableReplacement);
+            && equals$1(a.variableReplacement, b.variableReplacement)
+            && equals$1(a.devMode, b.devMode);
     }
     McpServerDefinition.equals = equals$2;
 })(McpServerDefinition || (McpServerDefinition = {}));
@@ -76,15 +85,20 @@ var LazyCollectionState;
     LazyCollectionState[LazyCollectionState["LoadingUnknown"] = 1] = "LoadingUnknown";
     LazyCollectionState[LazyCollectionState["AllKnown"] = 2] = "AllKnown";
 })(LazyCollectionState || (LazyCollectionState = {}));
-var McpServerToolsState;
-(function (McpServerToolsState) {
-    McpServerToolsState[McpServerToolsState["Unknown"] = 0] = "Unknown";
-    McpServerToolsState[McpServerToolsState["Cached"] = 1] = "Cached";
-    McpServerToolsState[McpServerToolsState["Outdated"] = 2] = "Outdated";
-    McpServerToolsState[McpServerToolsState["RefreshingFromUnknown"] = 3] = "RefreshingFromUnknown";
-    McpServerToolsState[McpServerToolsState["RefreshingFromCached"] = 4] = "RefreshingFromCached";
-    McpServerToolsState[McpServerToolsState["Live"] = 5] = "Live";
-})(McpServerToolsState || (McpServerToolsState = {}));
+const isMcpResourceTemplate = (obj) => {
+    return obj.template !== undefined;
+};
+var McpServerCacheState;
+(function (McpServerCacheState) {
+    McpServerCacheState[McpServerCacheState["Unknown"] = 0] = "Unknown";
+    McpServerCacheState[McpServerCacheState["Cached"] = 1] = "Cached";
+    McpServerCacheState[McpServerCacheState["Outdated"] = 2] = "Outdated";
+    McpServerCacheState[McpServerCacheState["RefreshingFromUnknown"] = 3] = "RefreshingFromUnknown";
+    McpServerCacheState[McpServerCacheState["RefreshingFromCached"] = 4] = "RefreshingFromCached";
+    McpServerCacheState[McpServerCacheState["Live"] = 5] = "Live";
+})(McpServerCacheState || (McpServerCacheState = {}));
+const mcpPromptReplaceSpecialChars = (s) => s.replace(/[^a-z0-9_.-]/gi, '_');
+const mcpPromptPrefix = (definition) => `/mcp.` + mcpPromptReplaceSpecialChars(definition.label);
 var McpServerTransportType;
 (function (McpServerTransportType) {
     McpServerTransportType[McpServerTransportType["Stdio"] = 1] = "Stdio";
@@ -103,7 +117,7 @@ var McpServerLaunch;
             case McpServerTransportType.Stdio:
                 return {
                     type: launch.type,
-                    cwd: launch.cwd ? URI.revive(launch.cwd) : undefined,
+                    cwd: launch.cwd,
                     command: launch.command,
                     args: launch.args,
                     env: launch.env,
@@ -125,13 +139,13 @@ var McpConnectionState;
     McpConnectionState.toString = (s) => {
         switch (s.state) {
             case Kind.Stopped:
-                return localize(7759, 'Stopped');
+                return localize(7986, 'Stopped');
             case Kind.Starting:
-                return localize(7760, 'Starting');
+                return localize(7987, 'Starting');
             case Kind.Running:
-                return localize(7761, 'Running');
+                return localize(7988, 'Running');
             case Kind.Error:
-                return localize(7762, 'Error {0}', s.message);
+                return localize(7989, 'Error {0}', s.message);
             default:
                 assertNever();
         }
@@ -162,5 +176,107 @@ class MpcResponseError extends Error {
 }
 class McpConnectionFailedError extends Error {
 }
+let McpServerContainers = class McpServerContainers extends Disposable {
+    constructor(containers, mcpWorkbenchService) {
+        super();
+        this.containers = containers;
+        this._register(mcpWorkbenchService.onChange(this.update, this));
+    }
+    set mcpServer(extension) {
+        this.containers.forEach(c => c.mcpServer = extension);
+    }
+    update(server) {
+        for (const container of this.containers) {
+            if (server && container.mcpServer) {
+                if (server.name === container.mcpServer.name) {
+                    container.mcpServer = server;
+                }
+            }
+            else {
+                container.update();
+            }
+        }
+    }
+};
+McpServerContainers = ( __decorate([
+    ( __param(1, IMcpWorkbenchService))
+], McpServerContainers));
+const McpServersGalleryEnabledContext = ( new RawContextKey('mcpServersGalleryEnabled', false));
+const HasInstalledMcpServersContext = ( new RawContextKey('hasInstalledMcpServers', false));
+const InstalledMcpServersViewId = 'workbench.views.mcp.installed';
+const mcpServerIcon = registerIcon('mcp-server', Codicon.mcp, ( localize(7990, 'Icon used for the MCP server.')));
+var McpResourceURI;
+(function (McpResourceURI) {
+    McpResourceURI.scheme = 'mcp-resource';
+    function fromServer(def, resourceURI) {
+        if (typeof resourceURI === 'string') {
+            resourceURI = ( URI.parse(resourceURI));
+        }
+        return resourceURI.with({
+            scheme: McpResourceURI.scheme,
+            authority: encodeHex(VSBuffer.fromString(def.id)),
+            path: ['', resourceURI.scheme, resourceURI.authority].join('/') + resourceURI.path,
+        });
+    }
+    McpResourceURI.fromServer = fromServer;
+    function toServer(uri) {
+        if (typeof uri === 'string') {
+            uri = ( URI.parse(uri));
+        }
+        if (uri.scheme !== McpResourceURI.scheme) {
+            throw ( new Error(`Invalid MCP resource URI: ${( uri.toString())}`));
+        }
+        const parts = uri.path.split('/');
+        if (parts.length < 3) {
+            throw ( new Error(`Invalid MCP resource URI: ${( uri.toString())}`));
+        }
+        const [, serverScheme, authority, ...path] = parts;
+        return {
+            definitionId: ( decodeHex(uri.authority).toString()),
+            resourceURI: uri.with({
+                scheme: serverScheme,
+                authority,
+                path: '/' + path.join('/'),
+            }),
+        };
+    }
+    McpResourceURI.toServer = toServer;
+})(McpResourceURI || (McpResourceURI = {}));
+var McpCapability;
+(function (McpCapability) {
+    McpCapability[McpCapability["Logging"] = 1] = "Logging";
+    McpCapability[McpCapability["Completions"] = 2] = "Completions";
+    McpCapability[McpCapability["Prompts"] = 4] = "Prompts";
+    McpCapability[McpCapability["PromptsListChanged"] = 8] = "PromptsListChanged";
+    McpCapability[McpCapability["Resources"] = 16] = "Resources";
+    McpCapability[McpCapability["ResourcesSubscribe"] = 32] = "ResourcesSubscribe";
+    McpCapability[McpCapability["ResourcesListChanged"] = 64] = "ResourcesListChanged";
+    McpCapability[McpCapability["Tools"] = 128] = "Tools";
+    McpCapability[McpCapability["ToolsListChanged"] = 256] = "ToolsListChanged";
+})(McpCapability || (McpCapability = {}));
+class McpError extends Error {
+    static methodNotFound(method) {
+        return ( new McpError(MCP.METHOD_NOT_FOUND, `Method not found: ${method}`));
+    }
+    static notAllowed() {
+        return ( new McpError(-32e3, 'The user has denied permission to call this method.'));
+    }
+    static unknown(e) {
+        const mcpError = ( new McpError(MCP.INTERNAL_ERROR, `Unknown error: ${e.stack}`));
+        mcpError.cause = e;
+        return mcpError;
+    }
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+var McpToolName;
+(function (McpToolName) {
+    McpToolName["Prefix"] = "mcp_";
+    McpToolName[McpToolName["MaxPrefixLen"] = 18] = "MaxPrefixLen";
+    McpToolName[McpToolName["MaxLength"] = 64] = "MaxLength";
+})(McpToolName || (McpToolName = {}));
 
-export { LazyCollectionState, McpCollectionDefinition, McpCollectionSortOrder, McpConnectionFailedError, McpConnectionState, McpServerDefinition, McpServerDefinitionVariableReplacement, McpServerLaunch, McpServerToolsState, McpServerTransportType, MpcResponseError, extensionMcpCollectionPrefix, extensionPrefixedIdentifier };
+export { HasInstalledMcpServersContext, InstalledMcpServersViewId, LazyCollectionState, McpCapability, McpCollectionDefinition, McpCollectionSortOrder, McpConnectionFailedError, McpConnectionState, McpError, McpResourceURI, McpServerCacheState, McpServerContainers, McpServerDefinition, McpServerDefinitionVariableReplacement, McpServerLaunch, McpServerTransportType, McpServersGalleryEnabledContext, McpToolName, MpcResponseError, extensionMcpCollectionPrefix, extensionPrefixedIdentifier, isMcpResourceTemplate, mcpPromptPrefix, mcpPromptReplaceSpecialChars, mcpServerIcon };

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

@@ -1,5 +1,10 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { Event } from "../../../../base/common/event.js";
 import { IObservable } from "../../../../base/common/observable.js";
-import { IMcpServer, LazyCollectionState } from "./mcpTypes.js";
+import { IEditorOptions } from "../../../../platform/editor/common/editor.js";
+import { IQueryOptions } from "@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/platform/mcp/common/mcpManagement";
+import { IMcpServerSamplingConfiguration } from "@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration";
+import { IMcpServer, LazyCollectionState, type ISamplingOptions, type ISamplingResult, type IWorkbenchMcpServer } from "./mcpTypes.js";
 export declare const IMcpService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMcpService>;
 export interface IMcpService {
     _serviceBrand: undefined;
@@ -8,3 +13,23 @@ export interface IMcpService {
     readonly lazyCollectionState: IObservable<LazyCollectionState>;
     activateCollections(): Promise<void>;
 }
+export declare const IMcpWorkbenchService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMcpWorkbenchService>;
+export interface IMcpWorkbenchService {
+    readonly _serviceBrand: undefined;
+    readonly onChange: Event<IWorkbenchMcpServer | undefined>;
+    readonly local: readonly IWorkbenchMcpServer[];
+    queryLocal(): Promise<IWorkbenchMcpServer[]>;
+    queryGallery(options?: IQueryOptions, token?: CancellationToken): Promise<IWorkbenchMcpServer[]>;
+    install(mcpServer: IWorkbenchMcpServer): Promise<void>;
+    uninstall(mcpServer: IWorkbenchMcpServer): Promise<void>;
+    open(extension: IWorkbenchMcpServer | string, options?: IEditorOptions): Promise<void>;
+}
+export interface IMcpSamplingService {
+    _serviceBrand: undefined;
+    sample(opts: ISamplingOptions): Promise<ISamplingResult>;
+    hasLogs(server: IMcpServer): boolean;
+    getLogText(server: IMcpServer): string;
+    getConfig(server: IMcpServer): IMcpServerSamplingConfiguration;
+    updateConfig(server: IMcpServer, mutate: (r: IMcpServerSamplingConfiguration) => unknown): Promise<IMcpServerSamplingConfiguration>;
+}
+export declare const IMcpSamplingService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMcpSamplingService>;

package/vscode/src/vs/workbench/contrib/mcp/common/mcpTypes.service.js

@@ -2,5 +2,7 @@
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 
 const IMcpService = ( createDecorator('IMcpService'));
+const IMcpWorkbenchService = ( createDecorator('IMcpWorkbenchService'));
+const IMcpSamplingService = ( createDecorator('IMcpServerSampling'));
 
-export { IMcpService };
+export { IMcpSamplingService, IMcpService, IMcpWorkbenchService };

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

@@ -0,0 +1,404 @@
+export declare namespace MCP {
+    interface CompleteRequest2 extends MCP.CompleteRequest {
+        params: MCP.CompleteRequest["params"] & {
+            resolved?: {
+                [key: string]: string;
+            };
+        };
+    }
+}
+export declare namespace MCP {
+    type JSONRPCMessage = JSONRPCRequest | JSONRPCNotification | JSONRPCBatchRequest | JSONRPCResponse | JSONRPCError | JSONRPCBatchResponse;
+    type JSONRPCBatchRequest = (JSONRPCRequest | JSONRPCNotification)[];
+    type JSONRPCBatchResponse = (JSONRPCResponse | JSONRPCError)[];
+    const LATEST_PROTOCOL_VERSION = "2025-03-26";
+    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;
+        completions?: 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;
+            message?: string;
+        };
+    }
+    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 {
+        uri: string;
+        name: string;
+        description?: string;
+        mimeType?: string;
+        annotations?: Annotations;
+        size?: number;
+    }
+    interface ResourceTemplate {
+        uriTemplate: string;
+        name: string;
+        description?: string;
+        mimeType?: string;
+        annotations?: Annotations;
+    }
+    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 | AudioContent | EmbeddedResource;
+    }
+    interface EmbeddedResource {
+        type: "resource";
+        resource: TextResourceContents | BlobResourceContents;
+        annotations?: Annotations;
+    }
+    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 | AudioContent | 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 ToolAnnotations {
+        title?: string;
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }
+    interface Tool {
+        name: string;
+        description?: string;
+        inputSchema: {
+            type: "object";
+            properties?: {
+                [key: string]: object;
+            };
+            required?: string[];
+        };
+        annotations?: ToolAnnotations;
+    }
+    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 | AudioContent;
+    }
+    interface Annotations {
+        audience?: Role[];
+        priority?: number;
+    }
+    interface TextContent {
+        type: "text";
+        text: string;
+        annotations?: Annotations;
+    }
+    interface ImageContent {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: Annotations;
+    }
+    interface AudioContent {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: Annotations;
+    }
+    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 = "2025-03-26";
+    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 };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service.d.ts

@@ -3,7 +3,7 @@ import { CodeWindow } from "../../../../../base/browser/window.js";
 import { Event } from "../../../../../base/common/event.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { type ServicesAccessor } from "../../../../../platform/instantiation/common/instantiation.js";
-import { INotebookEditorCreationOptions, INotebookEditor } from "@codingame/monaco-vscode-324f9a6e-6231-5bfc-af17-e147abd2dfd2-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { INotebookEditorCreationOptions, INotebookEditor } from "@codingame/monaco-vscode-4372ad43-a220-5e78-83e6-95a9cfd64384-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
 import { NotebookEditorWidget } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget";
 import { IBorrowValue } from "./notebookEditorService.js";
 export declare const INotebookEditorService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<INotebookEditorService>;