@codingame/monaco-vscode-mcp-service-override 28.4.1 → 29.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-mcp-service-override",
-  "version": "28.4.1",
+  "version": "29.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - mcp service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "28.4.1"
+    "@codingame/monaco-vscode-api": "29.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/base/common/jsonRpcProtocol.d.ts

@@ -28,6 +28,7 @@ export interface IJsonRpcErrorResponse {
     error: IJsonRpcError;
 }
 export type JsonRpcMessage = IJsonRpcRequest | IJsonRpcNotification | IJsonRpcSuccessResponse | IJsonRpcErrorResponse;
+export type JsonRpcResponse = IJsonRpcSuccessResponse | IJsonRpcErrorResponse;
 export interface IJsonRpcProtocolHandlers {
     handleRequest?(request: IJsonRpcRequest, token: CancellationToken): Promise<unknown> | unknown;
     handleNotification?(notification: IJsonRpcNotification): void;
@@ -51,7 +52,18 @@ export declare class JsonRpcProtocol extends Disposable {
     constructor(_send: (message: JsonRpcMessage) => void, _handlers: IJsonRpcProtocolHandlers);
     sendNotification(notification: Omit<IJsonRpcNotification, "jsonrpc">): void;
     sendRequest<T = unknown>(request: Omit<IJsonRpcRequest, "jsonrpc" | "id">, token?: CancellationToken, onCancel?: (id: JsonRpcId) => void): Promise<T>;
-    handleMessage(message: JsonRpcMessage | JsonRpcMessage[]): Promise<void>;
+    /**
+     * Handles one or more incoming JSON-RPC messages.
+     *
+     * Returns an array of JSON-RPC response objects generated for any incoming
+     * requests in the message(s). Notifications and responses to our own
+     * outgoing requests do not produce return values. For batch inputs, the
+     * returned responses are in the same order as the corresponding requests.
+     *
+     * Note: responses are also emitted via the `_send` callback, so callers
+     * that rely on the return value should not re-send them.
+     */
+    handleMessage(message: JsonRpcMessage | JsonRpcMessage[]): Promise<JsonRpcResponse[]>;
     cancelPendingRequest(id: JsonRpcId): void;
     cancelAllRequests(): void;
     private _handleMessage;

package/vscode/src/vs/base/common/jsonRpcProtocol.js

@@ -68,12 +68,17 @@ class JsonRpcProtocol extends Disposable {
     }
     async handleMessage(message) {
         if (Array.isArray(message)) {
+            const replies = [];
             for (const single of message) {
-                await this._handleMessage(single);
+                const reply = await this._handleMessage(single);
+                if (reply) {
+                    replies.push(reply);
+                }
             }
-            return;
+            return replies;
         }
-        await this._handleMessage(message);
+        const reply = await this._handleMessage(message);
+        return reply ? [reply] : [];
     }
     cancelPendingRequest(id) {
         const request = this._pendingRequests.get(id);
@@ -101,13 +106,15 @@ class JsonRpcProtocol extends Disposable {
             } else {
                 this._handleError(message);
             }
+            return undefined;
         }
         if (isJsonRpcRequest(message)) {
-            await this._handleRequest(message);
+            return this._handleRequest(message);
         }
         if (isJsonRpcNotification(message)) {
             this._handlers.handleNotification?.(message);
         }
+        return undefined;
     }
     _handleResult(response) {
         const request = this._pendingRequests.get(response.id);
@@ -130,29 +137,33 @@ class JsonRpcProtocol extends Disposable {
     }
     async _handleRequest(request) {
         if (!this._handlers.handleRequest) {
-            this._send({
+            const response = {
                 jsonrpc: "2.0",
                 id: request.id,
                 error: {
                     code: JsonRpcProtocol.MethodNotFound,
                     message: `Method not found: ${request.method}`
                 }
-            });
-            return;
+            };
+            this._send(response);
+            return response;
         }
         const cts = ( new CancellationTokenSource());
         this._register(toDisposable(() => cts.dispose(true)));
         try {
             const resultOrThenable = this._handlers.handleRequest(request, cts.token);
             const result = isThenable(resultOrThenable) ? await resultOrThenable : resultOrThenable;
-            this._send({
+            const response = {
                 jsonrpc: "2.0",
                 id: request.id,
                 result
-            });
+            };
+            this._send(response);
+            return response;
         } catch (error) {
+            let response;
             if (error instanceof JsonRpcError) {
-                this._send({
+                response = {
                     jsonrpc: "2.0",
                     id: request.id,
                     error: {
@@ -160,17 +171,19 @@ class JsonRpcProtocol extends Disposable {
                         message: error.message,
                         data: error.data
                     }
-                });
+                };
             } else {
-                this._send({
+                response = {
                     jsonrpc: "2.0",
                     id: request.id,
                     error: {
                         code: JsonRpcProtocol.InternalError,
                         message: error instanceof Error ? error.message : "Internal error"
                     }
-                });
+                };
             }
+            this._send(response);
+            return response;
         } finally {
             cts.dispose(true);
         }

package/vscode/src/vs/platform/mcp/common/allowedMcpServersService.js

@@ -27,7 +27,7 @@ let AllowedMcpServersService = class AllowedMcpServersService extends Disposable
             query: `@id:${mcpAccessConfig}`
         }).toString());
         return (new MarkdownString(localize(
-            2035,
+            2040,
             "Model Context Protocol servers are disabled in the Editor. Please check your [settings]({0}).",
             settingsCommandLink
         )));

package/vscode/src/vs/platform/mcp/common/mcpGalleryManifestService.js

@@ -108,7 +108,8 @@ let McpGalleryManifestService = class McpGalleryManifestService extends Disposab
         try {
             const context = await this.requestService.request({
                 type: "GET",
-                url: `${url}/${version}/servers?limit=1`
+                url: `${url}/${version}/servers?limit=1`,
+                callSite: "mcpGalleryManifestService.checkVersion"
             }, CancellationToken.None);
             if (isSuccess(context)) {
                 return true;

package/vscode/src/vs/platform/mcp/common/mcpGalleryService.js

@@ -456,7 +456,7 @@ let McpGalleryService = class McpGalleryService extends Disposable {
     async getReadme(gallery, token) {
         const readmeUrl = gallery.readmeUrl;
         if (!readmeUrl) {
-            return Promise.resolve(( localize(2036, "No README available")));
+            return Promise.resolve(( localize(2041, "No README available")));
         }
         const uri = ( URI.parse(readmeUrl));
         if (uri.scheme === Schemas.file) {
@@ -468,11 +468,12 @@ let McpGalleryService = class McpGalleryService extends Disposable {
             }
         }
         if (uri.authority !== "raw.githubusercontent.com") {
-            return ( new MarkdownString(( localize(2037, "You can find information about this server [here]({0})", readmeUrl)))).value;
+            return ( new MarkdownString(( localize(2042, "You can find information about this server [here]({0})", readmeUrl)))).value;
         }
         const context = await this.requestService.request({
             type: "GET",
-            url: readmeUrl
+            url: readmeUrl,
+            callSite: "mcpGalleryService.getReadme"
         }, token);
         const result = await asText(context);
         if (!result) {
@@ -597,7 +598,8 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         }
         const context = await this.requestService.request({
             type: "GET",
-            url
+            url,
+            callSite: "mcpGalleryService.queryMcpServers"
         }, token);
         const data = await asJson(context);
         if (!data) {
@@ -617,7 +619,8 @@ let McpGalleryService = class McpGalleryService extends Disposable {
     async getMcpServer(mcpServerUrl, mcpGalleryManifest) {
         const context = await this.requestService.request({
             type: "GET",
-            url: mcpServerUrl
+            url: mcpServerUrl,
+            callSite: "mcpGalleryService.getMcpServer"
         }, CancellationToken.None);
         if (context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500) {
             return undefined;

package/vscode/src/vs/platform/mcp/common/mcpGateway.d.ts

@@ -3,37 +3,68 @@ import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { MCP } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/modelContextProtocol";
 export declare const McpGatewayChannelName = "mcpGateway";
 export declare const McpGatewayToolBrokerChannelName = "mcpGatewayToolBroker";
-export interface IGatewayCallToolResult {
-    result: MCP.CallToolResult;
-    serverIndex: number;
+/**
+ * Descriptor for an MCP server known to the gateway.
+ */
+export interface IMcpGatewayServerDescriptor {
+    readonly id: string;
+    readonly label: string;
 }
-export interface IGatewayServerResources {
-    serverIndex: number;
-    resources: readonly MCP.Resource[];
+/**
+ * A single server entry exposed by the gateway.
+ */
+export interface IMcpGatewayServerInfo {
+    readonly label: string;
+    readonly address: URI;
 }
-export interface IGatewayServerResourceTemplates {
-    serverIndex: number;
-    resourceTemplates: readonly MCP.ResourceTemplate[];
+/**
+ * Per-server tool invoker used by a single gateway route/session.
+ * All methods operate on the specific server this invoker is bound to.
+ */
+export interface IMcpGatewaySingleServerInvoker {
+    readonly onDidChangeTools: Event<void>;
+    readonly onDidChangeResources: Event<void>;
+    listTools(): Promise<readonly MCP.Tool[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<MCP.CallToolResult>;
+    listResources(): Promise<readonly MCP.Resource[]>;
+    readResource(uri: string): Promise<MCP.ReadResourceResult>;
+    listResourceTemplates(): Promise<readonly MCP.ResourceTemplate[]>;
 }
+/**
+ * Aggregating tool invoker that provides per-server operations and
+ * server lifecycle tracking. Used by the gateway service to create
+ * and manage per-server routes.
+ */
 export interface IMcpGatewayToolInvoker {
+    readonly onDidChangeServers: Event<readonly IMcpGatewayServerDescriptor[]>;
     readonly onDidChangeTools: Event<void>;
     readonly onDidChangeResources: Event<void>;
-    listTools(): Promise<readonly MCP.Tool[]>;
-    callTool(name: string, args: Record<string, unknown>): Promise<IGatewayCallToolResult>;
-    listResources(): Promise<readonly IGatewayServerResources[]>;
-    readResource(serverIndex: number, uri: string): Promise<MCP.ReadResourceResult>;
-    listResourceTemplates(): Promise<readonly IGatewayServerResourceTemplates[]>;
+    listServers(): readonly IMcpGatewayServerDescriptor[];
+    listToolsForServer(serverId: string): Promise<readonly MCP.Tool[]>;
+    callToolForServer(serverId: string, name: string, args: Record<string, unknown>): Promise<MCP.CallToolResult>;
+    listResourcesForServer(serverId: string): Promise<readonly MCP.Resource[]>;
+    readResourceForServer(serverId: string, uri: string): Promise<MCP.ReadResourceResult>;
+    listResourceTemplatesForServer(serverId: string): Promise<readonly MCP.ResourceTemplate[]>;
 }
 /**
- * Result of creating an MCP gateway.
+ * Serializable result of creating an MCP gateway (safe for IPC).
  */
-export interface IMcpGatewayInfo {
+export interface IMcpGatewayDto {
     /**
-     * The address of the HTTP endpoint for this gateway.
+     * The servers currently exposed by this gateway.
      */
-    readonly address: URI;
+    readonly servers: readonly IMcpGatewayServerInfo[];
     /**
      * The unique identifier for this gateway, used for disposal.
      */
     readonly gatewayId: string;
 }
+/**
+ * Result of creating an MCP gateway (in-process, includes event).
+ */
+export interface IMcpGatewayInfo extends IMcpGatewayDto {
+    /**
+     * Event that fires when the set of servers changes.
+     */
+    readonly onDidChangeServers: Event<readonly IMcpGatewayServerInfo[]>;
+}

package/vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.js

@@ -115,16 +115,16 @@ registerWorkbenchContribution2(
 const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
 jsonRegistry.registerSchema(mcpSchemaId, mcpServerSchema);
 ( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
-    EditorPaneDescriptor.create(McpServerEditor, McpServerEditor.ID, ( localize(10094, "MCP Server"))),
+    EditorPaneDescriptor.create(McpServerEditor, McpServerEditor.ID, ( localize(10329, "MCP Server"))),
     [( new SyncDescriptor(McpServerEditorInput))]
 );
 ( Registry.as(Extensions$1.Quickaccess)).registerQuickAccessProvider({
     ctor: McpResourceQuickAccess,
     prefix: McpResourceQuickAccess.PREFIX,
     when: ChatContextKeys.enabled,
-    placeholder: ( localize(10095, "Filter to an MCP resource")),
+    placeholder: ( localize(10330, "Filter to an MCP resource")),
     helpEntries: [{
-        description: ( localize(10096, "MCP Server Resources")),
+        description: ( localize(10331, "MCP Server Resources")),
         commandId: McpCommandIds.AddConfiguration
     }]
 });

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpAddContextContribution.js

@@ -43,7 +43,7 @@ let McpAddContextContribution = class McpAddContextContribution extends Disposab
     _registerAddContextMenu() {
         this._addContextMenu.value = this._chatContextPickService.registerChatContextItem({
             type: "pickerPick",
-            label: ( localize(10097, "MCP Resources...")),
+            label: ( localize(10332, "MCP Resources...")),
             icon: Codicon.mcp,
             isEnabled(widget) {
                 return !!widget.attachmentCapabilities.supportsMCPAttachments;
@@ -51,7 +51,7 @@ let McpAddContextContribution = class McpAddContextContribution extends Disposab
             asPicker: () => {
                 const helper = this._instantiationService.createInstance(McpResourcePickHelper);
                 return {
-                    placeholder: ( localize(10098, "Select MCP Resource...")),
+                    placeholder: ( localize(10333, "Select MCP Resource...")),
                     picks: (_query, token) => this._getResourcePicks(token, helper),
                     goBack: () => {
                         return helper.navigateBack();