@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/runtime-mcp/manager-pool.test.ts

@@ -1,11 +1,33 @@
 import { expect, test, vi } from "bun:test";
 import { rm } from "node:fs/promises";
+import { legacyMcpMethodNotFound } from "../../test/mcp-test-utils";
 import * as configValue from "../config/resolve-config-value";
 import { MCPManager } from "./manager";
 import { MCPConnectionPool } from "./pool";
 import { computeMCPPoolKey } from "./pool-key";
+import type { MCPProtocolObservation } from "./protocol";
+import { legacyEraObservation } from "./protocol";
 import type { MCPRequestOptions, MCPServerConfig, MCPServerConnection, MCPTransport } from "./types";
 
+/** Fake connections model pre-v2 stdio servers: legacy era, forced by transport. */
+function fakeLegacyProtocol(capabilities: {
+	tools?: unknown;
+	resources?: unknown;
+	prompts?: unknown;
+}): MCPProtocolObservation {
+	return legacyEraObservation({
+		preference: "auto",
+		effectiveVersion: "2025-03-26",
+		negotiation: "legacy-forced",
+		downgradeReason: "stdio-transport",
+		serverInfo: { name: "fake", version: "1" },
+		capabilities: {
+			tools: capabilities.tools !== undefined,
+			resources: capabilities.resources !== undefined,
+			prompts: capabilities.prompts !== undefined,
+		},
+	});
+}
 class ManagerFakeTransport implements MCPTransport {
 	connected = true;
 	closeCount = 0;
@@ -136,6 +158,7 @@ test("withPreparedLease admission closes before disconnectAll snapshots scoped o
 				transport: new ManagerFakeTransport(),
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			}) satisfies MCPServerConnection,
 	});
 	const manager = new MCPManager(".", null, { pool, sessionId: "admission-disconnect" });
@@ -157,6 +180,7 @@ test("withPreparedLease admission closes during reconnect before fresh entry exi
 				transport: new ManagerFakeTransport(),
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			}) satisfies MCPServerConnection,
 	});
 	const manager = new MCPManager(".", null, { pool, sessionId: "admission-reconnect" });
@@ -182,6 +206,7 @@ test("manager connection lifecycle is owned by pool leases", async () => {
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -207,6 +232,7 @@ test("manager resolves one canonical stdio cwd for transport and pool identity",
 				transport: new ManagerFakeTransport(),
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -240,6 +266,7 @@ test("manager resource subscriptions flow through the lease aggregate", async ()
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {}, resources: { subscribe: true } },
+				protocol: fakeLegacyProtocol({ tools: {}, resources: { subscribe: true } }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -285,6 +312,7 @@ test("disconnectAll cancels hanging config resolution before opening a lease", a
 				transport: new ManagerFakeTransport(),
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			}) satisfies MCPServerConnection,
 	});
 	const manager = new MCPManager(".", null, { pool, sessionId: "config-hang" });
@@ -313,6 +341,7 @@ test("caller abort after acquisition releases a hanging prepared lease", async (
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -346,6 +375,7 @@ test("disconnectAll releases an active prepared lease and settles its callback",
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -375,6 +405,7 @@ test("disconnectAll aggregates active transient release failures", async () => {
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -403,6 +434,7 @@ test("transient lease does not replace the manager-owned lease mapping", async (
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -436,6 +468,7 @@ test("prepared transient operations acquire and release through the pool", async
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -460,6 +493,7 @@ test("reconnect retires held transient leases before opening a fresh physical co
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -507,6 +541,7 @@ test("shutdown closes retired and replacement physical entries after HTTP-style
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -541,6 +576,7 @@ test("successful HTTP-style rotations remove settled retired-release records whi
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -582,6 +618,7 @@ test("manager disconnectAll aggregates a rejecting retired HTTP-style close", as
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -624,6 +661,7 @@ test("reconnect uses the exact backoff schedule and coalesces concurrent request
 				transport: new ManagerFakeTransport(),
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -661,6 +699,7 @@ test("disconnectAll reports typed lease-release failures after clearing all stat
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -680,6 +719,7 @@ test("manager lease advertises its canonical roots through the pool", async () =
 				transport: new ManagerFakeTransport(),
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			}) satisfies MCPServerConnection,
 	});
 	const manager = new MCPManager(".", null, { pool, sessionId: "roots-session" });
@@ -708,6 +748,7 @@ test("per-session manager facades remain isolated while shared tools-only facade
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -757,6 +798,7 @@ test("shared prompt execution stays lease-bound while one manager releases", asy
 				transport,
 				serverInfo: { name: "prompt", version: "1" },
 				capabilities: { tools: {}, resources: { subscribe: true }, prompts: {} },
+				protocol: fakeLegacyProtocol({ tools: {}, resources: { subscribe: true }, prompts: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -807,6 +849,7 @@ test("shared replacement is deferred across an unrelated reconnecting server", a
 				transport,
 				serverInfo: { name: "multi", version: String(generation) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -874,6 +917,7 @@ test("shared replacement rebind reconciles a lease acquired before a second rota
 				transport,
 				serverInfo: { name: "generation", version: String(generation) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -947,6 +991,7 @@ test("shared initial join reconciles a lease acquired before owner rotation", as
 				transport,
 				serverInfo: { name: "initial-join", version: String(generation) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1010,6 +1055,7 @@ test("initial join hook rejection releases the acquired lease", async () => {
 				transport,
 				serverInfo: { name: "hook-rejection", version: String(opens) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1060,6 +1106,7 @@ test("initial join retry failure clears pending state for a subsequent connect",
 				transport,
 				serverInfo: { name: "retry-failure", version: String(generation) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1136,6 +1183,7 @@ test("shared replacement is requeued when reconnect starts during acquisition",
 				transport,
 				serverInfo: { name: "inverse", version: String(generation) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1216,6 +1264,7 @@ test("queued shared replacement is dropped when teardown begins", async () => {
 				transport,
 				serverInfo: { name: "drop", version: String(generation) },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1263,6 +1312,7 @@ test("shared replacement rebind is fenced when peer disconnects during old-lease
 				transport,
 				serverInfo: { name: "race", version: String(opens) },
 				capabilities: { tools: {}, resources: { subscribe: true }, prompts: {} },
+				protocol: fakeLegacyProtocol({ tools: {}, resources: { subscribe: true }, prompts: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1316,6 +1366,7 @@ test("shared noReplay request failure coordinates one replacement without resend
 				transport,
 				serverInfo: { name: "recovery", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1358,6 +1409,7 @@ test("released shared facade tools fail live-state checks while surviving lease
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1401,6 +1453,7 @@ test("shared restart rebinds every surviving manager lease before subsequent cal
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1444,6 +1497,7 @@ test("shared transport crash has one restart owner across manager facades", asyn
 				transport,
 				serverInfo: { name: "fake", version: "1" },
 				capabilities: { tools: {} },
+				protocol: fakeLegacyProtocol({ tools: {} }),
 			} satisfies MCPServerConnection;
 		},
 	});
@@ -1510,6 +1564,7 @@ test("shared HTTP leases use one MCP session and one callback stream while relea
 				toolsListCount += 1;
 				return Response.json({ jsonrpc: "2.0", id: message.id, result: { tools: [] } });
 			}
+			if (message.method === "server/discover") return legacyMcpMethodNotFound(message.id);
 			return Response.json({ jsonrpc: "2.0", id: message.id, result: {} });
 		},
 	});
@@ -1576,6 +1631,7 @@ test("S7-style HTTP stub keeps distinct paths and queries on one host in separat
 			if (message.method === "notifications/initialized") return new Response(null, { status: 202 });
 			if (message.method === "tools/list")
 				return Response.json({ jsonrpc: "2.0", id: message.id, result: { tools: [] } });
+			if (message.method === "server/discover") return legacyMcpMethodNotFound(message.id);
 			return Response.json({ jsonrpc: "2.0", id: message.id, result: {} });
 		},
 	});

package/src/runtime-mcp/manager.ts

@@ -33,12 +33,14 @@ import {
 	MCPPoolLeaseObsoleteError,
 	MCPPoolLeaseReleaseError,
 } from "./pool";
+import type { MCPProtocolObservation } from "./protocol";
 import type { MCPToolDetails } from "./tool-bridge";
 import { DeferredMCPTool, MCPTool } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
 import { HttpTransport } from "./transports/http";
 import type {
 	MCPGetPromptResult,
+	MCPInputRequestHandler,
 	MCPPrompt,
 	MCPRequestOptions,
 	MCPResource,
@@ -252,6 +254,12 @@ export interface MCPDiscoverOptions {
 	filterBrowser?: boolean;
 	/** Only connect servers with autoload !== false (default: false) */
 	autoloadOnly?: boolean;
+	/**
+	 * Restrict discovery to GJC's native `.gjc` scopes (user + project).
+	 * Runtime MCP authority for GJC sessions; Claude Code/Codex files are
+	 * explicit import sources into `.gjc`, not implicit runtime authorities.
+	 */
+	nativeOnly?: boolean;
 	/** Called when starting to connect to servers */
 	onConnecting?: (serverNames: string[]) => void;
 	/** Load only this explicit MCP config file. */
@@ -323,6 +331,7 @@ export class MCPManager {
 	#pendingToolLoads = new Map<string, Promise<ToolLoadResult>>();
 	#sources = new Map<string, SourceMeta>();
 	#authStorage: AuthStorage | null = null;
+	#inputRequestHandler: MCPInputRequestHandler | null = null;
 	#onNotification?: (serverName: string, method: string, params: unknown) => void;
 	#onToolsChanged?: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void;
 	#onResourcesChanged?: (serverName: string, uri: string) => void;
@@ -862,6 +871,16 @@ export class MCPManager {
 		this.#authStorage = authStorage;
 	}
 
+	/**
+	 * Register the handler for modern MRTR `input_required` results (structured
+	 * elicitation/roots/sampling input requests). Runtimes with an interactive
+	 * question surface (e.g. ACP `elicitation/create`) register here; without a
+	 * handler, `input_required` fails explicitly instead of hanging.
+	 */
+	setInputRequestHandler(handler: MCPInputRequestHandler | null): void {
+		this.#inputRequestHandler = handler;
+	}
+
 	/**
 	 * Discover and connect to all MCP servers from .mcp.json files.
 	 * Returns tools and any connection errors.
@@ -885,6 +904,7 @@ export class MCPManager {
 			filterExa: options?.filterExa,
 			filterBrowser: options?.filterBrowser,
 			autoloadOnly: options?.autoloadOnly,
+			nativeOnly: options?.nativeOnly,
 			configPath: options?.configPath,
 		});
 		const result = await this.#connectServers(configs, sources, options?.onConnecting);
@@ -1093,6 +1113,7 @@ export class MCPManager {
 					const reconnect = () => this.reconnectServer(name);
 					const customTools = MCPTool.fromTools(this.#connectionForLease(connection), serverTools, reconnect, {
 						noReplay: config.sharing === "shared",
+						inputHandler: () => this.#inputRequestHandler ?? undefined,
 					});
 					this.#replaceServerTools(name, customTools);
 					if (!this.#toolsOnly) this.#onToolsChanged?.(this.#tools);
@@ -1207,6 +1228,7 @@ export class MCPManager {
 						allTools.push(
 							...MCPTool.fromTools(this.#connectionForLease(connection), serverTools, reconnect, {
 								noReplay: task.config.sharing === "shared",
+								inputHandler: () => this.#inputRequestHandler ?? undefined,
 							}),
 						);
 					} catch (error) {
@@ -1239,7 +1261,10 @@ export class MCPManager {
 									() => this.#waitForConnection(name).then(connection => this.#connectionForLease(connection)),
 									source,
 									reconnect,
-									{ noReplay: task.config.sharing === "shared" },
+									{
+										noReplay: task.config.sharing === "shared",
+										inputHandler: () => this.#inputRequestHandler ?? undefined,
+									},
 								),
 							);
 						} catch (error) {
@@ -1379,6 +1404,27 @@ export class MCPManager {
 		return "disconnected";
 	}
 
+	/**
+	 * Get the authoritative protocol observation for a connected server
+	 * (preference, negotiated era/version, downgrade decision, deprecation state).
+	 * Secret-free; the single observation model consumed by customization doctor
+	 * (#4288) and /extensions (#4291). Returns undefined when not connected.
+	 */
+	getProtocolObservation(name: string): MCPProtocolObservation | undefined {
+		return this.#connections.get(name)?.protocol;
+	}
+
+	/**
+	 * Snapshot of protocol observations for all connected servers.
+	 */
+	getProtocolObservations(): ReadonlyMap<string, MCPProtocolObservation> {
+		const snapshot = new Map<string, MCPProtocolObservation>();
+		for (const [name, connection] of this.#connections) {
+			snapshot.set(name, connection.protocol);
+		}
+		return snapshot;
+	}
+
 	/**
 	 * Get the source metadata for a server.
 	 */
@@ -1947,6 +1993,7 @@ export class MCPManager {
 			const reconnect = () => this.reconnectServer(name);
 			const customTools = MCPTool.fromTools(this.#connectionForLease(connection), serverTools, reconnect, {
 				noReplay: config.sharing === "shared",
+				inputHandler: () => this.#inputRequestHandler ?? undefined,
 			});
 			void this.toolCache?.set(name, config, serverTools);
 			this.#replaceServerTools(name, customTools);
@@ -2002,8 +2049,10 @@ export class MCPManager {
 		const globalEpoch = this.#epoch;
 		const disconnectEpoch = this.#disconnectEpochs.get(name) ?? 0;
 
-		// Clear cached tools
+		// Clear cached tools and any server-supplied freshness hints
 		connection.tools = undefined;
+		connection.toolsFreshUntil = undefined;
+		connection.toolsCacheScope = undefined;
 
 		// Reload tools
 		const facade = this.#connectionForLease(connection);
@@ -2012,6 +2061,7 @@ export class MCPManager {
 		const reconnect = () => this.reconnectServer(name);
 		const customTools = MCPTool.fromTools(facade, serverTools, reconnect, {
 			noReplay: connection.config.sharing === "shared",
+			inputHandler: () => this.#inputRequestHandler ?? undefined,
 		});
 		void this.toolCache?.set(name, connection.config, serverTools);
 

package/src/runtime-mcp/oauth-discovery.ts

@@ -12,6 +12,10 @@ export interface OAuthEndpoints {
 	tokenUrl: string;
 	clientId?: string;
 	scopes?: string;
+	/** Issuer recorded from the validated metadata document (RFC 9207). */
+	issuer?: string;
+	/** `authorization_response_iss_parameter_supported` from the same metadata. */
+	authorizationResponseIssSupported?: boolean;
 }
 
 export interface AuthDetectionResult {
@@ -413,6 +417,15 @@ export async function discoverOAuthEndpoints(
 								...endpoints,
 								authorizationUrl: authorization.url.toString(),
 								tokenUrl: token.url.toString(),
+								// RFC 9207 (MCP 2026-07-28): record the issuer from this validated
+								// metadata document so the authorization response can be checked.
+								...(issuer ? { issuer } : {}),
+								...(typeof metadata.authorization_response_iss_parameter_supported === "boolean"
+									? {
+											authorizationResponseIssSupported:
+												metadata.authorization_response_iss_parameter_supported,
+										}
+									: {}),
 							};
 						}
 					}

package/src/runtime-mcp/oauth-flow.ts

@@ -95,15 +95,39 @@ function resolveCallbackOptions(config: MCPOAuthConfig): OAuthCallbackFlowOption
 		callbackHostname: resolveCallbackHostname(redirectUri),
 		callbackBindHostname: CALLBACK_BIND_HOSTNAME,
 		redirectUri,
+		...(config.issuer ? { expectedIssuer: config.issuer } : {}),
+		...(config.issuerResponseIssSupported !== undefined
+			? { issuerResponseIssSupported: config.issuerResponseIssSupported }
+			: {}),
 	};
 }
 
+/**
+ * Canonical MCP server resource URI per RFC 8707 §2: absolute URI, lowercase
+ * scheme/host, no fragment, no trailing slash on an empty path.
+ */
+export function canonicalMCPResourceUri(raw: string): string | undefined {
+	try {
+		const url = new URL(raw);
+		if (url.hash) url.hash = "";
+		const serialized = url.toString();
+		return url.pathname === "/" && serialized.endsWith("/") ? serialized.slice(0, -1) : serialized;
+	} catch {
+		return undefined;
+	}
+}
+
 export interface MCPOAuthConfig {
 	/** Authorization endpoint URL */
 	authorizationUrl: string;
 	/** Token endpoint URL */
 	tokenUrl: string;
-	/** Client ID (optional when already embedded in authorization URL) */
+	/**
+	 * Client ID (optional when already embedded in authorization URL). An
+	 * HTTPS URL here is a Client ID Metadata Document (CIMD) reference per
+	 * MCP 2026-07-28 and is used as-is; Dynamic Client Registration is only a
+	 * deprecated backwards-compatibility fallback when no client id exists.
+	 */
 	clientId?: string;
 	/** Client secret (optional for PKCE flows) */
 	clientSecret?: string;
@@ -115,6 +139,19 @@ export interface MCPOAuthConfig {
 	callbackPort?: number;
 	/** Custom callback path (default: /callback or redirectUri pathname) */
 	callbackPath?: string;
+	/**
+	 * Canonical URI of the target MCP server (RFC 8707). Sent as the `resource`
+	 * parameter on BOTH the authorization and token requests, regardless of
+	 * authorization-server support.
+	 */
+	resource?: string;
+	/**
+	 * Expected authorization-server issuer recorded from validated discovery
+	 * metadata (RFC 9207 / MCP 2026-07-28). Validation fails closed on mismatch.
+	 */
+	issuer?: string;
+	/** `authorization_response_iss_parameter_supported` from the same metadata. */
+	issuerResponseIssSupported?: boolean;
 }
 
 /**
@@ -174,6 +211,10 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		}
 		params.set("redirect_uri", redirectUri);
 		params.set("state", state);
+		// RFC 8707: the canonical MCP server resource MUST be on the authorization request.
+		if (this.config.resource && !params.get("resource")) {
+			params.set("resource", this.config.resource);
+		}
 
 		// Add PKCE challenge (some providers require it)
 		const codeVerifier = this.#generateCodeVerifier();
@@ -200,6 +241,10 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		if (this.#resolvedClientId) {
 			params.set("client_id", this.#resolvedClientId);
 		}
+		// RFC 8707: the canonical MCP server resource MUST be on the token request.
+		if (this.config.resource) {
+			params.set("resource", this.config.resource);
+		}
 
 		// Add code verifier for PKCE
 		if (this.#codeVerifier) {

package/src/runtime-mcp/pool-key.ts

@@ -2,6 +2,7 @@
 import { createHash } from "node:crypto";
 import { realpathSync } from "node:fs";
 import * as path from "node:path";
+import { resolveMCPProtocolPreference } from "./protocol";
 import type { MCPServerConfig } from "./types";
 
 export type MCPPoolSharingMode = "per-session" | "shared";
@@ -67,6 +68,8 @@ export interface MCPPoolKeyIdentity {
 	authScopeId: string;
 	pluginNetworkPolicyId: string;
 	capabilityProfile: MCPPoolCapabilityProfile;
+	/** Resolved protocol preference (auto | 2026-07-28 | legacy); partitions protocol generations. */
+	protocolPreference: string;
 	sessionId?: string;
 }
 
@@ -262,10 +265,11 @@ export function buildMCPPoolKeyIdentity(
 	}
 	const headers = headerIdentity(source, options, auth.kind, auth.scope);
 	const identity: MCPPoolKeyIdentity = {
-		schemaVersion: 1,
+		schemaVersion: 2,
 		serverName,
 		sharingMode,
 		transport,
+		protocolPreference: resolveMCPProtocolPreference(source.protocol),
 		command: source.type === "http" || source.type === "sse" ? "" : source.command,
 		argsNormalized: source.type === "http" || source.type === "sse" ? [] : [...(source.args ?? [])],
 		effectiveCwdRealpath: effectiveCwd(config, options),

package/src/runtime-mcp/pool.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { MCPConnectionPool, MCPPoolAcquireAbortError, MCPPoolLeaseInvalidatedError } from "./pool";
 import { MCPPoolConfigError } from "./pool-key";
+import { legacyEraObservation } from "./protocol";
 import type { MCPRequestOptions, MCPServerConfig, MCPServerConnection, MCPTransport } from "./types";
 import { MCPExpectedFailure, MCPNotificationMethods } from "./types";
 
@@ -103,6 +104,14 @@ function connection(name: string, configValue: MCPServerConfig, transport: FakeT
 		transport,
 		serverInfo: { name: "fake", version: "1" },
 		capabilities: { tools: {}, resources: { subscribe: true } },
+		protocol: legacyEraObservation({
+			preference: "auto",
+			effectiveVersion: "2025-03-26",
+			negotiation: "legacy-forced",
+			downgradeReason: "stdio-transport",
+			serverInfo: { name: "fake", version: "1" },
+			capabilities: { tools: true, resources: true },
+		}),
 	};
 }