feat: enhance MCP gateway handling to support multiple servers and improve error logging (#4470)

* feat: enhance MCP gateway handling to support multiple servers and improve error logging

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Updates

* Updates

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

Author: DonJayamanne

package.json

@@ -4480,7 +4480,7 @@
 					},
 					"github.copilot.chat.cli.mcp.enabled": {
 						"type": "boolean",
-						"default": false,
+						"default": true,
 						"markdownDescription": "%github.copilot.config.cli.mcp.enabled%",
 						"tags": [
 							"advanced",
@@ -6267,5 +6267,5 @@
 		"node-gyp": "npm:node-gyp@10.3.1",
 		"zod": "3.25.76"
 	},
-	"vscodeCommit": "6f7de9c47ab13c3d886928c04c382d527c9bf11d"
+	"vscodeCommit": "6f5263699012243ac0e0b5f8381fcd86ff503b2b"
 }

src/extension/chatSessions/claude/node/claudeCodeAgent.ts

@@ -391,12 +391,20 @@ export class ClaudeCodeSession extends Disposable {
 		const mcpServers: Record<string, McpServerConfig> = await buildMcpServersFromRegistry(this.instantiationService) ?? {};
 
 		// Create or reuse the MCP gateway for this session
-		this._gateway ??= await this.mcpService.startMcpGateway(ClaudeSessionUri.forSessionId(this.sessionId)) ?? undefined;
-		if (this._gateway) {
-			mcpServers['vscode-mcp-gateway'] = {
-				type: 'http',
-				url: this._gateway.address.toString(),
-			};
+		try {
+			this._gateway ??= await this.mcpService.startMcpGateway(ClaudeSessionUri.forSessionId(this.sessionId)) ?? undefined;
+			if (this._gateway) {
+				for (const server of this._gateway.servers) {
+					const serverId = server.label.toLowerCase().replace(/[^a-z0-9_-]/g, '_').replace(/^_+|_+$/g, '') || `vscode-mcp-server-${Object.keys(mcpServers).length}`;
+					mcpServers[serverId] = {
+						type: 'http',
+						url: server.address.toString(),
+					};
+				}
+			}
+		} catch (error) {
+			const errorMessage = error instanceof Error ? (error.stack ?? error.message) : String(error);
+			this.logService.warn(`[ClaudeCodeSession] Failed to start MCP gateway: ${errorMessage}`);
 		}
 		const options: Options = {
 			cwd,

src/extension/chatSessions/copilotcli/node/mcpHandler.ts

@@ -73,15 +73,17 @@ export class CopilotCLIMCPHandler implements ICopilotCLIMCPHandler {
 			const gateway = await this.mcpService.startMcpGateway(URI.from({ scheme: 'copilot-cli', path: `mcp-gateway-${generateUuid()}` }));
 			if (gateway) {
 				disposable.add(gateway);
-				mcpConfig['vscode-mcp-gateway'] = {
-					type: 'http',
-					url: gateway.address.toString(),
-					isDefaultServer: true,
-					tools: ['*'],
-					displayName: 'VS Code MCP Gateway',
-				};
+				for (const server of gateway.servers) {
+					const serverId = this.normalizeServerName(server.label) ?? `vscode-mcp-server-${Object.keys(mcpConfig).length}`;
+					mcpConfig[serverId] = {
+						type: 'http',
+						url: server.address.toString(),
+						tools: ['*'],
+						displayName: server.label,
+					};
+				}
 				const serverIds = Object.keys(mcpConfig);
-				this.logService.trace(`[CopilotCLIMCPHandler]   gateway: ${gateway.address.toString()},  server(s): [${serverIds.join(', ')}]`);
+				this.logService.trace(`[CopilotCLIMCPHandler]   gateway started, server(s): [${serverIds.join(', ')}]`);
 			} else {
 				this.logService.warn('[CopilotCLIMCPHandler]   gateway failed to start');
 				disposable.dispose();

src/extension/vscode.proposed.chatSessionsProvider.d.ts

@@ -99,6 +99,8 @@ declare module 'vscode' {
 			readonly prompt: string;
 			readonly command?: string;
 		};
+
+		readonly sessionOptions: ReadonlyArray<{ optionId: string; value: string | ChatSessionProviderOptionItem }>;
 	}
 
 	/**
@@ -447,10 +449,13 @@ declare module 'vscode' {
 		 *
 		 * @param resource The URI of the chat session to resolve.
 		 * @param token A cancellation token that can be used to cancel the operation.
+		 * @param context Additional context for the chat session.
 		 *
 		 * @return The {@link ChatSession chat session} associated with the given URI.
 		 */
-		provideChatSessionContent(resource: Uri, token: CancellationToken): Thenable<ChatSession> | ChatSession;
+		provideChatSessionContent(resource: Uri, token: CancellationToken, context: {
+			readonly sessionOptions: ReadonlyArray<{ optionId: string; value: string | ChatSessionProviderOptionItem }>;
+		}): Thenable<ChatSession> | ChatSession;
 
 		/**
 		 * @param resource Identifier of the chat session being updated.
@@ -483,10 +488,11 @@ declare module 'vscode' {
 		 *
 		 * @param scheme The uri-scheme to register for. This must be unique.
 		 * @param provider The provider to register.
+		 * @param defaultChatParticipant The default {@link ChatParticipant chat participant} used in sessions provided by this provider.
 		 *
 		 * @returns A disposable that unregisters the provider when disposed.
 		 */
-		export function registerChatSessionContentProvider(scheme: string, provider: ChatSessionContentProvider, chatParticipant: ChatParticipant, capabilities?: ChatSessionCapabilities): Disposable;
+		export function registerChatSessionContentProvider(scheme: string, provider: ChatSessionContentProvider, defaultChatParticipant: ChatParticipant, capabilities?: ChatSessionCapabilities): Disposable;
 	}
 
 	export interface ChatContext {

src/extension/vscode.proposed.mcpServerDefinitions.d.ts

@@ -3,23 +3,47 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+// version: 1
+
 declare module 'vscode' {
 
 	// https://github.com/microsoft/vscode/issues/288777 @DonJayamanne
 
 	/**
-	 * Represents an MCP gateway that exposes MCP servers via HTTP.
-	 * The gateway provides an HTTP endpoint that external processes can connect
-	 * to in order to interact with MCP servers known to the editor.
+	 * Represents a single MCP server exposed by the gateway via its own HTTP endpoint.
 	 */
-	export interface McpGateway extends Disposable {
+	export interface McpGatewayServer {
+		/**
+		 * The human-readable label of the MCP server.
+		 */
+		readonly label: string;
+
 		/**
 		 * The address of the HTTP MCP server endpoint.
-		 * External processes can connect to this URI to interact with MCP servers.
+		 * External processes can connect to this URI to interact with this MCP server.
 		 */
 		readonly address: Uri;
 	}
 
+	/**
+	 * Represents an MCP gateway that exposes MCP servers via HTTP.
+	 * Each known MCP server gets its own HTTP endpoint. The gateway
+	 * dynamically tracks server additions and removals.
+	 */
+	export interface McpGateway extends Disposable {
+		/**
+		 * The MCP servers currently exposed by the gateway.
+		 * Each server has its own HTTP endpoint address.
+		 */
+		readonly servers: readonly McpGatewayServer[];
+
+		/**
+		 * Event that fires when the set of gateway servers changes.
+		 * This can be due to MCP servers being added, removed, or restarted.
+		 */
+		readonly onDidChangeServers: Event<readonly McpGatewayServer[]>;
+	}
+
 	/**
 	 * Namespace for language model related functionality.
 	 */
@@ -42,14 +66,16 @@ declare module 'vscode' {
 		export const onDidChangeMcpServerDefinitions: Event<void>;
 
 		/**
-		 * Starts an MCP gateway that exposes MCP servers via an HTTP endpoint.
+		 * Starts an MCP gateway that exposes MCP servers via HTTP endpoints.
 		 *
-		 * The gateway creates a localhost HTTP server that external processes (such as
-		 * CLI-based agent loops) can connect to in order to interact with MCP servers
-		 * that the editor knows about.
+		 * The gateway creates a localhost HTTP server where each MCP server known
+		 * to the editor gets its own endpoint. External processes (such as CLI-based
+		 * agent loops) can connect to these endpoints to interact with individual
+		 * MCP servers.
 		 *
 		 * The HTTP server is shared among all gateways and is automatically torn down
-		 * when the last gateway is disposed.
+		 * when the last gateway is disposed. The gateway dynamically tracks server
+		 * additions and removals via {@link McpGateway.onDidChangeServers}.
 		 *
 		 * @returns A promise that resolves to an {@link McpGateway} if successful,
 		 * or `undefined` if no Node process is available (e.g., in serverless web environments).

src/platform/configuration/common/configurationService.ts

@@ -610,7 +610,7 @@ export namespace ConfigKey {
 		export const CLICustomAgentsEnabled = defineAndMigrateSetting<boolean | undefined>('chat.advanced.cli.customAgents.enabled', 'chat.cli.customAgents.enabled', true);
 		export const CLIPlanModeEnabled = defineAndMigrateSetting<boolean | undefined>('chat.advanced.cli.planMode.enabled', 'chat.cli.planMode.enabled', false);
 		export const CLIPlanExitModeEnabled = defineSetting<boolean>('chat.cli.planExitMode.enabled', ConfigType.Simple, false);
-		export const CLIMCPServerEnabled = defineAndMigrateSetting<boolean | undefined>('chat.advanced.cli.mcp.enabled', 'chat.cli.mcp.enabled', false);
+		export const CLIMCPServerEnabled = defineAndMigrateSetting<boolean | undefined>('chat.advanced.cli.mcp.enabled', 'chat.cli.mcp.enabled', true);
 		export const CLIBranchSupport = defineSetting<boolean>('chat.cli.branchSupport.enabled', ConfigType.Simple, false);
 		export const CLIIsolationOption = defineSetting<boolean>('chat.cli.isolationOption.enabled', ConfigType.Simple, true);
 		export const CLICheckpointsEnabled = defineSetting<boolean>('chat.cli.checkpoints.enabled', ConfigType.Simple, false);

src/platform/mcp/vscode/mcpServiceImpl.ts

@@ -3,21 +3,25 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { McpGateway, Uri, lm } from 'vscode';
+import { McpGateway, McpGatewayServer, lm, type Event } from 'vscode';
 import { IDisposable } from '../../../util/vs/base/common/lifecycle';
 import { ResourceMap } from '../../../util/vs/base/common/map';
 import { URI } from '../../../util/vs/base/common/uri';
-import { AbstractMcpService } from '../common/mcpService';
 import { ILogService } from '../../log/common/logService';
+import { AbstractMcpService } from '../common/mcpService';
 
 class TrackedMcpGateway implements McpGateway {
 	constructor(
 		private readonly _gateway: McpGateway,
 		private readonly _onDispose: () => void
 	) { }
 
-	get address(): Uri {
-		return this._gateway.address;
+	get servers(): readonly McpGatewayServer[] {
+		return this._gateway.servers;
+	}
+
+	get onDidChangeServers(): Event<readonly McpGatewayServer[]> {
+		return this._gateway.onDidChangeServers;
 	}
 
 	dispose(): void {

src/platform/mcp/vscode/test/mcpService.spec.ts

@@ -24,7 +24,8 @@ import { McpService } from '../mcpServiceImpl';
 
 function createMockGateway() {
 	return {
-		address: { toString: () => 'http://localhost:1234' },
+		servers: [{ label: 'test-server', address: { toString: () => 'http://localhost:1234' } }],
+		onDidChangeServers: () => ({ dispose() { } }),
 		dispose: vi.fn(),
 	};
 }
@@ -53,7 +54,7 @@ describe('McpService', () => {
 		const result = await service.startMcpGateway(resource1);
 
 		expect(result).toBeDefined();
-		expect(result!.address).toBe(mockGateway.address);
+		expect(result!.servers).toBe(mockGateway.servers);
 		expect(mockStartMcpGateway).toHaveBeenCalledOnce();
 	});
 
@@ -122,7 +123,7 @@ describe('McpService', () => {
 
 		const second = await service.startMcpGateway(resource1);
 		expect(second).toBeDefined();
-		expect(second!.address).toBe(mockGateway.address);
+		expect(second!.servers).toBe(mockGateway.servers);
 	});
 
 	test('disposing a gateway removes it from tracking', async () => {