const require_chunk = require('./chunk-Bnu9O96Y.cjs');
const require_src = require('./src-DpAS0jfg.cjs');
let _modelcontextprotocol_client__shims = require("@modelcontextprotocol/client/_shims");
let pkce_challenge = require("pkce-challenge");
pkce_challenge = require_chunk.__toESM(pkce_challenge);
let eventsource = require("eventsource");
let eventsource_parser_stream = require("eventsource-parser/stream");
let _modelcontextprotocol_core_internal = require("@modelcontextprotocol/core/internal");

//#region src/client/authErrors.ts
/**
* Base class for the OAuth-client-flow error family. Concrete subclasses are
* added to this module alongside the SEP-2468/837/2207/2350/2352 behavior
* changes that throw them, so callers can catch the whole family with a single
* `instanceof OAuthClientFlowError` guard once those land.
*
* @remarks Nothing in the SDK throws this base class directly. In the release
* that introduces it no subclass exists yet — the guard is a forward-compat
* hook and will not match anything until the first behavior change ships.
*/
var OAuthClientFlowError = class extends Error {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.OAuthClientFlowError" });
	}
	static [Symbol.hasInstance](value) {
		return require_src.brandedHasInstance(this, value);
	}
	/**
	* Brand-based type guard: equivalent to `value instanceof this`, as an
	* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
	* the caller's own brand via `this`, so every branded subclass gets a
	* correctly-scoped guard by inheritance. Must be invoked on the class —
	* in callback position write `v => SdkError.isInstance(v)`, not
	* `.filter(SdkError.isInstance)` (detached calls throw rather than
	* silently matching nothing).
	*/
	static isInstance(value) {
		if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
		return require_src.brandedHasInstance(this, value);
	}
	constructor(message) {
		super(message);
		this.name = new.target.name;
		require_src.stampErrorBrands(this, new.target);
	}
};
/**
* Thrown when an authorization-server issuer identifier fails validation.
*
* Two checks raise this error, distinguished by {@linkcode IssuerMismatchError.kind | kind}:
* - `'metadata'` — the `issuer` in fetched authorization-server metadata does
*   not match the issuer identifier the well-known URL was constructed from
*   (RFC 8414 §3.3 / OpenID Connect Discovery §4.3).
* - `'authorization_response'` — the `iss` parameter on the authorization
*   callback failed RFC 9207 §2.4 validation against the recorded issuer.
*
* Intentionally does **not** extend `OAuthError`: the `auth()`
* orchestrator's `OAuthError` retry block must not swallow this — a mix-up
* indication is fatal for the flow, not a retryable credential problem.
*
* On the `'authorization_response'` path the {@linkcode IssuerMismatchError.received | received}
* value is attacker-controllable in a mix-up attack; callers **MUST NOT** display
* it (or any `error`/`error_description`/`error_uri` from the same callback) to
* end users. The values are JSON-encoded in the message to neutralize log-injection.
*/
var IssuerMismatchError = class extends OAuthClientFlowError {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.IssuerMismatchError" });
	}
	/** Which check failed — metadata echo (RFC 8414 §3.3) or authorization-response `iss` (RFC 9207). */
	kind;
	/** The issuer the client expected (from validated metadata / discovery input). */
	expected;
	/** The issuer value that was received. Attacker-controllable on the `'authorization_response'` path. */
	received;
	constructor(kind, expected, received) {
		super(`Issuer mismatch in ${kind === "metadata" ? "authorization server metadata (RFC 8414 §3.3)" : "authorization response (RFC 9207)"}: expected ${JSON.stringify(expected)}, received ${JSON.stringify(received)}`);
		this.kind = kind;
		this.expected = expected;
		this.received = received;
	}
};
/**
* Thrown by `registerClient()` when the authorization server rejects a
* Dynamic Client Registration request. Carries the HTTP status, the raw
* response body, and the metadata that was submitted, so callers can inspect
* the AS's `error` / `error_description` and retry with adjusted metadata
* (for example a different `application_type`) per SEP-837.
*
* The `body` is the raw RFC 7591 error JSON; compare `JSON.parse(body).error`
* against `OAuthErrorCode` (e.g. `OAuthErrorCode.InvalidRedirectUri`,
* `OAuthErrorCode.InvalidClientMetadata`).
*
* Intentionally does **not** extend `OAuthError`: registration rejection is
* not a recoverable-by-credential-invalidation condition, and staying outside
* that hierarchy keeps it from being caught by `auth()`'s `OAuthError` retry
* path.
*/
var RegistrationRejectedError = class extends OAuthClientFlowError {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.RegistrationRejectedError" });
	}
	/** HTTP status code returned by the registration endpoint. */
	status;
	/** Raw response body text (typically an RFC 7591 error JSON document). */
	body;
	/** The exact client metadata that was POSTed (after SDK defaults were applied). */
	submittedMetadata;
	constructor(args) {
		super(`Dynamic Client Registration rejected (HTTP ${args.status}): ${args.body}`);
		this.status = args.status;
		this.body = args.body;
		this.submittedMetadata = args.submittedMetadata;
	}
};
/**
* Thrown by the token-exchange and refresh paths when the resolved token
* endpoint is not `https:` and is not a loopback host. The MCP authorization
* specification requires authorization server endpoints to use HTTPS; loopback
* hosts are exempt here for local development. This is a configuration error —
* re-authorizing cannot fix it — so it intentionally does **not** extend
* `OAuthError` and `auth()`'s refresh branch rethrows it instead of falling
* through to a fresh `/authorize` redirect.
*/
var InsecureTokenEndpointError = class extends OAuthClientFlowError {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.InsecureTokenEndpointError" });
	}
	/** The token endpoint URL that was rejected. */
	tokenEndpoint;
	constructor(tokenEndpoint) {
		super(`Refusing to send credentials to non-https token endpoint '${tokenEndpoint}'. OAuth token requests MUST use TLS (localhost / *.localhost / 127.0.0.1 / ::1 are exempt).`);
		this.tokenEndpoint = tokenEndpoint;
	}
};
/**
* Thrown by the HTTP client transport when the server responds with
* `403 Forbidden` and `WWW-Authenticate: Bearer error="insufficient_scope"`,
* and either (a) the transport's `onInsufficientScope` option is `'throw'`, or
* (b) `onInsufficientScope` is the default `'reauthorize'` but the transport
* has no {@linkcode index.OAuthClientProvider | OAuthClientProvider} to drive
* step-up (e.g. a minimal `AuthProvider`, `requestInit`-only headers, or no
* `authProvider`).
*
* Carries the challenge parameters so the host can decide whether to initiate
* step-up authorization itself (e.g., behind a UX gate) or surface the error.
*
* Does **not** extend `OAuthError`: that class represents OAuth protocol errors
* from the authorization server; this is a resource-server challenge surfaced
* at the transport layer.
*
* All fields originate from the resource server's `WWW-Authenticate` header;
* treat them as untrusted input when displaying or logging (this includes
* `requiredScope`, which appears in the error message).
*/
/**
* Thrown by `auth()` and `fetchToken()` when the authorization server in use differs
* from the one a credential is bound to and the flow cannot simply start over:
*
* - on the authorization-code callback leg, when it differs from the one recorded
*   in `discoveryState()` at redirect time — the `authorization_code` and PKCE
*   `code_verifier` are bound to the AS that minted the code (RFC 7636);
* - for client information whose `issuer` stamp names a different authorization
*   server on a provider that cannot re-register (no `saveClientInformation()`,
*   e.g. the bundled static-credential providers); `fetchToken()` throws for any provider.
*
* Stored tokens and re-registrable client information are protected structurally
* by the `issuer` stamp instead (they read back as absent).
*/
var AuthorizationServerMismatchError = class extends OAuthClientFlowError {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.AuthorizationServerMismatchError" });
	}
	constructor(recordedIssuer, currentIssuer) {
		super(`Authorization server mismatch: credentials are bound to ${JSON.stringify(recordedIssuer)} but this call resolved ${JSON.stringify(currentIssuer)}; refusing to present them to a different authorization server`);
		this.recordedIssuer = recordedIssuer;
		this.currentIssuer = currentIssuer;
	}
};
var InsufficientScopeError = class extends OAuthClientFlowError {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.InsufficientScopeError" });
	}
	/** The `scope` value from the `WWW-Authenticate` challenge — the scopes the resource server says are required. */
	requiredScope;
	/** The `resource_metadata` URL from the `WWW-Authenticate` challenge, if present. */
	resourceMetadataUrl;
	/** The `error_description` from the `WWW-Authenticate` challenge, if present. */
	errorDescription;
	constructor(init) {
		super(`Insufficient scope${init.requiredScope ? `: required "${init.requiredScope}"` : ""}`);
		this.requiredScope = init.requiredScope;
		this.resourceMetadataUrl = init.resourceMetadataUrl;
		this.errorDescription = init.errorDescription;
	}
};

//#endregion
//#region src/client/auth.ts
/**
* SEP-2352 stamp check: returns `stored` only when its `issuer` stamp matches the
* resolved authorization server. A stamp that names a *different* issuer reads back
* as `undefined`, so a credential issued by one authorization server is never reused
* at another — the flow falls through to re-registration / re-authorization exactly
* as if nothing were stored. An unstamped value (legacy provider or pre-SEP-2352
* storage) is returned as-is with a `console.warn`; {@linkcode auth} writes the
* stamp back on first use so the window closes after one call.
*
* {@linkcode auth} stamps every value it writes via `saveTokens` / `saveClientInformation`,
* so a provider that round-trips the stored object verbatim is protected with no extra
* code. Providers that hold credentials for multiple authorization servers key their
* storage on `ctx.issuer` instead.
*
* @param opts.canPersistStamp - When `false`, suppresses the unstamped-credential
*   warning: the caller cannot back-stamp (no `saveClientInformation`), so the
*   "binding on first use" claim would be false and would fire on every call.
*/
function discardIfIssuerMismatch(stored, issuer, opts) {
	if (!stored) return void 0;
	if (typeof stored.issuer !== "string") {
		if (opts?.canPersistStamp !== false) console.warn("[mcp-sdk] SEP-2352: stored OAuth credential has no 'issuer' stamp (pre-upgrade storage or provider not round-tripping the value). SEP-2352 isolation is inactive for this read; ensure your provider round-trips the issuer field.");
		return stored.issuer === void 0 ? stored : {
			...stored,
			issuer: void 0
		};
	}
	return issuersMatch(stored.issuer, issuer) ? stored : void 0;
}
/**
* SEP-2352 issuer-identity comparison. Tolerates a single trailing `/` difference,
* mirroring the RFC 8414 §3.3 "one narrow tolerance" applied at metadata-echo
* validation in {@linkcode discoverAuthorizationServerMetadata}: when the SDK
* derives an issuer from `String(new URL(...))` (always slash-suffixed) and the AS
* publishes a slash-free `metadata.issuer`, the two name the same authorization
* server.
*/
function issuersMatch(a, b) {
	return a === b || a.endsWith("/") && a.slice(0, -1) === b || b.endsWith("/") && b.slice(0, -1) === a;
}
/**
* Type guard distinguishing `OAuthClientProvider` from a minimal `AuthProvider`.
* Transports use this at construction time to classify the `authProvider` option.
*
* Checks for `tokens()` + `clientInformation()` — two required `OAuthClientProvider`
* methods that a minimal `AuthProvider` `{ token: ... }` would never have.
*/
function isOAuthClientProvider(provider) {
	if (provider == null) return false;
	const p = provider;
	return typeof p.tokens === "function" && typeof p.clientInformation === "function";
}
/**
* Standard `onUnauthorized` behavior for OAuth providers: extracts
* `WWW-Authenticate` parameters from the 401 response and runs {@linkcode auth}.
* Used by {@linkcode adaptOAuthProvider} to bridge `OAuthClientProvider` to `AuthProvider`.
*/
async function handleOAuthUnauthorized(provider, ctx, extraAuthOptions) {
	const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(ctx.response);
	if (await auth(provider, {
		serverUrl: ctx.serverUrl,
		resourceMetadataUrl,
		scope,
		fetchFn: ctx.fetchFn,
		...extraAuthOptions
	}) !== "AUTHORIZED") throw new UnauthorizedError();
}
/**
* Adapts an `OAuthClientProvider` to the minimal `AuthProvider` interface that
* transports consume. Called once at transport construction — the transport stores
* the adapted provider for `_commonHeaders()` and 401 handling, while keeping the
* original `OAuthClientProvider` for OAuth-specific paths (`finishAuth()`, 403 `insufficient_scope` step-up).
*
* SEP-2352 note: `token()` here is the per-request `Authorization: Bearer …` read for
* the *resource server* (the MCP transport URL), not an authorization server. No OAuth
* discovery has run at this layer, so there is no `issuer` to pass as `ctx` and no
* {@linkcode discardIfIssuerMismatch} check to apply — the access token is sent only to
* the resource server, never to an AS, so the SEP-2352 cross-AS isolation invariant is
* not in scope. Providers that key storage on `ctx.issuer` MUST treat `ctx === undefined`
* as "return the most-recently-saved token set" (the only consumer is the resource server
* the token was minted for); providers that round-trip a single blob need no change.
*
* SEP-1932 (DPoP) note: DPoP request-signing is deliberately *not* done here. When the provider
* implements {@linkcode OAuthClientProvider.dpop | dpop()}, the transports wrap their
* resource-server `fetch` with {@linkcode withDpopFromProvider}, which upgrades the `Bearer` header
* this adapter produces to `DPoP` + proof for DPoP-bound tokens and handles nonce challenges — at
* the one layer that sees the real method, URL and response of every request.
*/
function adaptOAuthProvider(provider, extraAuthOptions) {
	return {
		token: async () => {
			return (await provider.tokens())?.access_token;
		},
		onUnauthorized: async (ctx) => handleOAuthUnauthorized(provider, ctx, extraAuthOptions)
	};
}
var UnauthorizedError = class extends Error {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.UnauthorizedError" });
	}
	static [Symbol.hasInstance](value) {
		return require_src.brandedHasInstance(this, value);
	}
	/**
	* Brand-based type guard: equivalent to `value instanceof this`, as an
	* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
	* the caller's own brand via `this`, so every branded subclass gets a
	* correctly-scoped guard by inheritance. Must be invoked on the class —
	* in callback position write `v => SdkError.isInstance(v)`, not
	* `.filter(SdkError.isInstance)` (detached calls throw rather than
	* silently matching nothing).
	*/
	static isInstance(value) {
		if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
		return require_src.brandedHasInstance(this, value);
	}
	constructor(message) {
		super(message ?? "Unauthorized");
		this.name = "UnauthorizedError";
		require_src.stampErrorBrands(this, new.target);
	}
};
/**
* Validates the `iss` parameter from an authorization response against the
* issuer recorded from the authorization server's validated metadata, per
* RFC 9207 §2.4 and the MCP specification's four-row decision table.
*
* | `issParameterSupported` | `iss`   | Action                                           |
* | ----------------------- | ------- | ------------------------------------------------ |
* | `true`                  | present | compare; throw {@linkcode IssuerMismatchError} on mismatch |
* | `true`                  | absent  | throw {@linkcode IssuerMismatchError}            |
* | `false`                 | present | compare; throw {@linkcode IssuerMismatchError} on mismatch |
* | `false`                 | absent  | proceed (no-op)                                  |
*
* Comparison is **simple string equality** (RFC 3986 §6.2.1). Scheme/host case
* folding, default-port elision, trailing-slash, and percent-encoding
* normalization are explicitly **not** applied — any difference is a mismatch.
*
* When `expectedIssuer` is `undefined` (no validated metadata document exists),
* the check has no authentic baseline and degenerates to a no-op.
*
* @throws {IssuerMismatchError} with `kind: 'authorization_response'`
*/
/**
* Reads RFC 9207's `authorization_response_iss_parameter_supported` from
* authorization-server metadata. Only a literal `true` counts as advertised;
* absent, `false`, or a non-boolean wire value (coerced to `undefined` by the
* schema) means not advertised.
*/
function isIssParameterSupported(metadata) {
	return metadata?.authorization_response_iss_parameter_supported === true;
}
function validateAuthorizationResponseIssuer({ iss, expectedIssuer, issParameterSupported }) {
	if (expectedIssuer === void 0) return;
	if (iss === void 0) {
		if (issParameterSupported) throw new IssuerMismatchError("authorization_response", expectedIssuer, void 0);
		return;
	}
	if (iss !== expectedIssuer) throw new IssuerMismatchError("authorization_response", expectedIssuer, iss);
}
/**
* Computes the union of one or more OAuth `scope` strings.
*
* Each argument is a space-delimited scope string per RFC 6749 §3.3, or
* `undefined`. The result is a single space-delimited string containing each
* distinct scope token exactly once, in first-seen order, or `undefined` if
* every input is empty/undefined.
*
* No hierarchical deduplication is performed: a union may contain semantically
* redundant entries (e.g., a broad scope alongside a narrower one it implies).
* Authorization servers normalize such redundancy during token issuance; the
* spec's step-up flow does not require clients to.
*
* Used by the transport's `403 insufficient_scope` step-up path to accumulate
* previously-requested scopes with newly-challenged scopes so re-authorization
* does not lose previously-granted permissions.
*/
function computeScopeUnion(...scopes) {
	const seen = /* @__PURE__ */ new Set();
	for (const scope of scopes) {
		if (!scope) continue;
		for (const token of scope.split(/\s+/)) if (token) seen.add(token);
	}
	return seen.size > 0 ? [...seen].join(" ") : void 0;
}
/**
* Whether `union` contains at least one scope token not present in `current`.
* Both arguments are space-delimited scope strings per RFC 6749 §3.3.
*
* Used to gate the step-up refresh bypass: when the union of previously-requested
* and newly-challenged scopes is a strict superset of the current token's
* granted scope, refreshing cannot widen the grant (RFC 6749 §6), so the
* transport must force a fresh authorization request instead. When the current
* token already covers the union, refresh remains valid.
*
* An undefined or empty `current` is treated as the empty set, so any non-empty
* `union` is a strict superset. Note that per RFC 6749 §3.3 an authorization
* server MAY omit the token's `scope` field when it equals the requested scope;
* this helper is conservative and treats an absent token `scope` as empty, so
* step-up always forces a fresh authorization request in that case rather than
* risking a refresh that silently drops the widened scope.
*/
function isStrictScopeSuperset(union, current) {
	if (!union) return false;
	const currentSet = new Set((current ?? "").split(/\s+/).filter(Boolean));
	for (const token of union.split(/\s+/)) if (token && !currentSet.has(token)) return true;
	return false;
}
/**
* Shared `finishAuth` resolver for the `(code, iss?)` and `(URLSearchParams)` overloads.
*
* For the `URLSearchParams` form, only `iss` and `code` are read up front. When a `code` is
* present the returned values flow into {@linkcode auth}, which runs
* {@linkcode validateAuthorizationResponseIssuer} against freshly-discovered metadata before
* the code is redeemed — so on mismatch the thrown {@linkcode IssuerMismatchError} carries no
* `error`/`error_description`/`error_uri` text from the callback (those are attacker-controlled
* in a mix-up). When no `code` is present (an error-shaped callback), `iss` is validated here
* against the provider's recorded discovery state — or, when the provider does not implement
* `discoveryState`, against freshly-discovered metadata mirroring what {@linkcode auth} does on
* the code-present path — **before** the callback's error parameters are read; only after that
* passes are they surfaced as an {@linkcode OAuthError}. When no issuer baseline can be
* obtained either way, a generic {@linkcode UnauthorizedError} is thrown without surfacing the
* callback's `error`/`error_description`/`error_uri`.
*
* @internal Exported for the transport `finishAuth` overloads; not part of the public barrel.
*/
async function resolveAuthorizationCallbackParams(codeOrParams, iss, provider, serverUrl, opts) {
	if (typeof codeOrParams === "string") return {
		authorizationCode: codeOrParams,
		iss
	};
	const issParam = codeOrParams.get("iss") ?? void 0;
	const code = codeOrParams.get("code");
	if (code) return {
		authorizationCode: code,
		iss: issParam
	};
	let metadata = (await provider.discoveryState?.())?.authorizationServerMetadata;
	if (!metadata) try {
		metadata = (await discoverOAuthServerInfo(serverUrl, opts)).authorizationServerMetadata;
	} catch {
		metadata = void 0;
	}
	if (!metadata) throw new UnauthorizedError("Authorization callback failed and the issuer could not be verified");
	validateAuthorizationResponseIssuer({
		iss: issParam,
		expectedIssuer: metadata.issuer,
		issParameterSupported: isIssParameterSupported(metadata)
	});
	const error = codeOrParams.get("error");
	if (error) throw new require_src.OAuthError(error, codeOrParams.get("error_description") ?? error, codeOrParams.get("error_uri") ?? void 0);
	throw new UnauthorizedError("Authorization callback contained neither `code` nor `error`");
}
function isClientAuthMethod(method) {
	return [
		"client_secret_basic",
		"client_secret_post",
		"none"
	].includes(method);
}
const AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
const AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
/**
* Determines the best client authentication method to use based on server support and client configuration.
*
* Priority order (highest to lowest):
* 1. `client_secret_basic` (if client secret is available)
* 2. `client_secret_post` (if client secret is available)
* 3. `none` (for public clients)
*
* @param clientInformation - OAuth client information containing credentials
* @param supportedMethods - Authentication methods supported by the authorization server
* @returns The selected authentication method
*/
function selectClientAuthMethod(clientInformation, supportedMethods) {
	const hasClientSecret = clientInformation.client_secret !== void 0;
	if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) return clientInformation.token_endpoint_auth_method;
	if (supportedMethods.length === 0) return hasClientSecret ? "client_secret_basic" : "none";
	if (hasClientSecret && supportedMethods.includes("client_secret_basic")) return "client_secret_basic";
	if (hasClientSecret && supportedMethods.includes("client_secret_post")) return "client_secret_post";
	if (supportedMethods.includes("none")) return "none";
	return hasClientSecret ? "client_secret_post" : "none";
}
/**
* Applies client authentication to the request based on the specified method.
*
* Implements OAuth 2.1 client authentication methods:
* - `client_secret_basic`: HTTP Basic authentication (RFC 6749 Section 2.3.1)
* - `client_secret_post`: Credentials in request body (RFC 6749 Section 2.3.1)
* - `none`: Public client authentication (RFC 6749 Section 2.1)
*
* @param method - The authentication method to use
* @param clientInformation - OAuth client information containing credentials
* @param headers - HTTP headers object to modify
* @param params - URL search parameters to modify
* @throws {Error} When required credentials are missing
*/
function applyClientAuthentication(method, clientInformation, headers, params) {
	const { client_id, client_secret } = clientInformation;
	switch (method) {
		case "client_secret_basic":
			applyBasicAuth(client_id, client_secret, headers);
			return;
		case "client_secret_post":
			applyPostAuth(client_id, client_secret, params);
			return;
		case "none":
			applyPublicAuth(client_id, params);
			return;
		default: throw new Error(`Unsupported client authentication method: ${method}`);
	}
}
/**
* Applies HTTP Basic authentication (RFC 6749 Section 2.3.1)
*/
function applyBasicAuth(clientId, clientSecret, headers) {
	if (!clientSecret) throw new Error("client_secret_basic authentication requires a client_secret");
	const credentials = btoa(`${clientId}:${clientSecret}`);
	headers.set("Authorization", `Basic ${credentials}`);
}
/**
* Applies POST body authentication (RFC 6749 Section 2.3.1)
*/
function applyPostAuth(clientId, clientSecret, params) {
	params.set("client_id", clientId);
	if (clientSecret) params.set("client_secret", clientSecret);
}
/**
* Applies public client authentication (RFC 6749 Section 2.1)
*/
function applyPublicAuth(clientId, params) {
	params.set("client_id", clientId);
}
/**
* Loopback hosts exempt from the in-transit `https:` requirement (RFC 8252 §7.3).
* Includes bare `localhost` and any name ending in `.localhost` (RFC 6761 §6.3).
*/
function isLoopbackHost(hostname) {
	return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
}
/**
* Refuse to send credentials to a non-TLS token endpoint. The MCP authorization
* specification requires authorization server endpoints to use HTTPS. Loopback
* hosts are exempt here for local development.
*
* @throws {@linkcode InsecureTokenEndpointError} if the endpoint is insecure.
*/
function assertSecureTokenEndpoint(tokenEndpoint) {
	const url = new URL(String(tokenEndpoint));
	if (url.protocol !== "https:" && !isLoopbackHost(url.hostname)) throw new InsecureTokenEndpointError(url.href);
	return url;
}
/**
* Derives an OIDC `application_type` from a client's registered redirect URIs
* when the consumer has not set one explicitly (SEP-837). Loopback hosts and
* non-`http(s)` custom URI schemes indicate a native application (RFC 8252);
* everything else is treated as a web application. The result is a heuristic
* default — callers that know better should set `clientMetadata.application_type`
* themselves, which {@linkcode resolveClientMetadata} never overwrites.
*
* A mixed redirect set (for example a public `https:` URI alongside a loopback
* URI) is inherently ambiguous under OIDC DCR §2 — neither value satisfies the
* AS for both URIs — so consumers with mixed sets should set `application_type`
* explicitly rather than relying on this heuristic.
*/
function deriveApplicationType(redirectUris) {
	for (const raw of redirectUris ?? []) {
		let url;
		try {
			url = new URL(raw);
		} catch {
			continue;
		}
		if (url.protocol !== "http:" && url.protocol !== "https:") return "native";
		if (isLoopbackHost(url.hostname)) return "native";
	}
	return "web";
}
/**
* Reads {@linkcode OAuthClientProvider.clientMetadata | clientMetadata} from the
* provider and fills the SEP-837 / SEP-2207 defaults the SDK relies on, so
* {@linkcode registerClient} sees a consistent, fully-populated document.
*
* - `grant_types` defaults to `['authorization_code', 'refresh_token']` for
*   interactive providers (those with a {@linkcode OAuthClientProvider.redirectUrl | redirectUrl})
*   so authorization servers that gate refresh-token issuance on the registered
*   grant types issue one (SEP-2207). Non-interactive providers (no
*   `redirectUrl`) get no `grant_types` default. This default applies to the
*   Dynamic Client Registration body only — it does **not** drive
*   {@linkcode determineScope}'s `offline_access` augmentation.
* - `application_type` defaults from `redirect_uris`: loopback redirect hosts
*   and custom URI schemes → `'native'`, otherwise `'web'` (SEP-837 / RFC 8252).
*
* A field the consumer set explicitly is **never** overwritten. {@linkcode auth}
* calls this once at the top of the flow; direct callers of
* {@linkcode registerClient} that want the same defaults should pass the result
* of this function as `clientMetadata`.
*/
function resolveClientMetadata(provider) {
	const clientMetadata = provider.clientMetadata;
	return {
		...clientMetadata,
		grant_types: clientMetadata.grant_types ?? (provider.redirectUrl === void 0 ? void 0 : ["authorization_code", "refresh_token"]),
		application_type: clientMetadata.application_type ?? deriveApplicationType(clientMetadata.redirect_uris)
	};
}
/**
* Parses an OAuth error response from a string or Response object.
*
* If the input is a standard OAuth2.0 error response, it will be parsed according to the spec
* and an {@linkcode OAuthError} will be returned with the appropriate error code.
* If parsing fails, it falls back to a generic {@linkcode OAuthErrorCode.ServerError | ServerError} that includes
* the response status (if available) and original content.
*
* @param input - A Response object or string containing the error response
* @returns A Promise that resolves to an {@linkcode OAuthError} instance
*/
async function parseErrorResponse(input) {
	const statusCode = input instanceof Response ? input.status : void 0;
	const body = input instanceof Response ? await input.text() : input;
	try {
		const result = _modelcontextprotocol_core_internal.OAuthErrorResponseSchema.parse(JSON.parse(body));
		return require_src.OAuthError.fromResponse(result);
	} catch (error) {
		const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error}. Raw body: ${body}`;
		return new require_src.OAuthError(require_src.OAuthErrorCode.ServerError, errorMessage);
	}
}
/**
* Recovering from a recoverable OAuth error discards stored credentials and silently starts a
* fresh authorization. On a headless client whose `redirectToAuthorization()` is a no-op that
* recovery is indistinguishable from nothing happening at all, so name the cause. The most
* common case is `invalid_grant` — an expired, revoked, or rotation-reuse-detected refresh
* token. See issue #2034.
*/
function warnCredentialInvalidation(provider, error, invalidated) {
	const action = provider.invalidateCredentials === void 0 ? `retrying authorization without discarding the stored ${invalidated} (provider implements no invalidateCredentials())` : `invalidating the stored ${invalidated} and retrying authorization`;
	console.warn(`[mcp-sdk] OAuth ${JSON.stringify(error.code)} — ${action}. Cause: ${JSON.stringify(error.message)}`);
}
/**
* Orchestrates the full auth flow with a server.
*
* This can be used as a single entry point for all authorization functionality,
* instead of linking together the other lower-level functions in this module.
*/
async function auth(provider, options) {
	try {
		return await authInternal(provider, options);
	} catch (error) {
		if (error instanceof require_src.OAuthError) {
			if (error.code === require_src.OAuthErrorCode.InvalidClient || error.code === require_src.OAuthErrorCode.UnauthorizedClient) {
				warnCredentialInvalidation(provider, error, "client credentials and tokens");
				await provider.invalidateCredentials?.("client");
				await provider.invalidateCredentials?.("tokens");
				return await authInternal(provider, options);
			} else if (error.code === require_src.OAuthErrorCode.InvalidGrant || error.code === require_src.OAuthErrorCode.InvalidDpopProof) {
				warnCredentialInvalidation(provider, error, "tokens");
				await provider.invalidateCredentials?.("tokens");
				return await authInternal(provider, options);
			}
		}
		throw error;
	}
}
/**
* Selects scopes per the MCP spec and augment for refresh token support.
*/
function determineScope(options) {
	const { requestedScope, resourceMetadata, authServerMetadata, clientMetadata } = options;
	let effectiveScope = requestedScope || resourceMetadata?.scopes_supported?.join(" ") || clientMetadata.scope;
	if (effectiveScope && authServerMetadata?.scopes_supported?.includes("offline_access") && !effectiveScope.split(" ").includes("offline_access") && clientMetadata.grant_types?.includes("refresh_token")) effectiveScope = `${effectiveScope} offline_access`;
	return effectiveScope;
}
async function authInternal(provider, { serverUrl, authorizationCode, iss, scope, resourceMetadataUrl, fetchFn, skipIssuerMetadataValidation, forceReauthorization }) {
	const clientMetadata = resolveClientMetadata(provider);
	const cachedState = await provider.discoveryState?.();
	let resourceMetadata;
	let authorizationServerUrl;
	let metadata;
	let freshDiscoveryState;
	let effectiveResourceMetadataUrl = resourceMetadataUrl;
	if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
	if (cachedState?.authorizationServerUrl) {
		authorizationServerUrl = cachedState.authorizationServerUrl;
		resourceMetadata = cachedState.resourceMetadata;
		metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, {
			fetchFn,
			skipIssuerValidation: skipIssuerMetadataValidation
		});
		if (!resourceMetadata) try {
			resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
		} catch (error) {
			if (error instanceof TypeError) throw error;
		}
		if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) await provider.saveDiscoveryState?.({
			authorizationServerUrl: String(authorizationServerUrl),
			resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
			resourceMetadata,
			authorizationServerMetadata: metadata
		});
	} else {
		const serverInfo = await discoverOAuthServerInfo(serverUrl, {
			resourceMetadataUrl: effectiveResourceMetadataUrl,
			fetchFn,
			skipIssuerMetadataValidation
		});
		authorizationServerUrl = serverInfo.authorizationServerUrl;
		metadata = serverInfo.authorizationServerMetadata;
		resourceMetadata = serverInfo.resourceMetadata;
		freshDiscoveryState = {
			authorizationServerUrl: String(authorizationServerUrl),
			resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
			resourceMetadata,
			authorizationServerMetadata: metadata
		};
	}
	const issuer = metadata?.issuer ?? String(authorizationServerUrl);
	const infoCtx = { issuer };
	await provider.saveAuthorizationServerUrl?.(issuer);
	if (authorizationCode !== void 0) {
		const recordedIssuer = cachedState?.authorizationServerMetadata?.issuer ?? cachedState?.authorizationServerUrl;
		if (recordedIssuer === void 0) {
			if (provider.saveDiscoveryState !== void 0) throw new AuthorizationServerMismatchError("discoveryState was not available on the callback leg; ensure your provider persists discoveryState alongside codeVerifier", issuer);
			console.warn("[mcp-sdk] OAuthClientProvider does not implement saveDiscoveryState()/discoveryState(); the SEP-2352 callback-leg authorization-server binding cannot be checked. Implement discoveryState (persist alongside codeVerifier) — see docs/migration/upgrade-to-v2.md §SEP-2352.");
		} else if (!issuersMatch(recordedIssuer, issuer)) throw new AuthorizationServerMismatchError(recordedIssuer, issuer);
	}
	if (freshDiscoveryState) await provider.saveDiscoveryState?.(freshDiscoveryState);
	const selectedResource = await selectResourceURL(serverUrl, provider, resourceMetadata);
	const resource = selectedResource && resourceMetadata && !provider.validateResourceURL ? resourceMetadata.resource : selectedResource;
	if (resource) await provider.saveResourceUrl?.(resourceIndicatorToString(resource));
	const resolvedScope = determineScope({
		requestedScope: scope,
		resourceMetadata,
		authServerMetadata: metadata,
		clientMetadata: provider.clientMetadata
	});
	const rawClientInfo = await Promise.resolve(provider.clientInformation(infoCtx));
	let clientInformation = discardIfIssuerMismatch(rawClientInfo, issuer, { canPersistStamp: provider.saveClientInformation !== void 0 });
	if (clientInformation === void 0 && rawClientInfo?.issuer && provider.saveClientInformation === void 0) throw new AuthorizationServerMismatchError(rawClientInfo.issuer, issuer);
	if (clientInformation && clientInformation.issuer === void 0) {
		clientInformation = {
			...clientInformation,
			issuer
		};
		await provider.saveClientInformation?.(clientInformation, infoCtx);
	}
	if (!clientInformation) {
		if (authorizationCode !== void 0) throw new Error("Existing OAuth client information is required when exchanging an authorization code");
		const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
		const clientMetadataUrl = provider.clientMetadataUrl;
		if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) throw new require_src.OAuthError(require_src.OAuthErrorCode.InvalidClientMetadata, `clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
		if (supportsUrlBasedClientId && clientMetadataUrl) {
			clientInformation = {
				client_id: clientMetadataUrl,
				issuer
			};
			await provider.saveClientInformation?.(clientInformation, infoCtx);
		} else {
			if (!provider.saveClientInformation) throw new Error("OAuth client information must be saveable for dynamic registration");
			clientInformation = {
				...await registerClient(authorizationServerUrl, {
					metadata,
					clientMetadata,
					scope: resolvedScope,
					fetchFn
				}),
				issuer
			};
			await provider.saveClientInformation(clientInformation, infoCtx);
		}
	}
	const nonInteractiveFlow = !provider.redirectUrl;
	if (authorizationCode !== void 0 || nonInteractiveFlow) {
		if (authorizationCode !== void 0) validateAuthorizationResponseIssuer({
			iss,
			expectedIssuer: metadata?.issuer,
			issParameterSupported: isIssParameterSupported(metadata)
		});
		const tokens$1 = await fetchToken(provider, authorizationServerUrl, {
			metadata,
			resource,
			authorizationCode,
			iss,
			scope: resolvedScope,
			fetchFn
		});
		await provider.saveTokens({
			...tokens$1,
			issuer
		}, infoCtx);
		return "AUTHORIZED";
	}
	let tokens = discardIfIssuerMismatch(await provider.tokens(infoCtx), issuer);
	if (tokens && tokens.issuer === void 0) {
		tokens = {
			...tokens,
			issuer
		};
		await provider.saveTokens(tokens, infoCtx);
	}
	if (tokens?.refresh_token && !forceReauthorization) {
		let newTokens;
		try {
			newTokens = await refreshAuthorization(authorizationServerUrl, {
				metadata,
				clientInformation,
				refreshToken: tokens.refresh_token,
				resource,
				addClientAuthentication: provider.addClientAuthentication,
				dpop: await provider.dpop?.(),
				fetchFn
			});
		} catch (error) {
			if (error instanceof InsecureTokenEndpointError) throw error;
			if (!(error instanceof require_src.OAuthError) || error.code === require_src.OAuthErrorCode.ServerError) console.warn(`[mcp-sdk] Could not refresh OAuth tokens; falling back to a new authorization request. Cause: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`);
			else throw error;
		}
		if (newTokens) {
			await provider.saveTokens({
				...newTokens,
				issuer
			}, infoCtx);
			return "AUTHORIZED";
		}
	}
	const state = provider.state ? await provider.state() : void 0;
	const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
		metadata,
		clientInformation,
		state,
		redirectUrl: provider.redirectUrl,
		scope: resolvedScope,
		resource
	});
	await provider.saveCodeVerifier(codeVerifier);
	await provider.redirectToAuthorization(authorizationUrl);
	return "REDIRECT";
}
/**
* Validates that the given `clientMetadataUrl` is a valid HTTPS URL with a non-root pathname.
*
* No-op when `url` is `undefined` or empty (providers that do not use URL-based client IDs
* are unaffected). When the value is defined but invalid, throws an {@linkcode OAuthError}
* with code {@linkcode OAuthErrorCode.InvalidClientMetadata}.
*
* {@linkcode OAuthClientProvider} implementations that accept a `clientMetadataUrl` should
* call this in their constructors for early validation.
*
* @param url - The `clientMetadataUrl` value to validate (from `OAuthClientProvider.clientMetadataUrl`)
* @throws {OAuthError} When `url` is defined but is not a valid HTTPS URL with a non-root pathname
*/
function validateClientMetadataUrl(url) {
	if (url && !isHttpsUrl(url)) throw new require_src.OAuthError(require_src.OAuthErrorCode.InvalidClientMetadata, `clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${url}`);
}
/**
* SEP-991: URL-based Client IDs
* Validate that the `client_id` is a valid URL with `https` scheme
*/
function isHttpsUrl(value) {
	if (!value) return false;
	try {
		const url = new URL(value);
		return url.protocol === "https:" && url.pathname !== "/";
	} catch {
		return false;
	}
}
/**
* Selects the RFC 8707 resource indicator for an MCP server: the provider's
* {@linkcode OAuthClientProvider.validateResourceURL | validateResourceURL} result when
* implemented, otherwise the protected resource metadata's `resource` (checked against the
* server URL with `checkResourceAllowed`), or `undefined` when there is no metadata.
*
* The result is a parsed `URL`, so a pathless indicator such as `https://example.com` has
* the `href` `https://example.com/`. {@linkcode auth} therefore sends the metadata string
* verbatim instead of this URL's `href` (#1968); callers that emit the `resource`
* parameter themselves should do the same.
*/
async function selectResourceURL(serverUrl, provider, resourceMetadata) {
	const defaultResource = require_src.resourceUrlFromServerUrl(serverUrl);
	if (provider.validateResourceURL) return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
	if (!resourceMetadata) return;
	if (!require_src.checkResourceAllowed({
		requestedResource: defaultResource,
		configuredResource: resourceMetadata.resource
	})) throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
	return new URL(resourceMetadata.resource);
}
/** Auth-scheme challenge tokens {@linkcode extractWWWAuthenticateParams} recognizes. */
const RECOGNIZED_CHALLENGE_SCHEMES = new Set(["bearer", "dpop"]);
/**
* Extract `resource_metadata`, `scope`, `error`, and `error_description` from a
* `WWW-Authenticate` header.
*
* Recognizes both the `Bearer` scheme (RFC 6750) and the `DPoP` scheme (RFC 9449 §7.1,
* SEP-1932) — a DPoP-protected resource's challenge carries the same parameters under `DPoP`
* instead of `Bearer`, and this must still surface `resource_metadata`/`scope` from it for
* discovery and SEP-2350 step-up to work against such a resource.
*/
function extractWWWAuthenticateParams(res) {
	const authenticateHeader = res.headers.get("WWW-Authenticate");
	if (!authenticateHeader) return {};
	const [type, scheme] = authenticateHeader.split(" ");
	if (!type || !RECOGNIZED_CHALLENGE_SCHEMES.has(type.toLowerCase()) || !scheme) return {};
	const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
	let resourceMetadataUrl;
	if (resourceMetadataMatch) try {
		resourceMetadataUrl = new URL(resourceMetadataMatch);
	} catch {}
	const scope = extractFieldFromWwwAuth(res, "scope") || void 0;
	const error = extractFieldFromWwwAuth(res, "error") || void 0;
	const errorDescription = extractFieldFromWwwAuth(res, "error_description") || void 0;
	return {
		resourceMetadataUrl,
		scope,
		error,
		errorDescription
	};
}
/**
* Extracts a specific field's value from the `WWW-Authenticate` header string.
*
* @param response The HTTP response object containing the headers.
* @param fieldName The name of the field to extract (e.g., `"realm"`, `"nonce"`).
* @returns The field value
*/
function extractFieldFromWwwAuth(response, fieldName) {
	const wwwAuthHeader = response.headers.get("WWW-Authenticate");
	if (!wwwAuthHeader) return null;
	const pattern = new RegExp(String.raw`${fieldName}=(?:"([^"]+)"|([^\s,]+))`);
	const match = wwwAuthHeader.match(pattern);
	if (match) {
		const result = match[1] || match[2];
		if (result) return result;
	}
	return null;
}
/**
* Extract `resource_metadata` from response header.
* @deprecated Use {@linkcode extractWWWAuthenticateParams} instead.
*/
function extractResourceMetadataUrl(res) {
	const authenticateHeader = res.headers.get("WWW-Authenticate");
	if (!authenticateHeader) return;
	const [type, scheme] = authenticateHeader.split(" ");
	if (type?.toLowerCase() !== "bearer" || !scheme) return;
	const match = /resource_metadata="([^"]*)"/.exec(authenticateHeader);
	if (!match || !match[1]) return;
	try {
		return new URL(match[1]);
	} catch {
		return;
	}
}
/**
* Looks up {@link https://datatracker.ietf.org/doc/html/rfc9728 | RFC 9728}
* OAuth 2.0 Protected Resource Metadata.
*
* If the server returns a 404 for the well-known endpoint, this function will
* return `undefined`. Any other errors will be thrown as exceptions.
*/
async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
	const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
		protocolVersion: opts?.protocolVersion,
		metadataUrl: opts?.resourceMetadataUrl
	});
	if (!response || response.status === 404) {
		await response?.text?.().catch(() => {});
		throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
	}
	if (!response.ok) {
		await response.text?.().catch(() => {});
		throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
	}
	return _modelcontextprotocol_core_internal.OAuthProtectedResourceMetadataSchema.parse(await response.json());
}
/**
* Fetch with a retry heuristic for CORS errors caused by custom headers.
*
* In browsers, adding a custom header (e.g. `MCP-Protocol-Version`) triggers a CORS preflight.
* If the server doesn't allow that header, the browser throws a `TypeError` before any response
* is received. Retrying without custom headers often succeeds because the request becomes
* "simple" (no preflight). If the server sends no CORS headers at all, the retry also fails
* with `TypeError` and we return `undefined` so callers can fall through to an alternate URL.
*
* However, `fetch()` also throws `TypeError` for non-CORS failures (DNS resolution, connection
* refused, invalid URL). Swallowing those and returning `undefined` masks real errors and can
* cause callers to silently fall through to a different discovery URL. CORS is a browser-only
* concept, so in non-browser runtimes (Node.js, Workers) a `TypeError` from `fetch` is never a
* CORS error — there we propagate the error instead of swallowing it.
*
* In browsers, we cannot reliably distinguish CORS `TypeError` from network `TypeError` from the
* error object alone, so the swallow-and-fallthrough heuristic is preserved there.
*/
async function fetchWithCorsRetry(url, headers, fetchFn = fetch) {
	const withinOrigin = require_src.fetchWithinOrigin(fetchFn);
	try {
		return await withinOrigin(url, { headers });
	} catch (error) {
		if (!(error instanceof TypeError) || !_modelcontextprotocol_client__shims.CORS_IS_POSSIBLE) throw error;
		if (headers) try {
			return await withinOrigin(url, {});
		} catch (retryError) {
			if (!(retryError instanceof TypeError)) throw retryError;
			return;
		}
		return;
	}
}
/**
* Constructs the well-known path for auth-related metadata discovery
*/
function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
	if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
	return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
}
/**
* Tries to discover OAuth metadata at a specific URL
*/
async function tryMetadataDiscovery(url, protocolVersion, fetchFn = fetch) {
	return await fetchWithCorsRetry(url, { "MCP-Protocol-Version": protocolVersion }, fetchFn);
}
/**
* Determines if fallback to root discovery should be attempted
*/
function shouldAttemptFallback(response, pathname) {
	if (!response) return true;
	if (pathname === "/") return false;
	return !response.ok && response.status < 500 || response.status === 502;
}
/**
* Generic function for discovering OAuth metadata with fallback support
*/
async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
	const issuer = new URL(serverUrl);
	const protocolVersion = opts?.protocolVersion ?? _modelcontextprotocol_core_internal.LATEST_PROTOCOL_VERSION;
	let url;
	if (opts?.metadataUrl) url = new URL(opts.metadataUrl);
	else {
		const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
		url = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
		url.search = issuer.search;
	}
	let response = await tryMetadataDiscovery(url, protocolVersion, fetchFn);
	if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) response = await tryMetadataDiscovery(new URL(`/.well-known/${wellKnownType}`, issuer), protocolVersion, fetchFn);
	return response;
}
/**
* Looks up RFC 8414 OAuth 2.0 Authorization Server Metadata.
*
* If the server returns a 404 for the well-known endpoint, this function will
* return `undefined`. Any other errors will be thrown as exceptions.
*
* @deprecated This function is deprecated in favor of {@linkcode discoverAuthorizationServerMetadata}.
*/
async function discoverOAuthMetadata(issuer, { authorizationServerUrl, protocolVersion } = {}, fetchFn = fetch) {
	if (typeof issuer === "string") issuer = new URL(issuer);
	if (!authorizationServerUrl) authorizationServerUrl = issuer;
	if (typeof authorizationServerUrl === "string") authorizationServerUrl = new URL(authorizationServerUrl);
	protocolVersion ??= _modelcontextprotocol_core_internal.LATEST_PROTOCOL_VERSION;
	const response = await discoverMetadataWithFallback(authorizationServerUrl, "oauth-authorization-server", fetchFn, {
		protocolVersion,
		metadataServerUrl: authorizationServerUrl
	});
	if (!response || response.status === 404) {
		await response?.text?.().catch(() => {});
		return;
	}
	if (!response.ok) {
		await response.text?.().catch(() => {});
		throw new Error(`HTTP ${response.status} trying to load well-known OAuth metadata`);
	}
	return _modelcontextprotocol_core_internal.OAuthMetadataSchema.parse(await response.json());
}
/**
* Builds a list of discovery URLs to try for authorization server metadata.
* URLs are returned in priority order:
* 1. OAuth metadata at the given URL
* 2. OIDC metadata endpoints at the given URL
*/
function buildDiscoveryUrls(authorizationServerUrl) {
	const url = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
	const hasPath = url.pathname !== "/";
	const urlsToTry = [];
	if (!hasPath) {
		urlsToTry.push({
			url: new URL("/.well-known/oauth-authorization-server", url.origin),
			type: "oauth"
		}, {
			url: new URL(`/.well-known/openid-configuration`, url.origin),
			type: "oidc"
		});
		return urlsToTry;
	}
	let pathname = url.pathname;
	if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
	urlsToTry.push({
		url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url.origin),
		type: "oauth"
	}, {
		url: new URL(`/.well-known/openid-configuration${pathname}`, url.origin),
		type: "oidc"
	}, {
		url: new URL(`${pathname}/.well-known/openid-configuration`, url.origin),
		type: "oidc"
	});
	return urlsToTry;
}
/**
* Discovers authorization server metadata with support for
* {@link https://datatracker.ietf.org/doc/html/rfc8414 | RFC 8414} OAuth 2.0
* Authorization Server Metadata and
* {@link https://openid.net/specs/openid-connect-discovery-1_0.html | OpenID Connect Discovery 1.0}
* specifications.
*
* This function implements a fallback strategy for authorization server discovery:
* 1. Attempts RFC 8414 OAuth metadata discovery first
* 2. If OAuth discovery fails, falls back to OpenID Connect Discovery
*
* @param authorizationServerUrl - The authorization server URL obtained from the MCP Server's
*                                 protected resource metadata, or the MCP server's URL if the
*                                 metadata was not found.
* The returned metadata's `issuer` is validated against `authorizationServerUrl`
* per RFC 8414 §3.3 (and OIDC Discovery §4.3): if they differ the metadata is
* **rejected** with {@linkcode IssuerMismatchError} and not returned. Set
* `skipIssuerValidation: true` to suppress this check — **security-weakening**,
* intended only for known-misconfigured authorization servers.
*
* @param options - Configuration options
* @param options.fetchFn - Optional fetch function for making HTTP requests, defaults to global fetch
* @param options.protocolVersion - MCP protocol version to use, defaults to {@linkcode LATEST_PROTOCOL_VERSION}
* @param options.skipIssuerValidation - Skip the RFC 8414 §3.3 `issuer` echo check. **Security-weakening.**
* @returns Promise resolving to authorization server metadata, or undefined if discovery fails
* @throws {IssuerMismatchError} when the metadata's `issuer` does not match `authorizationServerUrl`
*/
async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = _modelcontextprotocol_core_internal.LATEST_PROTOCOL_VERSION, skipIssuerValidation = false } = {}) {
	const headers = {
		"MCP-Protocol-Version": protocolVersion,
		Accept: "application/json"
	};
	const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
	for (const { url: endpointUrl, type } of urlsToTry) {
		const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
		if (!response)
 /**
		* CORS error occurred - don't throw as the endpoint may not allow CORS,
		* continue trying other possible endpoints
		*/
		continue;
		if (!response.ok) {
			await response.text?.().catch(() => {});
			if (response.status < 500 || response.status === 502) continue;
			throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
		}
		const parsed = type === "oauth" ? _modelcontextprotocol_core_internal.OAuthMetadataSchema.parse(await response.json()) : _modelcontextprotocol_core_internal.OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
		if (!skipIssuerValidation) {
			const expectedIssuer = typeof authorizationServerUrl === "string" ? authorizationServerUrl : authorizationServerUrl.href;
			if (!(parsed.issuer === expectedIssuer || expectedIssuer.endsWith("/") && parsed.issuer === expectedIssuer.slice(0, -1))) throw new IssuerMismatchError("metadata", expectedIssuer, parsed.issuer);
		}
		return parsed;
	}
}
/**
* Discovers the authorization server for an MCP server following
* {@link https://datatracker.ietf.org/doc/html/rfc9728 | RFC 9728} (OAuth 2.0 Protected
* Resource Metadata), with fallback to treating the server URL as the
* authorization server.
*
* This function combines two discovery steps into one call:
* 1. Probes `/.well-known/oauth-protected-resource` on the MCP server to find the
*    authorization server URL (RFC 9728).
* 2. Fetches authorization server metadata from that URL (RFC 8414 / OpenID Connect Discovery).
*
* Use this when you need the authorization server metadata for operations outside the
* {@linkcode auth} orchestrator, such as token refresh or token revocation.
*
* @param serverUrl - The MCP resource server URL
* @param opts - Optional configuration
* @param opts.resourceMetadataUrl - Override URL for the protected resource metadata endpoint
* @param opts.fetchFn - Custom fetch function for HTTP requests
* @returns Authorization server URL, metadata, and resource metadata (if available)
*/
async function discoverOAuthServerInfo(serverUrl, opts) {
	let resourceMetadata;
	let authorizationServerUrl;
	try {
		resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
		if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) authorizationServerUrl = resourceMetadata.authorization_servers[0];
	} catch (error) {
		if (error instanceof TypeError) throw error;
	}
	if (!authorizationServerUrl) authorizationServerUrl = String(new URL("/", serverUrl));
	const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
		fetchFn: opts?.fetchFn,
		skipIssuerValidation: opts?.skipIssuerMetadataValidation
	});
	return {
		authorizationServerUrl,
		authorizationServerMetadata,
		resourceMetadata
	};
}
function resourceIndicatorToString(resource) {
	return typeof resource === "string" ? resource : resource.href;
}
/**
* Begins the authorization flow with the given server, by generating a PKCE challenge and constructing the authorization URL.
*/
async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
	let authorizationUrl;
	if (metadata) {
		authorizationUrl = new URL(metadata.authorization_endpoint);
		if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
		if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
	} else authorizationUrl = new URL("/authorize", authorizationServerUrl);
	const challenge = await (0, pkce_challenge.default)();
	const codeVerifier = challenge.code_verifier;
	const codeChallenge = challenge.code_challenge;
	authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
	authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
	authorizationUrl.searchParams.set("code_challenge", codeChallenge);
	authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
	authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
	if (state) authorizationUrl.searchParams.set("state", state);
	if (scope) authorizationUrl.searchParams.set("scope", scope);
	if (scope?.split(" ").includes("offline_access")) authorizationUrl.searchParams.append("prompt", "consent");
	if (resource) authorizationUrl.searchParams.set("resource", resourceIndicatorToString(resource));
	return {
		authorizationUrl,
		codeVerifier
	};
}
/**
* Prepares token request parameters for an authorization code exchange.
*
* This is the default implementation used by {@linkcode fetchToken} when the provider
* doesn't implement {@linkcode OAuthClientProvider.prepareTokenRequest | prepareTokenRequest}.
*
* @param authorizationCode - The authorization code received from the authorization endpoint
* @param codeVerifier - The PKCE code verifier
* @param redirectUri - The redirect URI used in the authorization request
* @returns URLSearchParams for the `authorization_code` grant
*/
function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
	return new URLSearchParams({
		grant_type: "authorization_code",
		code: authorizationCode,
		code_verifier: codeVerifier,
		redirect_uri: String(redirectUri)
	});
}
/**
* Internal helper to execute a token request with the given parameters.
* Used by {@linkcode exchangeAuthorization}, {@linkcode refreshAuthorization}, and {@linkcode fetchToken}.
*/
async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, dpop, fetchFn }) {
	const tokenUrl = assertSecureTokenEndpoint(metadata?.token_endpoint ?? new URL("/token", authorizationServerUrl));
	const headers = new Headers({
		"Content-Type": "application/x-www-form-urlencoded",
		Accept: "application/json"
	});
	if (resource) tokenRequestParams.set("resource", resourceIndicatorToString(resource));
	if (!addClientAuthentication && clientInformation) applyClientAuthentication(selectClientAuthMethod(clientInformation, metadata?.token_endpoint_auth_methods_supported ?? []), clientInformation, headers, tokenRequestParams);
	const requestOnce = async () => {
		const requestHeaders = new Headers(headers);
		if (addClientAuthentication) await addClientAuthentication(requestHeaders, tokenRequestParams, tokenUrl, metadata);
		if (dpop) requestHeaders.set("DPoP", await dpop.buildProof({
			htm: "POST",
			htu: tokenUrl
		}));
		return require_src.fetchWithinOrigin(fetchFn ?? fetch)(tokenUrl, {
			method: "POST",
			headers: requestHeaders,
			body: tokenRequestParams
		});
	};
	let response = await requestOnce();
	if (dpop && response.status === 400) {
		if ((await response.clone().json().catch(() => {}))?.error === require_src.OAuthErrorCode.UseDpopNonce) {
			dpop.observeNonce(response, tokenUrl);
			response = await requestOnce();
		}
	}
	dpop?.observeNonce(response, tokenUrl);
	if (!response.ok) throw await parseErrorResponse(response);
	const json = await response.json();
	try {
		return _modelcontextprotocol_core_internal.OAuthTokensSchema.parse(require_src.withoutIssuer(json));
	} catch (parseError) {
		if (typeof json === "object" && json !== null && "error" in json) throw await parseErrorResponse(JSON.stringify(json));
		throw parseError;
	}
}
/**
* Exchanges an authorization code for an access token with the given server.
*
* Supports multiple client authentication methods as specified in OAuth 2.1:
* - Automatically selects the best authentication method based on server support
* - Falls back to appropriate defaults when server metadata is unavailable
*
* @param authorizationServerUrl - The authorization server's base URL
* @param options - Configuration object containing client info, auth code, etc.
* @returns Promise resolving to OAuth tokens
* @throws {Error} When token exchange fails or authentication is invalid
*/
async function exchangeAuthorization(authorizationServerUrl, { metadata, clientInformation, authorizationCode, iss, codeVerifier, redirectUri, resource, addClientAuthentication, dpop, fetchFn }) {
	validateAuthorizationResponseIssuer({
		iss,
		expectedIssuer: metadata?.issuer,
		issParameterSupported: isIssParameterSupported(metadata)
	});
	return executeTokenRequest(authorizationServerUrl, {
		metadata,
		tokenRequestParams: prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri),
		clientInformation,
		addClientAuthentication,
		resource,
		dpop,
		fetchFn
	});
}
/**
* Exchange a refresh token for an updated access token.
*
* Supports multiple client authentication methods as specified in OAuth 2.1:
* - Automatically selects the best authentication method based on server support
* - Preserves the original refresh token if a new one is not returned
*
* @param authorizationServerUrl - The authorization server's base URL
* @param options - Configuration object containing client info, refresh token, etc.
* @returns Promise resolving to OAuth tokens (preserves original `refresh_token` if not replaced)
* @throws {Error} When token refresh fails or authentication is invalid
*/
async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, dpop, fetchFn }) {
	return {
		refresh_token: refreshToken,
		...await executeTokenRequest(authorizationServerUrl, {
			metadata,
			tokenRequestParams: new URLSearchParams({
				grant_type: "refresh_token",
				refresh_token: refreshToken
			}),
			clientInformation,
			addClientAuthentication,
			resource,
			dpop,
			fetchFn
		})
	};
}
/**
* Unified token fetching that works with any grant type via {@linkcode OAuthClientProvider.prepareTokenRequest | prepareTokenRequest()}.
*
* This function provides a single entry point for obtaining tokens regardless of the
* OAuth grant type. The provider's `prepareTokenRequest()` method determines which grant
* to use and supplies the grant-specific parameters.
*
* @param provider - OAuth client provider that implements `prepareTokenRequest()`
* @param authorizationServerUrl - The authorization server's base URL
* @param options - Configuration for the token request
* @returns Promise resolving to OAuth tokens
* @throws {Error} When provider doesn't implement `prepareTokenRequest` or token fetch fails
*
* @example
* ```ts source="./auth.examples.ts#fetchToken_clientCredentials"
* // Provider for client_credentials:
* class MyProvider extends MyProviderBase implements OAuthClientProvider {
*     prepareTokenRequest(scope?: string) {
*         const params = new URLSearchParams({ grant_type: 'client_credentials' });
*         if (scope) params.set('scope', scope);
*         return params;
*     }
* }
*
* const tokens = await fetchToken(new MyProvider(), authServerUrl, { metadata });
* ```
*/
async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, iss, scope, fetchFn } = {}) {
	if (authorizationCode !== void 0) validateAuthorizationResponseIssuer({
		iss,
		expectedIssuer: metadata?.issuer,
		issParameterSupported: isIssParameterSupported(metadata)
	});
	const issuer = metadata?.issuer ?? String(authorizationServerUrl);
	const readClientInformation = async () => {
		const rawClientInfo = await provider.clientInformation({ issuer });
		const checked = discardIfIssuerMismatch(rawClientInfo, issuer, { canPersistStamp: false });
		if (rawClientInfo && checked === void 0) throw new AuthorizationServerMismatchError(String(rawClientInfo.issuer), issuer);
		return checked;
	};
	let clientInformation = await readClientInformation();
	const effectiveScope = scope ?? provider.clientMetadata.scope;
	let tokenRequestParams;
	if (provider.prepareTokenRequest) tokenRequestParams = await provider.prepareTokenRequest(effectiveScope);
	if (!tokenRequestParams) {
		if (!authorizationCode) throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
		if (!provider.redirectUrl) throw new Error("redirectUrl is required for authorization_code flow");
		tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, await provider.codeVerifier(), provider.redirectUrl);
	}
	clientInformation ??= await readClientInformation();
	return executeTokenRequest(authorizationServerUrl, {
		metadata,
		tokenRequestParams,
		clientInformation,
		addClientAuthentication: provider.addClientAuthentication,
		resource,
		dpop: await provider.dpop?.(),
		fetchFn
	});
}
/**
* Performs OAuth 2.0 Dynamic Client Registration according to
* {@link https://datatracker.ietf.org/doc/html/rfc7591 | RFC 7591}.
*
* If `scope` is provided, it overrides `clientMetadata.scope` in the registration
* request body. This allows callers to apply the Scope Selection Strategy (SEP-835)
* consistently across both DCR and the subsequent authorization request.
*
* @deprecated Dynamic Client Registration is deprecated as of protocol version
* 2026-07-28 in favor of Client ID Metadata Documents (SEP-991); the deprecation
* landed via spec PR
* {@link https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2858 | modelcontextprotocol#2858}
* (SEP-2577 is the separate roots/sampling/logging deprecation). Remains
* functional during the deprecation window — at least twelve months under the
* feature lifecycle policy (SEP-2596), so 2027-07-28 is the earliest possible
* removal date. Prefer a CIMD URL `client_id` when the authorization server
* advertises `client_id_metadata_document_supported`: the built-in `auth()` flow
* skips registration for you when that capability is advertised AND your
* provider supplies `clientMetadataUrl`, but `registerClient` itself does not
* gate — calling it directly always sends the registration request.
*/
async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
	let registrationUrl;
	if (metadata) {
		if (!metadata.registration_endpoint) throw new Error("Incompatible auth server: does not support dynamic client registration");
		registrationUrl = new URL(metadata.registration_endpoint);
	} else registrationUrl = new URL("/register", authorizationServerUrl);
	const submittedMetadata = {
		...clientMetadata,
		...scope === void 0 ? {} : { scope }
	};
	const response = await require_src.fetchWithinOrigin(fetchFn ?? fetch)(registrationUrl, {
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify(submittedMetadata)
	});
	if (!response.ok) throw new RegistrationRejectedError({
		status: response.status,
		body: await response.text(),
		submittedMetadata
	});
	return _modelcontextprotocol_core_internal.OAuthClientInformationFullSchema.parse(require_src.withoutIssuer(await response.json()));
}

//#endregion
//#region src/client/authExtensions.ts
/**
* Helper to produce a `private_key_jwt` client authentication function.
*
* @example
* ```ts source="./authExtensions.examples.ts#createPrivateKeyJwtAuth_basicUsage"
* const addClientAuth = createPrivateKeyJwtAuth({
*     issuer: 'my-client',
*     subject: 'my-client',
*     privateKey: pemEncodedPrivateKey,
*     alg: 'RS256'
* });
* // pass addClientAuth as provider.addClientAuthentication implementation
* ```
*/
function createPrivateKeyJwtAuth(options) {
	return async (_headers, params, url, metadata) => {
		if (globalThis.crypto === void 0) throw new TypeError("crypto is not available, please ensure you have Web Crypto API support for older Node.js versions (see https://github.com/modelcontextprotocol/typescript-sdk#nodejs-web-crypto-globalthiscrypto-compatibility)");
		const jose = await import("jose");
		const audience = String(options.audience ?? metadata?.issuer ?? url);
		const lifetimeSeconds = options.lifetimeSeconds ?? 300;
		const now = Math.floor(Date.now() / 1e3);
		const jti = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
		const baseClaims = {
			iss: options.issuer,
			sub: options.subject,
			aud: audience,
			exp: now + lifetimeSeconds,
			iat: now,
			jti
		};
		const claims = options.claims ? {
			...baseClaims,
			...options.claims
		} : baseClaims;
		const alg = options.alg;
		let key;
		if (typeof options.privateKey === "string") if (alg.startsWith("RS") || alg.startsWith("ES") || alg.startsWith("PS")) key = await jose.importPKCS8(options.privateKey, alg);
		else if (alg.startsWith("HS")) key = new TextEncoder().encode(options.privateKey);
		else throw new Error(`Unsupported algorithm ${alg}`);
		else if (options.privateKey instanceof Uint8Array) key = alg.startsWith("HS") ? options.privateKey : await jose.importPKCS8(new TextDecoder().decode(options.privateKey), alg);
		else key = await jose.importJWK(options.privateKey, alg);
		const assertion = await new jose.SignJWT(claims).setProtectedHeader({
			alg,
			typ: "JWT"
		}).setIssuer(options.issuer).setSubject(options.subject).setAudience(audience).setIssuedAt(now).setExpirationTime(now + lifetimeSeconds).setJti(jti).sign(key);
		params.set("client_assertion", assertion);
		params.set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");
	};
}
/**
* The `issuer` stamp for constructor-supplied client information. Omitting `expectedIssuer` is
* deprecated: nothing else says which authorization server such credentials belong to.
*/
function checkedExpectedIssuer(expectedIssuer) {
	if (expectedIssuer === void 0) console.warn("[mcp-sdk] Omitting `expectedIssuer` is deprecated. Without it, the MCP server decides which authorization server receives this client's credentials; pass your authorization server's issuer URL as `expectedIssuer` so they are only sent there.");
	else if (typeof expectedIssuer !== "string" || !expectedIssuer) throw new Error("expectedIssuer must be the authorization server's issuer URL");
	return expectedIssuer;
}
/**
* OAuth provider for `client_credentials` grant with `client_secret_basic` authentication.
*
* This provider is designed for machine-to-machine authentication where
* the client authenticates using a `client_id` and `client_secret`.
*
* @example
* ```ts source="./authExtensions.examples.ts#ClientCredentialsProvider_basicUsage"
* const provider = new ClientCredentialsProvider({
*     clientId: 'my-client',
*     clientSecret: 'my-secret',
*     expectedIssuer: 'https://auth.example.com'
* });
*
* const transport = new StreamableHTTPClientTransport(serverUrl, {
*     authProvider: provider
* });
* ```
*/
var ClientCredentialsProvider = class {
	_tokens;
	_clientInfo;
	_clientMetadata;
	constructor(options) {
		this._clientInfo = {
			client_id: options.clientId,
			client_secret: options.clientSecret,
			issuer: checkedExpectedIssuer(options.expectedIssuer)
		};
		this._clientMetadata = {
			client_name: options.clientName ?? "client-credentials-client",
			redirect_uris: [],
			grant_types: ["client_credentials"],
			token_endpoint_auth_method: "client_secret_basic",
			scope: options.scope
		};
	}
	get redirectUrl() {}
	get clientMetadata() {
		return this._clientMetadata;
	}
	clientInformation() {
		return this._clientInfo;
	}
	tokens() {
		return this._tokens;
	}
	saveTokens(tokens) {
		this._tokens = tokens;
	}
	redirectToAuthorization() {
		throw new Error("redirectToAuthorization is not used for client_credentials flow");
	}
	saveCodeVerifier() {}
	codeVerifier() {
		throw new Error("codeVerifier is not used for client_credentials flow");
	}
	prepareTokenRequest(scope) {
		const params = new URLSearchParams({ grant_type: "client_credentials" });
		if (scope) params.set("scope", scope);
		return params;
	}
};
/**
* OAuth provider for `client_credentials` grant with `private_key_jwt` authentication.
*
* This provider is designed for machine-to-machine authentication where
* the client authenticates using a signed JWT assertion
* ({@link https://datatracker.ietf.org/doc/html/rfc7523#section-2.2 | RFC 7523 Section 2.2}).
*
* @example
* ```ts source="./authExtensions.examples.ts#PrivateKeyJwtProvider_basicUsage"
* const provider = new PrivateKeyJwtProvider({
*     clientId: 'my-client',
*     privateKey: pemEncodedPrivateKey,
*     algorithm: 'RS256',
*     expectedIssuer: 'https://auth.example.com'
* });
*
* const transport = new StreamableHTTPClientTransport(serverUrl, {
*     authProvider: provider
* });
* ```
*/
var PrivateKeyJwtProvider = class {
	_tokens;
	_clientInfo;
	_clientMetadata;
	addClientAuthentication;
	constructor(options) {
		this._clientInfo = {
			client_id: options.clientId,
			issuer: checkedExpectedIssuer(options.expectedIssuer)
		};
		this._clientMetadata = {
			client_name: options.clientName ?? "private-key-jwt-client",
			redirect_uris: [],
			grant_types: ["client_credentials"],
			token_endpoint_auth_method: "private_key_jwt",
			scope: options.scope
		};
		this.addClientAuthentication = createPrivateKeyJwtAuth({
			issuer: options.clientId,
			subject: options.clientId,
			privateKey: options.privateKey,
			alg: options.algorithm,
			lifetimeSeconds: options.jwtLifetimeSeconds,
			claims: options.claims
		});
	}
	get redirectUrl() {}
	get clientMetadata() {
		return this._clientMetadata;
	}
	clientInformation() {
		return this._clientInfo;
	}
	tokens() {
		return this._tokens;
	}
	saveTokens(tokens) {
		this._tokens = tokens;
	}
	redirectToAuthorization() {
		throw new Error("redirectToAuthorization is not used for client_credentials flow");
	}
	saveCodeVerifier() {}
	codeVerifier() {
		throw new Error("codeVerifier is not used for client_credentials flow");
	}
	prepareTokenRequest(scope) {
		const params = new URLSearchParams({ grant_type: "client_credentials" });
		if (scope) params.set("scope", scope);
		return params;
	}
};
/**
* OAuth provider for `client_credentials` grant with a static `private_key_jwt` assertion.
*
* This provider mirrors {@linkcode PrivateKeyJwtProvider} but instead of constructing and
* signing a JWT on each request, it accepts a pre-built JWT assertion string and
* uses it directly for authentication.
*/
var StaticPrivateKeyJwtProvider = class {
	_tokens;
	_clientInfo;
	_clientMetadata;
	addClientAuthentication;
	constructor(options) {
		this._clientInfo = {
			client_id: options.clientId,
			issuer: checkedExpectedIssuer(options.expectedIssuer)
		};
		this._clientMetadata = {
			client_name: options.clientName ?? "static-private-key-jwt-client",
			redirect_uris: [],
			grant_types: ["client_credentials"],
			token_endpoint_auth_method: "private_key_jwt",
			scope: options.scope
		};
		const assertion = options.jwtBearerAssertion;
		this.addClientAuthentication = async (_headers, params) => {
			params.set("client_assertion", assertion);
			params.set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");
		};
	}
	get redirectUrl() {}
	get clientMetadata() {
		return this._clientMetadata;
	}
	clientInformation() {
		return this._clientInfo;
	}
	tokens() {
		return this._tokens;
	}
	saveTokens(tokens) {
		this._tokens = tokens;
	}
	redirectToAuthorization() {
		throw new Error("redirectToAuthorization is not used for client_credentials flow");
	}
	saveCodeVerifier() {}
	codeVerifier() {
		throw new Error("codeVerifier is not used for client_credentials flow");
	}
	prepareTokenRequest(scope) {
		const params = new URLSearchParams({ grant_type: "client_credentials" });
		if (scope) params.set("scope", scope);
		return params;
	}
};
/**
* OAuth provider for Cross-App Access (Enterprise Managed Authorization) using JWT Authorization Grant.
*
* This provider implements the Enterprise Managed Authorization flow (SEP-990) where:
* 1. User authenticates with an enterprise IdP and the client obtains an ID Token
* 2. Client exchanges the ID Token for a JWT Authorization Grant (ID-JAG) via RFC 8693 token exchange
* 3. Client uses the JAG to obtain an access token from the MCP server via RFC 7523 JWT bearer grant
*
* The provider handles steps 2-3 automatically, with the JAG acquisition delegated to
* a callback function that you provide. This allows flexibility in how you obtain and
* cache ID Tokens from the IdP.
*
* @see https://github.com/modelcontextprotocol/ext-auth/blob/main/specification/stable/enterprise-managed-authorization.mdx
*
* @example
* ```ts
* const provider = new CrossAppAccessProvider({
*     assertion: async (ctx) => {
*         const result = await discoverAndRequestJwtAuthGrant({
*             idpUrl: 'https://idp.example.com',
*             audience: ctx.authorizationServerUrl,
*             resource: ctx.resourceUrl,
*             idToken: await getIdToken(), // Your function to get ID token
*             clientId: 'my-idp-client',
*             clientSecret: 'my-idp-secret',
*             scope: ctx.scope,
*             fetchFn: ctx.fetchFn
*         });
*         return result.jwtAuthGrant;
*     },
*     clientId: 'my-mcp-client',
*     clientSecret: 'my-mcp-secret',
*     expectedIssuer: 'https://auth.example.com'
* });
*
* const transport = new StreamableHTTPClientTransport(serverUrl, {
*     authProvider: provider
* });
* ```
*/
var CrossAppAccessProvider = class {
	_tokens;
	_clientInfo;
	_clientMetadata;
	_assertionCallback;
	_fetchFn;
	_authorizationServerUrl;
	_resourceUrl;
	_scope;
	constructor(options) {
		this._clientInfo = {
			client_id: options.clientId,
			client_secret: options.clientSecret,
			issuer: checkedExpectedIssuer(options.expectedIssuer)
		};
		this._clientMetadata = {
			client_name: options.clientName ?? "cross-app-access-client",
			redirect_uris: [],
			grant_types: ["urn:ietf:params:oauth:grant-type:jwt-bearer"],
			token_endpoint_auth_method: "client_secret_basic"
		};
		this._assertionCallback = options.assertion;
		this._fetchFn = options.fetchFn ?? fetch;
	}
	get redirectUrl() {}
	get clientMetadata() {
		return this._clientMetadata;
	}
	clientInformation() {
		return this._clientInfo;
	}
	tokens() {
		return this._tokens;
	}
	saveTokens(tokens) {
		this._tokens = tokens;
	}
	redirectToAuthorization() {
		throw new Error("redirectToAuthorization is not used for jwt-bearer flow");
	}
	saveCodeVerifier() {}
	codeVerifier() {
		throw new Error("codeVerifier is not used for jwt-bearer flow");
	}
	/**
	* Saves the authorization server URL discovered during OAuth flow.
	* This is called by the auth() function after RFC 9728 discovery.
	*/
	saveAuthorizationServerUrl(authorizationServerUrl) {
		this._authorizationServerUrl = authorizationServerUrl;
	}
	/**
	* Returns the cached authorization server URL if available.
	*/
	authorizationServerUrl() {
		return this._authorizationServerUrl;
	}
	/**
	* Saves the resource URL discovered during OAuth flow.
	* This is called by the auth() function after RFC 9728 discovery.
	*/
	saveResourceUrl(resourceUrl) {
		this._resourceUrl = resourceUrl;
	}
	/**
	* Returns the cached resource URL if available.
	*/
	resourceUrl() {
		return this._resourceUrl;
	}
	async prepareTokenRequest(scope) {
		const authServerUrl = this._authorizationServerUrl;
		const resourceUrl = this._resourceUrl;
		if (!authServerUrl) throw new Error("Authorization server URL not available. Ensure auth() has been called first.");
		if (!resourceUrl) throw new Error("Resource URL not available — server may not implement RFC 9728 Protected Resource Metadata (required for Cross-App Access), or auth() has not been called");
		this._scope = scope;
		const jwtAuthGrant = await this._assertionCallback({
			authorizationServerUrl: authServerUrl,
			resourceUrl,
			scope: this._scope,
			fetchFn: this._fetchFn
		});
		const params = new URLSearchParams({
			grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
			assertion: jwtAuthGrant
		});
		if (scope) params.set("scope", scope);
		return params;
	}
};

//#endregion
//#region src/client/responseCache.ts
/**
* Methods whose entries are exempt from the
* {@linkcode InMemoryResponseCacheStoreOptions.maxEntries} cap. Each holds at
* most one entry per partition (a small bounded set) and the
* `tools/list`-derived index depends on its entry surviving regardless of the
* `resources/read` working-set size. Only `resources/read` keys count toward
* the cap and are eligible for FIFO eviction.
*/
const CAP_EXEMPT_METHODS = new Set([
	"tools/list",
	"prompts/list",
	"resources/list",
	"resources/templates/list",
	"server/discover"
]);
/**
* In-memory default. Bounded by an insertion-ordered size cap (default `512`;
* see {@linkcode InMemoryResponseCacheStoreOptions.maxEntries}) on the
* `resources/read` keyspace so an unbounded stream of distinct URIs cannot
* grow it without limit; the list-singleton methods are exempt and never
* evicted by the cap. `Map` preserves insertion order, so the oldest live
* capped key is the first matching iteration entry.
*/
var InMemoryResponseCacheStore = class {
	_entries = /* @__PURE__ */ new Map();
	_maxEntries;
	_stamp = 0;
	/** Count of held entries that are subject to the cap (i.e. not in {@linkcode CAP_EXEMPT_METHODS}). */
	_cappedSize = 0;
	constructor(options) {
		this._maxEntries = options?.maxEntries ?? 512;
	}
	/** Number of held entries (for diagnostics / bounding tests). */
	get size() {
		return this._entries.size;
	}
	get(key) {
		return this._entries.get(keyOf(key));
	}
	set(key, entry) {
		const k = keyOf(key);
		const exempt = CAP_EXEMPT_METHODS.has(key.method);
		const isNew = !this._entries.has(k);
		if (!exempt && isNew && this._maxEntries > 0 && this._cappedSize >= this._maxEntries) {
			for (const oldKey of this._entries.keys()) if (!CAP_EXEMPT_METHODS.has(oldKey.slice(0, oldKey.indexOf("\0")))) {
				this._entries.delete(oldKey);
				this._cappedSize--;
				break;
			}
		}
		const stamp = ++this._stamp;
		this._entries.set(k, {
			...entry,
			stamp
		});
		if (isNew && !exempt) this._cappedSize++;
		return stamp;
	}
	delete(key) {
		if (this._entries.delete(keyOf(key)) && !CAP_EXEMPT_METHODS.has(key.method)) this._cappedSize--;
	}
	evict(method) {
		const prefix = `${method}\0`;
		const exempt = CAP_EXEMPT_METHODS.has(method);
		for (const k of this._entries.keys()) if (k.startsWith(prefix)) {
			this._entries.delete(k);
			if (!exempt) this._cappedSize--;
		}
	}
	clear() {
		this._entries.clear();
		this._cappedSize = 0;
	}
};
/**
* Serialize a {@linkcode CacheKey} for the in-memory map. `method` is always
* an SDK-set MCP method string (never contains a NUL), so the `\0` prefix
* delimiter is safe and lets {@linkcode InMemoryResponseCacheStore.evict} do a
* cheap prefix scan. `partition` (already a JSON-encoded
* `[serverIdentity, principal]` pair) and `params` (a resource URI on the
* `resources/read` path — caller-controlled) are JSON-array-encoded together,
* which is collision-free regardless of any NUL or delimiter characters they
* carry.
*/
function keyOf(key) {
	return `${key.method}\0${JSON.stringify([key.partition ?? "", key.params ?? ""])}`;
}
/**
* Serialize a `{method, params}` pair for the eviction-generation map. The
* list singletons key on `method` alone (their {@linkcode ClientResponseCache.evict}
* is whole-method); `resources/read` keys on `` `${method}\0${uri}` `` so
* {@linkcode ClientResponseCache.evictKey} bumps a per-URI counter.
*/
function genKey(method, params) {
	return params === void 0 ? method : `${method}\0${params}`;
}
/**
* Upper bound on the server-supplied `ttlMs` honoured by
* {@linkcode ClientResponseCache} (24h). A server cannot pin an entry
* indefinitely.
*/
const MAX_CACHE_TTL_MS = 864e5;
/**
* The `Client`'s cache-coordination collaborator.
*
* Owns the per-connection cache state that used to live as five private
* fields on `Client` — the backing {@linkcode ResponseCacheStore}, the
* per-method eviction-generation counter, the user-supplied/default flag, and
* the stamp-memoized derived indices over the `tools/list` entry. `Client`
* holds exactly one instance and never reaches past it to the store.
*
* Not exported from the package index — internal to the client package.
*
* @internal
*/
var ClientResponseCache = class {
	/**
	* Per-logical-key eviction-generation counter. {@linkcode evict} (whole
	* method) and {@linkcode evictKey} (single `{method, params}`) bump it
	* before touching the store; {@linkcode captureGeneration} reads it before
	* the request; {@linkcode write} skips when it moved — so a `list_changed`
	* arriving mid-walk, or a `resources/updated` arriving while a
	* `readResource()` for the same URI is in flight, is not overwritten by
	* the in-flight request's stale write. The map key is `method` for the
	* list singletons and `` `${method}\0${params}` `` for per-URI keys.
	*
	* Growth is bounded by keys the CLIENT has issued a `captureGeneration`
	* for: {@linkcode captureGeneration} records the key (so an interleaved
	* {@linkcode evictKey} sees there is an in-flight write to suppress);
	* {@linkcode evictKey} only bumps a key that is already recorded — a
	* server streaming `notifications/resources/updated` for URIs the client
	* has never read therefore cannot grow this map.
	*/
	_evictionGeneration = /* @__PURE__ */ new Map();
	/**
	* `name → Tool` index derived from the cached `tools/list` entry, memoized
	* against the entry's `stamp` so it re-derives only when the backing entry
	* changes (mcp.d's `cachedTool` pattern).
	*/
	_toolIndex;
	/**
	* `name → compiled output-schema validator` derived from the cached
	* `tools/list` entry; same stamp-keyed memoization as `_toolIndex`. Typed
	* `unknown` so this class stays free of any validator-provider dependency
	* — the compile callback supplied to {@linkcode outputValidator} owns the
	* concrete type.
	*/
	_toolOutputValidatorIndex;
	/**
	* The connected server's identity (`serverInfo.name@version`, the
	* transport's `sessionId`, or a client-generated per-connection
	* surrogate). Set by the `Client` immediately after a successful connect;
	* `''` is the pre-connect sentinel. Every storage partition is derived
	* from this (see `_partitionFor`), so two clients sharing one store but
	* connected to different servers never collide on `tools/list` and a
	* server cannot read another server's `'public'` entries.
	*/
	_serverIdentity = "";
	constructor(_store, _isUserSupplied, _reportError = () => {}, _cachePartition = "", _now = Date.now) {
		this._store = _store;
		this._isUserSupplied = _isUserSupplied;
		this._reportError = _reportError;
		this._cachePartition = _cachePartition;
		this._now = _now;
	}
	/** The clock used for every freshness computation and check. */
	now() {
		return this._now();
	}
	/**
	* Record the connected server's identity. Called by `Client` immediately
	* after a successful connect: `serverInfo.name@version` when the server
	* identified itself, else the transport's `sessionId`, else a
	* client-generated per-connection surrogate (`serverInfo` is a spec
	* SHOULD on 2026-07-28, so anonymous servers exist). Surrogate-keyed
	* partitions are NOT stable across reconnects — no identity means no
	* cross-connection cache reuse, and a shared long-lived store should
	* bound its own size accordingly. Every partition derived after this
	* call is scoped to this identity; entries written under the pre-connect
	* `''` sentinel are no longer reachable.
	*/
	setServerIdentity(identity) {
		this._serverIdentity = identity;
	}
	/**
	* Derive the storage partition for `scope`. The encoding is
	* `JSON.stringify([serverIdentity, principal])` — JSON escaping makes it
	* collision-free by construction: a malicious server cannot craft a
	* `serverInfo.name`/`version` whose concatenated form bleeds into another
	* server's namespace or another principal's slot, regardless of `@` / `|`
	* / `"` / NUL in the server-controlled strings. `'public'` →
	* `[serverIdentity, '']` (shared within this server); `'private'` →
	* `[serverIdentity, cachePartition]`. When `cachePartition` is `''` the
	* two coincide.
	*/
	_partitionFor(scope) {
		return JSON.stringify([this._serverIdentity, scope === "public" ? "" : this._cachePartition]);
	}
	/**
	* Two-probe lookup: this client's own (private) partition first, then the
	* connected server's shared (public) partition. The shared probe is gated
	* on `entry.scope === 'public'` — a co-tenant client that omits
	* `cachePartition` writes its `'private'`-scoped entries at the public
	* partition, and serving those to a correctly-partitioned client would
	* leak private bodies (mcp.d's `cachedEntry` two-probe order; the scope
	* gate is defence-in-depth on top of the partition split). When
	* `cachePartition` is `''` the two partitions are identical and only one
	* probe is issued.
	*/
	async _probe(method, params) {
		const key = {
			method,
			params: params ?? ""
		};
		const ownPartition = this._partitionFor("private");
		const own = await this._store.get({
			...key,
			partition: ownPartition
		});
		if (own !== void 0) return own;
		const sharedPartition = this._partitionFor("public");
		if (sharedPartition === ownPartition) return void 0;
		const shared = await this._store.get({
			...key,
			partition: sharedPartition
		});
		return shared?.scope === "public" ? shared : void 0;
	}
	/**
	* Bump the per-method generation (so an in-flight {@linkcode write} for the
	* same method becomes a no-op) and drop the connected server's two list
	* singletons (own + shared partition; `params: ''`). The generation bump
	* is unconditional and FIRST — the {@linkcode write} race guard relies on
	* the bump, not on the store's deletes completing.
	*
	* Eviction is scoped to this client's `[serverIdentity, principal]`
	* partitions (mirroring {@linkcode evictKey}) — the method-wide
	* `store.evict()` is NOT called, so on a shared store one server's
	* `list_changed` cannot wipe a co-tenant's entry. A custom store's
	* `delete()` may throw or reject; each partition is guarded
	* independently so a failure on one does not skip the other, the failure
	* is reported via the constructor's sink, and the call resolves so
	* dispatch proceeds.
	*/
	async evict(method) {
		this._evictionGeneration.set(method, (this._evictionGeneration.get(method) ?? 0) + 1);
		await this._deleteBoth(method, "");
	}
	/**
	* Guarded two-partition delete of `{method, params}`: each partition's
	* `delete` is independently wrapped so a custom store's failure on one is
	* reported and does not skip the other, and the call always resolves.
	*/
	async _deleteBoth(method, params) {
		const ownPartition = this._partitionFor("private");
		const sharedPartition = this._partitionFor("public");
		try {
			await this._store.delete({
				method,
				params,
				partition: ownPartition
			});
		} catch (error) {
			this._reportError(error);
		}
		if (sharedPartition !== ownPartition) try {
			await this._store.delete({
				method,
				params,
				partition: sharedPartition
			});
		} catch (error) {
			this._reportError(error);
		}
	}
	/**
	* Drop the single logical entry `{method, params}` from BOTH the private
	* and public partitions for this client's connected server (mcp.d's
	* `invalidateLogical`). Used for `notifications/resources/updated`'s
	* per-URI eviction. The per-key generation is bumped FIRST (so an
	* in-flight {@linkcode write} for the same `{method, params}` becomes a
	* no-op and cannot re-cache the now-stale body) but only when the key was
	* already recorded by {@linkcode captureGeneration} — bounding the map to
	* keys the client has actually read. A custom store's `delete()` may
	* throw or reject; each partition's delete is guarded independently so a
	* failure on one does not skip the other, and the call resolves so
	* dispatch proceeds.
	*/
	async evictKey(method, params) {
		const gk = genKey(method, params);
		const current = this._evictionGeneration.get(gk);
		if (current !== void 0) this._evictionGeneration.set(gk, current + 1);
		await this._deleteBoth(method, params);
	}
	/**
	* Snapshot the eviction generation for `{method, params}` before issuing
	* the request (a list walk's page 1, or a `resources/read` for `params`).
	* Records the key so an interleaved {@linkcode evictKey} for the same
	* `{method, params}` knows there is an in-flight write to suppress and
	* bumps; without the record, `evictKey`'s recorded-only bump would skip
	* and the stale body would be cached.
	*/
	captureGeneration(method, params) {
		const gk = genKey(method, params);
		const current = this._evictionGeneration.get(gk) ?? 0;
		this._evictionGeneration.set(gk, current);
		return current;
	}
	/**
	* Write `value` under `{method}` unless the per-method generation moved
	* since `capturedGen` was taken — a `list_changed` that landed mid-walk has
	* already invalidated the result the caller is about to write, and
	* overwriting the eviction with the stale aggregate would lose the
	* invalidation.
	*
	* The value is stored as its JSON-serialized document; serialization
	* doubles as the mutation barrier, so a caller mutating the returned
	* aggregate cannot reach the cache or its derived indices. A value that
	* is not JSON-serializable (reachable only via in-process transports)
	* fails the write loudly into the `reportError` sink. A custom store
	* whose `set()` throws or rejects is routed to the same sink and the
	* write resolves — cache bookkeeping never costs the caller a result it
	* already fetched.
	*
	* `freshness` carries the client-computed `expiresAt` (absolute ms epoch,
	* `now + ttlMs`) and the server-reported `cacheScope`. The storage
	* `partition` is derived from the scope via `_partitionFor`:
	* `'public'` → `[serverIdentity, '']` (shared within this server);
	* `'private'` → `[serverIdentity, cachePartition]` (so a shared store
	* never serves a private entry to another identity). Absent `freshness`
	* preserves the substrate write (no `expiresAt`, private partition) — the
	* `tools/list` retain-for-schema posture: never served by
	* {@linkcode read}'s freshness gate, always readable by
	* {@linkcode toolDefinition}.
	*
	* After storing under the derived partition, the same `{method, params}`
	* is deleted from the OPPOSITE partition (mirroring {@linkcode evictKey}'s
	* two-partition posture). A server that flips a result's `cacheScope` for
	* the same key would otherwise leave the previous entry in the other slot
	* — and since `_probe` checks own-partition first, a stale private entry
	* would shadow the fresh public one (or a stale public entry would keep
	* serving co-tenants). Both store calls are independently guarded so a
	* custom store's failure on one does not skip the other.
	*/
	async write(method, value, capturedGen, freshness) {
		if ((this._evictionGeneration.get(genKey(method, freshness?.params)) ?? 0) !== capturedGen) return;
		const params = freshness?.params ?? "";
		const ownPartition = this._partitionFor("private");
		const sharedPartition = this._partitionFor("public");
		const partition = (freshness?.scope ?? "private") === "public" ? sharedPartition : ownPartition;
		try {
			await this._store.set({
				method,
				params,
				partition
			}, {
				value: encodeCacheValue(value),
				expiresAt: freshness?.expiresAt,
				scope: freshness?.scope
			});
		} catch (error) {
			this._reportError(error);
		}
		if (sharedPartition !== ownPartition) try {
			await this._store.delete({
				method,
				params,
				partition: partition === ownPartition ? sharedPartition : ownPartition
			});
		} catch (error) {
			this._reportError(error);
		}
	}
	/**
	* Serve the fresh cached result for `{method, params}`, or `undefined`.
	* Lookup is the two-probe order (own-partition then this server's shared
	* partition, gated on `scope === 'public'`); freshness is
	* `entry.expiresAt > now()` (a missing `expiresAt` is never fresh),
	* checked BEFORE decoding so stale entries cost no parse. Every hit is
	* freshly parsed, so the caller owns the value outright. An entry whose
	* document does not parse or is not an object (corrupted external
	* store) is reported,
	* deleted, and treated as a miss — deleted because a fresh-but-corrupt
	* entry would otherwise re-parse and re-report on every read until its
	* `expiresAt` passes.
	*/
	async read(method, params) {
		const entry = await this._probe(method, params);
		if (entry?.expiresAt === void 0 || !(entry.expiresAt > this.now())) return void 0;
		try {
			const parsed = JSON.parse(entry.value);
			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("cached document is not an object");
			return { value: parsed };
		} catch (error) {
			this._reportError(error);
			await this._deleteBoth(method, params ?? "");
			return;
		}
	}
	/**
	* Connection reset. The per-instance default store IS cleared
	* (connection-scoped); a user-supplied store is NOT — that would defeat
	* the only reason to supply one. The generation map and every derived
	* index are dropped regardless: they are connection-scoped even when the
	* backing store survives, so the next read re-derives from whatever the
	* store still holds. The server identity returns to the pre-connect
	* sentinel. The default impl is synchronous, so the `MaybePromise<void>`
	* return is a plain void here and the caller need not await.
	*/
	resetForReconnect() {
		if (!this._isUserSupplied) this._store.clear();
		this._evictionGeneration.clear();
		this._toolIndex = void 0;
		this._toolOutputValidatorIndex = void 0;
		this._serverIdentity = "";
	}
	/**
	* The descriptor for tool `name` taken from the cached `tools/list` entry.
	* The `name → Tool` index is memoized against the entry's `stamp` and
	* re-derived only when the backing entry changes (mcp.d's `cachedTool`).
	* Returns `undefined` only when no `tools/list` response is held at all,
	* or the held list does not contain `name`.
	*
	* Consumed by `callTool()`'s SEP-2243 `_resolveXMcpHeaderScan` (mirroring)
	* and, via {@linkcode outputValidator}, its output-schema validation.
	*/
	async toolDefinition(name) {
		const entry = await this._probe("tools/list");
		if (entry === void 0) {
			this._toolIndex = void 0;
			return;
		}
		if (this._toolIndex?.stamp !== entry.stamp) {
			const list = this._decodeListTools(entry);
			const byName = /* @__PURE__ */ new Map();
			if (list !== void 0) for (const tool of list.tools) byName.set(tool.name, tool);
			this._toolIndex = {
				stamp: entry.stamp,
				byName
			};
		}
		return this._toolIndex.byName.get(name);
	}
	/**
	* The compiled output-schema validator for tool `name`, derived from the
	* cached `tools/list` entry — same source and same stamp-keyed
	* memoization as {@linkcode toolDefinition}. The `name → validator` index
	* re-derives only when the backing entry's stamp changes (a refetched
	* `tools/list` recompiles; a `list_changed` eviction drops it). Returns
	* `undefined` when no `tools/list` is held, the tool is absent, or it has
	* no `outputSchema`.
	*
	* `compile` is the caller-supplied validator-compile callback (the
	* `Client` passes its `_jsonSchemaValidator` wrapper) so this
	* class carries no validator-provider dependency. One tool's uncompilable
	* `outputSchema` (e.g. an invalid `pattern` regex or unresolvable `$ref`)
	* must not poison every other tool's `callTool` — the callback isolates
	* that compile error per tool by returning a per-tool error variant which
	* the index stores alongside the good ones, and `callTool` surfaces it as
	* a typed `InvalidParams` only for that name. Because the error is held on
	* this stamp-keyed substrate (not a parallel map), it inherits the
	* substrate's invalidation lifecycle: a `list_changed` eviction drops it,
	* a refetched `tools/list` re-derives it, and `resetForReconnect` clears
	* the lot.
	*/
	async outputValidator(name, compile) {
		const entry = await this._probe("tools/list");
		if (entry === void 0) {
			this._toolOutputValidatorIndex = void 0;
			return;
		}
		if (this._toolOutputValidatorIndex?.stamp !== entry.stamp) {
			const list = this._decodeListTools(entry) ?? { tools: [] };
			const byName = /* @__PURE__ */ new Map();
			for (const tool of list.tools) {
				const compiled = compile(tool);
				if (compiled !== void 0) byName.set(tool.name, compiled);
			}
			this._toolOutputValidatorIndex = {
				stamp: entry.stamp,
				byName
			};
		}
		return this._toolOutputValidatorIndex.byName.get(name);
	}
	/** Parse a held `tools/list` document for the index builders; a document
	* that does not parse OR whose `tools` is not an array of objects
	* (both mean a corrupted external store) is reported and treated as if
	* nothing were held. Callers memoize the outcome against the entry's
	* stamp, so a corrupt document costs one parse + report per stamp, not
	* per lookup. */
	_decodeListTools(entry) {
		try {
			const parsed = JSON.parse(entry.value);
			if (!Array.isArray(parsed?.tools) || !parsed.tools.every((t) => t !== null && typeof t === "object")) throw new TypeError("cached tools/list document has a malformed tools array");
			return parsed;
		} catch (error) {
			this._reportError(error);
			return;
		}
	}
};
/**
* Serialize a result for storage; throws TypeError for anything without a
* JSON representation (legal wire results always have one). Two failure
* modes need folding into that one throw: `JSON.stringify` throws on cycles
* and BigInt, but silently returns `undefined` (not a string) for a
* top-level function, symbol, or `undefined`.
*/
function encodeCacheValue(value) {
	let json;
	try {
		json = JSON.stringify(value);
	} catch (error) {
		throw new TypeError(`cache value is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`);
	}
	if (typeof json !== "string") throw new TypeError("cache value is not JSON-serializable: it has no JSON representation");
	return json;
}

//#endregion
//#region src/client/authSeam.ts
/**
* Auth-seam provenance stamp (internal — not part of the public API).
*
* Errors escaping a transport auth seam — the `authProvider.token()` read,
* an `onUnauthorized` invocation (SDK adapter or custom user callback), the
* 403 step-up flow, the transport's own auth-failure constructions — are
* stamped at the throw boundary. The version-negotiation probe routes stamped
* errors as auth outcomes; provenance is recorded where it is known, never
* reconstructed from error types downstream.
*
* `Symbol.for` uses the global symbol registry, so the stamp survives a
* duplicated SDK copy in one process (bundler double-install, version skew)
* by design: both copies resolve the same symbol.
*/
const AUTH_SEAM = Symbol.for("mcp.authSeamEscape");
/**
* Stamp `error` as an auth-seam escape and return it — identity-preserving
* (the same object flows on, `instanceof` and `.cause` chains intact). A
* frozen/sealed object is returned unstamped rather than replaced: identity
* outranks provenance. Primitive throws cannot carry the stamp.
*/
function markAuthSeamEscape(error) {
	if (typeof error === "object" && error !== null || typeof error === "function") try {
		Object.defineProperty(error, AUTH_SEAM, {
			value: true,
			configurable: true
		});
	} catch {}
	return error;
}
/** Whether `error` escaped through a transport auth seam. */
function isAuthSeamEscape(error) {
	return (typeof error === "object" && error !== null || typeof error === "function") && error[AUTH_SEAM] === true;
}

//#endregion
//#region src/client/probeClassifier.ts
/** The `-32022` UnsupportedProtocolVersion protocol error code (negotiation-phase recognition). */
const UNSUPPORTED_PROTOCOL_VERSION = -32022;
/**
* Deliberately not probe-recognized in either direction: deployed servers
* overload `-32001` (the SDK-conventional `Session not found` body on a 2025
* stateful server), and the spec-assigned `-32020` (`HeaderMismatch`) /
* `-32021` (`MissingRequiredClientCapability`) are not era evidence — all
* fall into the conservative legacy default.
*/
const NOT_PROBE_RECOGNIZED = new Set([
	-32001,
	-32020,
	-32021
]);
/**
* Classify a single probe outcome. Pure: no I/O, no state — loop-guard and
* retry state live in the caller.
*/
function classifyProbeOutcome(outcome, context) {
	switch (outcome.kind) {
		case "result": return classifyResult(outcome.result, context);
		case "rpc-error": return classifyRpcError(outcome, context);
		case "http-error": return classifyHttpError(outcome, context);
		case "network-error": return classifyNetworkError(outcome.error, context);
		case "unusable-reply": return {
			kind: "error",
			error: new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, `Version negotiation probe failed: the server answered with an unusable reply (${describeError(outcome.error)})`, { cause: outcome.error }, { cause: outcome.error })
		};
		case "auth-required": return {
			kind: "error",
			error: outcome.error
		};
		case "closed":
			if (context.transportKind === "stdio") return { kind: "legacy" };
			return classifyNetworkError(/* @__PURE__ */ new Error("Connection closed during the version negotiation probe"), context);
		case "timeout":
			if (context.transportKind === "stdio") return { kind: "legacy" };
			return {
				kind: "error",
				error: new require_src.SdkError(require_src.SdkErrorCode.RequestTimeout, `Version negotiation probe timed out after ${outcome.timeoutMs}ms`, { timeout: outcome.timeoutMs })
			};
	}
}
function classifyResult(result, context) {
	const parsed = require_src.codecForVersion(require_src.MODERN_WIRE_REVISION).validateResult("server/discover", result);
	if (!parsed.ok) return { kind: "legacy" };
	const supportedVersions = parsed.value.supportedVersions;
	const overlap = context.clientModernVersions.find((version) => supportedVersions.includes(version));
	if (overlap !== void 0) return {
		kind: "modern",
		version: overlap,
		discover: parsed.value
	};
	if (context.fallbackAvailable) return { kind: "legacy" };
	return {
		kind: "error",
		error: new require_src.UnsupportedProtocolVersionError({
			supported: [...supportedVersions],
			requested: context.requestedVersion
		})
	};
}
function classifyRpcError(outcome, context) {
	const { code, message, data } = outcome;
	if (code === UNSUPPORTED_PROTOCOL_VERSION) {
		const supported = parseSupportedList(data);
		if (supported === void 0) return { kind: "legacy" };
		const error = new require_src.UnsupportedProtocolVersionError({
			supported,
			requested: parseRequested(data) ?? context.requestedVersion
		}, message);
		const supportedModern = require_src.modernProtocolVersions(supported);
		const mutual = context.clientModernVersions.find((version) => supportedModern.includes(version));
		if (mutual !== void 0) return {
			kind: "corrective",
			version: mutual,
			error
		};
		if (supportedModern.length > 0) return {
			kind: "error",
			error
		};
		return context.fallbackAvailable ? { kind: "legacy" } : {
			kind: "error",
			error
		};
	}
	if (NOT_PROBE_RECOGNIZED.has(code)) return { kind: "legacy" };
	return { kind: "legacy" };
}
function classifyHttpError(outcome, context) {
	if (outcome.status === 401 || outcome.status === 403) {
		const isDenial = outcome.status === 403;
		return {
			kind: "error",
			error: new require_src.SdkHttpError(isDenial ? require_src.SdkErrorCode.ClientHttpForbidden : require_src.SdkErrorCode.ClientHttpAuthentication, `Version negotiation failed: ${isDenial ? "the server denied access (HTTP 403)" : "the server requires authorization (HTTP 401)"}`, {
				status: outcome.status,
				statusText: outcome.statusText,
				text: outcome.body
			})
		};
	}
	if (outcome.status >= 500) return {
		kind: "error",
		error: new require_src.SdkHttpError(require_src.SdkErrorCode.EraNegotiationFailed, `Version negotiation failed: the server answered the probe with HTTP ${outcome.status}`, {
			status: outcome.status,
			statusText: outcome.statusText,
			text: outcome.body
		})
	};
	const rpcError = parseJsonRpcErrorBody(outcome.body);
	if (rpcError !== void 0) return classifyRpcError(rpcError, context);
	return { kind: "legacy" };
}
function classifyNetworkError(error, context) {
	if (context.environment === "browser" && isOpaqueFetchTypeError(error)) return { kind: "legacy" };
	return {
		kind: "error",
		error: new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, `Version negotiation probe failed: ${describeError(error)}`, { cause: error }, { cause: error })
	};
}
function isOpaqueFetchTypeError(error) {
	return error instanceof TypeError || error instanceof Error && error.name === "TypeError";
}
function describeError(error) {
	return error instanceof Error ? error.message : String(error);
}
function parseSupportedList(data) {
	if (typeof data !== "object" || data === null) return void 0;
	const supported = data.supported;
	if (!Array.isArray(supported) || supported.length === 0 || !supported.every((v) => typeof v === "string")) return;
	return supported;
}
function parseRequested(data) {
	if (typeof data !== "object" || data === null) return void 0;
	const requested = data.requested;
	return typeof requested === "string" ? requested : void 0;
}
function parseJsonRpcErrorBody(body) {
	if (body === void 0 || body === "") return void 0;
	let parsed;
	try {
		parsed = JSON.parse(body);
	} catch {
		return;
	}
	if (typeof parsed !== "object" || parsed === null) return void 0;
	const error = parsed.error;
	if (typeof error !== "object" || error === null) return void 0;
	const { code, message, data } = error;
	if (typeof code !== "number") return void 0;
	return {
		code,
		message: typeof message === "string" ? message : "",
		data
	};
}

//#endregion
//#region src/client/versionNegotiation.ts
/**
* The default mode when `versionNegotiation` (or its `mode`) is absent;
* changing the default later is a flip of this single line.
*/
const DEFAULT_VERSION_NEGOTIATION_MODE = "legacy";
/**
* Resolve the negotiation options into a per-connect plan. The raw (not
* defaulted) `supportedProtocolVersions` option supplies the modern offer list;
* a list without any legacy version makes this a modern-only client (no fallback).
*/
function resolveVersionNegotiation(options, supportedProtocolVersionsOption) {
	const mode = options?.mode ?? DEFAULT_VERSION_NEGOTIATION_MODE;
	if (mode === "legacy") return { kind: "legacy" };
	const probe = options?.probe ?? {};
	if (typeof mode === "object") {
		if (!require_src.isModernProtocolVersion(mode.pin)) throw new TypeError(`versionNegotiation: { pin: '${mode.pin}' } is not a modern protocol revision — pinning is for 2026-07-28 and later; omit versionNegotiation (or use mode: 'legacy') for 2025-era servers.`);
		return {
			kind: "pin",
			version: mode.pin,
			probe
		};
	}
	const explicitModern = supportedProtocolVersionsOption ? require_src.modernProtocolVersions(supportedProtocolVersionsOption) : [];
	return {
		kind: "auto",
		modernVersions: explicitModern.length > 0 ? explicitModern : [...require_src.SUPPORTED_MODERN_PROTOCOL_VERSIONS],
		fallbackAvailable: supportedProtocolVersionsOption ? require_src.legacyProtocolVersions(supportedProtocolVersionsOption).length > 0 : true,
		probe
	};
}
/** Detect the probe environment for the network-failure row — see {@linkcode ProbeEnvironment}. */
function detectProbeEnvironment() {
	const g = globalThis;
	return g.window !== void 0 && g.document !== void 0 ? "browser" : "node";
}
/**
* Detect the transport class for the transport-aware timeout and closed verdicts (see
* {@linkcode ProbeTransportKind}). The stdio child-process transport is
* recognized structurally (`stderr`/`pid` accessors, no `instanceof` — safe
* across bundles); everything else is treated like HTTP.
*/
function detectProbeTransportKind(transport) {
	return "stderr" in transport && "pid" in transport ? "stdio" : "http";
}
/**
* Temporary ownership of a raw transport for the negotiation exchange, before
* the Protocol machinery attaches. `open()` installs the window's handlers and
* starts the transport; `release()` detaches them and arms a one-shot `start()`
* pass-through so the subsequent Protocol connect (which always starts its
* transport) takes over the already-started channel without a double-start error.
*
* Handlers a caller pre-set on the transport before `connect()` are saved on
* open and restored on detach, so `Protocol.connect()` finds and chains them
* exactly as it would on a plain (non-negotiating) connect. Error and close
* events are forwarded to the saved handlers during the window, so negotiation
* does not change what a pre-attached observer sees of the transport
* lifecycle. (Inbound messages are deliberately NOT forwarded — the window's
* drop-guard is a module invariant, and the probe reply has no plain-connect
* counterpart; a pre-set `onmessage` is restored at detach and chained by
* `Protocol.connect()` like the others.)
*/
var ProbeWindow = class ProbeWindow {
	_pending;
	_probeCounter = 0;
	_savedOnMessage;
	_savedOnError;
	_savedOnClose;
	_closeDelivered = false;
	constructor(_transport) {
		this._transport = _transport;
		this._savedOnMessage = _transport.onmessage;
		this._savedOnError = _transport.onerror;
		this._savedOnClose = _transport.onclose;
	}
	static async open(transport) {
		const window = new ProbeWindow(transport);
		transport.onmessage = (message) => {
			const pending = window._pending;
			if (pending !== void 0 && (require_src.isJSONRPCResultResponse(message) || require_src.isJSONRPCErrorResponse(message)) && message.id === pending.id) {
				window._pending = void 0;
				if (require_src.isJSONRPCResultResponse(message)) pending.resolve({
					kind: "response",
					result: message.result
				});
				else pending.resolve({
					kind: "response",
					error: message.error
				});
				return;
			}
		};
		transport.onerror = (error) => {
			window._savedOnError?.(error);
		};
		transport.onclose = () => {
			const pending = window._pending;
			if (pending !== void 0) {
				window._pending = void 0;
				pending.resolve({ kind: "closed" });
			}
			window._closeDelivered = true;
			window._savedOnClose?.();
		};
		try {
			await transport.start();
		} catch (error) {
			window.detach();
			throw error;
		}
		return window;
	}
	/**
	* Send one probe request and await its reply. Probe ids are strings, so they
	* never collide with Protocol's numeric ids (e.g. on a shared stdio pipe).
	*/
	async exchange(buildRequest, timeoutMs) {
		const id = `server-discover-probe-${++this._probeCounter}`;
		return new Promise((resolve) => {
			let settled = false;
			const settle = (reply) => {
				if (settled) return;
				settled = true;
				clearTimeout(timer);
				if (this._pending?.id === id) this._pending = void 0;
				resolve(reply);
			};
			const timer = setTimeout(() => settle({ kind: "timeout" }), timeoutMs);
			this._pending = {
				id,
				resolve: settle
			};
			this._transport.send(buildRequest(id)).catch((error) => settle({
				kind: "send-error",
				error
			}));
		});
	}
	/** Detach the window's handlers, restoring any the caller pre-set, leaving the transport's own `start` untouched. */
	detach() {
		this._pending = void 0;
		this._transport.onmessage = this._savedOnMessage;
		this._transport.onerror = this._savedOnError;
		if (this._closeDelivered && this._savedOnClose !== void 0) {
			const saved = this._savedOnClose;
			const transport = this._transport;
			let spent = false;
			const wrapper = () => {
				if (!spent) {
					spent = true;
					return;
				}
				saved();
			};
			transport.onclose = wrapper;
			pendingSpentCloseGuards.set(transport, () => {
				if (transport.onclose === wrapper) transport.onclose = saved;
			});
		} else this._transport.onclose = this._savedOnClose;
	}
	/** Detach the handlers and arm the one-shot `start()` pass-through for the `Protocol.connect()` handover. */
	release() {
		this.detach();
		const transport = this._transport;
		const originalStart = transport.start;
		let armed = true;
		transport.start = async function() {
			if (armed) {
				armed = false;
				transport.start = originalStart;
				return;
			}
			return originalStart.call(transport);
		};
	}
};
/**
* Spent-close guards from failed negotiations, pending disarm by the cleanup
* site (keyed weakly — an abandoned transport carries its guard to GC).
*/
const pendingSpentCloseGuards = /* @__PURE__ */ new WeakMap();
/**
* Disarm a failed negotiation's spent-close guard once the cleanup `close()`
* has settled. Any re-delivery of the spent mid-window close happens DURING
* that close (HTTP transports re-fire `onclose` there; stdio transports never
* do — their close event already fired), so after it every close is genuine
* and must reach the caller's pre-set observer.
*/
function disarmSpentCloseGuard(transport) {
	const disarm = pendingSpentCloseGuards.get(transport);
	pendingSpentCloseGuards.delete(transport);
	disarm?.();
}
/** Build the probe request: `server/discover` carrying the full per-request `_meta` envelope. */
function buildProbeRequest(id, protocolVersion, clientInfo, capabilities) {
	return {
		jsonrpc: "2.0",
		id,
		method: "server/discover",
		params: { _meta: require_src.codecForVersion(protocolVersion).outboundEnvelope({
			protocolVersion,
			clientInfo,
			clientCapabilities: capabilities
		}) }
	};
}
/** True for what the transport throws when the probe was answered 2xx without a usable reply. */
function isUnusableReplyError(error) {
	if (error instanceof require_src.SdkError && error.code === require_src.SdkErrorCode.ClientHttpUnexpectedContent) return true;
	return error instanceof Error && error.name === "SyntaxError";
}
function normalizeReply(reply, timeoutMs) {
	switch (reply.kind) {
		case "response": return reply.error === void 0 ? {
			kind: "result",
			result: reply.result
		} : {
			kind: "rpc-error",
			...reply.error
		};
		case "send-error": {
			const error = reply.error;
			if (isAuthSeamEscape(error) || error instanceof UnauthorizedError || error instanceof Error && error.name === "UnauthorizedError") return {
				kind: "auth-required",
				error
			};
			if (error instanceof require_src.SdkHttpError) {
				const text = error.data?.text;
				return {
					kind: "http-error",
					status: error.data.status,
					body: typeof text === "string" ? text : void 0,
					statusText: error.data.statusText
				};
			}
			if (isUnusableReplyError(error)) return {
				kind: "unusable-reply",
				error
			};
			return {
				kind: "network-error",
				error
			};
		}
		case "closed": return { kind: "closed" };
		case "timeout": return {
			kind: "timeout",
			timeoutMs
		};
	}
}
/**
* Run the negotiation probe state machine on a raw (not yet Protocol-connected)
* transport. Resolves with the negotiated era; throws typed connect errors. On
* return the probe window has been released: the transport is started,
* handler-free, and ready for `Protocol.connect()` handover. On throw the
* window is detached and the transport's `start` is left untouched.
*/
async function negotiateEra(negotiation, deps) {
	const timeoutMs = negotiation.probe.timeoutMs ?? deps.defaultTimeoutMs;
	const maxRetries = Math.max(0, negotiation.probe.maxRetries ?? 0);
	const clientModernVersions = negotiation.kind === "pin" ? [negotiation.version] : negotiation.modernVersions;
	const fallbackAvailable = negotiation.kind === "auto" && negotiation.fallbackAvailable;
	const window = await ProbeWindow.open(deps.transport);
	const probe = async () => {
		let requestedVersion = clientModernVersions[0];
		let correctiveUsed = false;
		let timeoutRetriesRemaining = maxRetries;
		for (;;) {
			const reply = await window.exchange((id) => buildProbeRequest(id, requestedVersion, deps.clientInfo, deps.capabilities), timeoutMs);
			if (reply.kind === "timeout" && timeoutRetriesRemaining > 0) {
				timeoutRetriesRemaining--;
				continue;
			}
			const outcome = normalizeReply(reply, timeoutMs);
			const verdict = classifyProbeOutcome(outcome, {
				clientModernVersions,
				requestedVersion,
				fallbackAvailable,
				environment: deps.environment,
				transportKind: deps.transportKind
			});
			switch (verdict.kind) {
				case "modern": return {
					era: "modern",
					version: verdict.version,
					discover: verdict.discover
				};
				case "corrective":
					if (correctiveUsed) throw verdict.error;
					correctiveUsed = true;
					requestedVersion = verdict.version;
					continue;
				case "legacy": {
					const closedCause = outcome.kind === "closed" ? "the connection closed during the server/discover probe" : void 0;
					if (negotiation.kind === "pin") throw new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, closedCause === void 0 ? `Version negotiation failed: the server did not offer pinned protocol version ${negotiation.version} via server/discover (no fallback in pin mode)` : `Version negotiation failed: ${closedCause} before the server offered pinned protocol version ${negotiation.version} (no fallback in pin mode)`);
					if (!negotiation.fallbackAvailable) throw new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, closedCause === void 0 ? "Version negotiation failed: the server gave no modern evidence and this client supports no pre-2026-07-28 protocol version to fall back to" : `Version negotiation failed: ${closedCause} and this client supports no pre-2026-07-28 protocol version to fall back to`);
					if (closedCause !== void 0 && deps.disposableProbe !== true) throw new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, `Version negotiation failed: ${closedCause} (this transport probed in place — the disposable sibling probe requires the SDK's base StdioClientTransport)`);
					return { era: "legacy" };
				}
				case "error": throw verdict.error;
			}
		}
	};
	let result;
	try {
		result = await probe();
	} catch (error) {
		window.detach();
		throw error;
	}
	window.release();
	return result;
}
/**
* Structural read of the SDK stdio transport's retained spawn parameters —
* `undefined` for stdio-shaped transports that do not expose them, and for
* SUBCLASSES of the SDK transport (those probe in place, where a mid-probe
* close stays a typed connect error). The sibling path requires the transport
* to be exactly the base class: a subclass cannot be faithfully cloned by
* re-invoking its constructor with the retained params alone (extra ctor
* arguments, transformed state, side effects). Exactness is checked without
* importing the class (the negotiation graph must stay runtime-neutral): only
* the base class's own prototype carries the internal `_dispose` reaper the
* sibling flow depends on — a subclass's prototype does not own it.
*/
function readStdioServerParams(transport) {
	const proto = Object.getPrototypeOf(transport);
	if (proto === null || !Object.prototype.hasOwnProperty.call(proto, "_dispose")) return;
	const params = transport._serverParams;
	return typeof params === "object" && params !== null && typeof params.command === "string" ? params : void 0;
}
/**
* stdio era negotiation on a DISPOSABLE SIBLING: stdio servers built on SDKs
* that terminate on any pre-`initialize` request exit when the probe arrives,
* so the probe must not spend the caller's one process life. `server/discover`
* runs on a short-lived sibling spawned from the same parameters; the caller's
* transport starts exactly once, after the era is known. The sibling is
* invisible infrastructure: its stderr is discarded, and it is reaped before
* this resolves (signal escalation awaiting process exit — a helper holding
* its pipes never blocks disposal). A caller `close()` on the session
* transport during the probe aborts the connect with the typed negotiation
* error, and the session transport is never started.
*/
async function negotiateStdioViaSibling(negotiation, sessionTransport, params, deps) {
	const SiblingTransport = sessionTransport.constructor;
	const sibling = new SiblingTransport({
		...params,
		stderr: "ignore"
	});
	const originalClose = sessionTransport.close;
	let callerClosed = false;
	let signalClosed;
	const closedSignal = new Promise((_, reject) => {
		signalClosed = () => reject(callerCloseAbortError());
	});
	sessionTransport.close = async function() {
		callerClosed = true;
		signalClosed?.();
		return originalClose.call(sessionTransport);
	};
	let result;
	try {
		const negotiated = negotiateEra(negotiation, {
			...deps,
			transport: sibling,
			transportKind: "stdio",
			disposableProbe: true
		});
		negotiated.catch(() => {});
		result = await Promise.race([negotiated, closedSignal]);
	} finally {
		await disposeSibling(sibling);
		sessionTransport.close = originalClose;
	}
	if (callerClosed) throw callerCloseAbortError();
	return result;
}
/** The typed abort for a caller `close()` landing while the sibling probes. */
function callerCloseAbortError() {
	return new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, "Version negotiation failed: the transport was closed during the server/discover probe");
}
/** Reap a probe sibling — best-effort; a sibling that cannot be reaped must not turn a settled verdict into an error. */
async function disposeSibling(sibling) {
	try {
		const dispose = sibling._dispose;
		await (typeof dispose === "function" ? dispose.call(sibling) : sibling.close());
	} catch {}
}

//#endregion
//#region src/client/client.ts
/**
* The server identity a `DiscoverResult` carries in
* `_meta['io.modelcontextprotocol/serverInfo']` (a spec SHOULD — absent means
* the server offered no identity). Runtime-validated with the spec-type
* guard because `connect({ prior })` accepts caller-supplied values that
* never saw a wire parse.
*/
function serverInfoFromDiscover(discover) {
	const fromMeta = discover._meta?.[_modelcontextprotocol_core_internal.SERVER_INFO_META_KEY];
	return require_src.isSpecType.Implementation(fromMeta) ? fromMeta : void 0;
}
/**
* Elicitation default application helper. Applies defaults to the `data` based on the `schema`.
*
* @param schema - The schema to apply defaults to.
* @param data - The data to apply defaults to.
*/
function applyElicitationDefaults(schema, data) {
	if (!schema || data === null || typeof data !== "object") return;
	if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
		const obj = data;
		const props = schema.properties;
		for (const key of Object.keys(props)) {
			const propSchema = props[key];
			if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) obj[key] = propSchema.default;
			if (obj[key] !== void 0) applyElicitationDefaults(propSchema, obj[key]);
		}
	}
	if (Array.isArray(schema.anyOf)) {
		for (const sub of schema.anyOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
	}
	if (Array.isArray(schema.oneOf)) {
		for (const sub of schema.oneOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
	}
}
/**
* Determines which elicitation modes are supported based on declared client capabilities.
*
* According to the spec:
* - An empty elicitation capability object defaults to form mode support (backwards compatibility)
* - URL mode is only supported if explicitly declared
*
* @param capabilities - The client's elicitation capabilities
* @returns An object indicating which modes are supported
*/
function getSupportedElicitationModes(capabilities) {
	if (!capabilities) return {
		supportsFormMode: false,
		supportsUrlMode: false
	};
	const hasFormCapability = capabilities.form !== void 0;
	const hasUrlCapability = capabilities.url !== void 0;
	return {
		supportsFormMode: hasFormCapability || !hasFormCapability && !hasUrlCapability,
		supportsUrlMode: hasUrlCapability
	};
}
/**
* Rejects malformed persisted blobs with a typed `SdkError` before any state
* change: unrecognized `kind`, a legacy verdict also carrying
* DiscoverResult-shaped members (a corrupt blob must never era-choose), or a
* modern `discover` payload failing the wire path's schema.
*/
function validatePrior(prior) {
	if (typeof prior === "object" && prior !== null) {
		if (prior.kind === "legacy" && !("supportedVersions" in prior) && !("discover" in prior)) return prior;
		if (prior.kind === "modern" && _modelcontextprotocol_core_internal.DiscoverResultSchema.safeParse(prior.discover).success) return prior;
	}
	throw new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, "connect({ prior }): unrecognized prior — expected { kind: 'modern', discover } or { kind: 'legacy' }");
}
/**
* `list_changed` notification → response-cache method(s) to evict. `resources`
* covers both list verbs (the spec's "relevant notification ⇒ immediately
* stale").
*/
const LIST_CHANGED_EVICTIONS = {
	"notifications/tools/list_changed": ["tools/list"],
	"notifications/prompts/list_changed": ["prompts/list"],
	"notifications/resources/list_changed": ["resources/list", "resources/templates/list"]
};
const DEFAULT_LIST_MAX_PAGES = 64;
/**
* An MCP client on top of a pluggable transport.
*
* The client will automatically begin the initialization flow with the server when {@linkcode connect} is called.
*
* To handle server-initiated requests (sampling, elicitation, roots), call {@linkcode setRequestHandler}.
* The client must declare the corresponding capability for the handler to be accepted. For
* `sampling/createMessage` and `elicitation/create`, the handler is automatically wrapped with
* schema validation for both the incoming request and the returned result.
*
* Note: the `roots/list` and `sampling/createMessage` handler surfaces (and the corresponding
* `roots` and `sampling` capabilities) are deprecated as of protocol version 2026-07-28
* (SEP-2577). They remain functional during the deprecation window (at least twelve months).
* Migrate sampling to calling LLM provider APIs directly, and roots to passing paths via tool
* parameters, resource URIs, or configuration.
*
* @example Handling a sampling request
* ```ts source="./client.examples.ts#Client_setRequestHandler_sampling"
* client.setRequestHandler('sampling/createMessage', async request => {
*     const lastMessage = request.params.messages.at(-1);
*     console.log('Sampling request:', lastMessage);
*
*     // In production, send messages to your LLM here
*     return {
*         model: 'my-model',
*         role: 'assistant' as const,
*         content: {
*             type: 'text' as const,
*             text: 'Response from the model'
*         }
*     };
* });
* ```
*/
var Client = class extends require_src.Protocol {
	_serverCapabilities;
	_serverVersion;
	_capabilities;
	_instructions;
	_jsonSchemaValidator;
	/**
	* The response-cache substrate. Owns the backing store, the per-method
	* eviction-generation counter, the user-supplied/default flag, and the
	* stamp-memoized derived `name → Tool` / `name → output-validator`
	* indices — the cache-coordination state that used to live as separate
	* private fields here. The internal aggregating walk writes one entry per
	* list verb; `list_changed` evicts the matching method;
	* `_resetConnectionState` resets the lot. {@linkcode callTool}'s
	* output-schema validation reads the derived `outputValidator` index (the
	* substrate's first production caller); the stacked SEP-2243 PR wires
	* `Mcp-Param-*` mirroring through `toolDefinition` on top.
	*/
	_cache;
	_defaultCacheTtlMs;
	_listMaxPages;
	_listChangedDebounceTimers = /* @__PURE__ */ new Map();
	/**
	* The constructor `listChanged` configuration. Durable across reconnects:
	* read fresh on every connect (legacy or modern), never consumed.
	*/
	_listChangedConfig;
	_enforceStrictCapabilities;
	_versionNegotiation;
	_supportedProtocolVersionsOption;
	_inputRequiredDriverConfig;
	/**
	* Active subscriptions/listen state, keyed by subscription id (= the
	* listen request's JSON-RPC id verbatim). The id is a STRING from a
	* Client-owned counter (`'listen:' + N`) — JSON-RPC permits string ids,
	* and Protocol's numeric `_requestMessageId` counter only ever issues
	* numbers, so listen ids cannot collide with ordinary request ids.
	*/
	_listenState = /* @__PURE__ */ new Map();
	_nextListenId = 0;
	/** The auto-opened subscription backing ClientOptions.listChanged on a modern connection. */
	_autoOpenedSubscription;
	/** Backing store for {@linkcode getDiscoverResult}. Per-connection. */
	_discoverResult;
	/**
	* Clears every per-connection field in one place. Called at the start of
	* each fresh (non-resuming) connect and from `close()`, so a stale
	* negotiated era / server identity / auto-opened subscription cannot
	* survive a reconnect.
	*/
	_resetConnectionState() {
		this._negotiatedProtocolVersion = void 0;
		this._serverCapabilities = void 0;
		this._serverVersion = void 0;
		this._instructions = void 0;
		this._discoverResult = void 0;
		this._autoOpenedSubscription = void 0;
		if (this._listenState.size > 0) {
			const reason = new require_src.SdkError(require_src.SdkErrorCode.ConnectionClosed, "subscriptions/listen: client reconnected or closed; subscription state from the previous connection was reset");
			for (const entry of this._listenState.values()) entry.settle({
				cause: "remote",
				error: reason
			});
		}
		this._listenState.clear();
		for (const timer of this._listChangedDebounceTimers.values()) clearTimeout(timer);
		this._listChangedDebounceTimers.clear();
		this._cache.resetForReconnect();
	}
	async close() {
		try {
			await super.close();
		} finally {
			this._resetConnectionState();
		}
	}
	/**
	* Initializes this client with the given name and version information.
	*/
	constructor(_clientInfo, options) {
		super(options);
		this._clientInfo = _clientInfo;
		this._capabilities = options?.capabilities ? { ...options.capabilities } : {};
		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new _modelcontextprotocol_client__shims.DefaultJsonSchemaValidator();
		this._enforceStrictCapabilities = options?.enforceStrictCapabilities ?? false;
		this._versionNegotiation = options?.versionNegotiation;
		this._supportedProtocolVersionsOption = options?.supportedProtocolVersions;
		this._inputRequiredDriverConfig = require_src.resolveInputRequiredDriverConfig(options?.inputRequired);
		this._cache = new ClientResponseCache(options?.responseCacheStore ?? new InMemoryResponseCacheStore(), options?.responseCacheStore !== void 0, (error) => this._reportStoreError(error), options?.cachePartition ?? "");
		this._defaultCacheTtlMs = options?.defaultCacheTtlMs ?? 0;
		this._listMaxPages = options?.listMaxPages ?? DEFAULT_LIST_MAX_PAGES;
		if (options?.listChanged) this._listChangedConfig = options.listChanged;
	}
	buildContext(ctx, _transportInfo) {
		return ctx;
	}
	/**
	* Era-keyed direction enforcement for inbound traffic on channels whose
	* transport does not classify (e.g. stdio): the 2026-07-28 era has no
	* server→client JSON-RPC request channel — server-to-client interactions
	* are carried in-band in `input_required` results — and on stdio the
	* client must never write JSON-RPC responses. An inbound request arriving
	* on a connection that negotiated a modern era is therefore dropped
	* (surfaced via `onerror`) rather than answered. Connections on a legacy
	* era — and all responses and notifications — keep today's dispatch path.
	*/
	_shouldDropInbound(message) {
		if (this._negotiatedProtocolVersion !== void 0 && require_src.isModernProtocolVersion(this._negotiatedProtocolVersion) && require_src.isJSONRPCRequest(message)) return "drop";
	}
	/**
	* Per-request `_meta` envelope auto-emission (protocol revision 2026-07-28):
	* on a connection that negotiated a modern era — auto-negotiated or pinned —
	* every outgoing request and notification automatically carries the reserved
	* protocol-version / client-info / client-capabilities `_meta` keys (the
	* same envelope the connect-time `server/discover` probe sends).
	* User-supplied `_meta` keys take precedence over the auto-attached ones.
	*
	* Legacy-era connections return `undefined`: the envelope seam is a no-op
	* and outbound traffic is byte-identical to a 2025 client (the legacy
	* `'auto'` fallback included).
	*/
	_outboundMetaEnvelope() {
		const version = this._negotiatedProtocolVersion;
		if (version === void 0) return void 0;
		return this._wireCodec().outboundEnvelope({
			protocolVersion: version,
			clientInfo: this._clientInfo,
			clientCapabilities: this._capabilities
		});
	}
	/**
	* Wires the multi-round-trip auto-fulfilment engine (protocol revision
	* 2026-07-28) into the response funnel: an `input_required` answer is
	* fulfilled through the registered elicitation/sampling/roots handlers
	* and the original request retried via `flow.retry`, up to
	* `inputRequired.maxRounds` rounds. With auto-fulfilment disabled the
	* response surfaces as a typed error steering to manual mode.
	*/
	_resolveNonCompleteResult(decoded, flow) {
		if (!this._inputRequiredDriverConfig.autoFulfill) return Promise.reject(new require_src.SdkError(require_src.SdkErrorCode.UnsupportedResultType, `Unsupported result type 'input_required' for ${flow.request.method}: multi-round-trip auto-fulfilment is not enabled on this instance — pass allowInputRequired: true to handle it manually, or enable inputRequired.autoFulfill`, {
			resultType: "input_required",
			method: flow.request.method
		}));
		return require_src.runInputRequiredFlow({
			getRequestHandler: (method) => this._getRequestHandler(method),
			buildContext: (baseCtx) => this.buildContext(baseCtx, void 0),
			sessionId: this.transport?.sessionId
		}, this._inputRequiredDriverConfig, decoded, flow);
	}
	/**
	* Set up handlers for list changed notifications based on config and server capabilities.
	* This should only be called after initialization when server capabilities are known.
	* Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
	* @internal
	*/
	_setupListChangedHandlers(config) {
		if (config.tools && this._serverCapabilities?.tools?.listChanged) this._setupListChangedHandler("tools", "notifications/tools/list_changed", config.tools, async () => {
			return (await this.listTools(void 0, { cacheMode: "refresh" })).tools;
		});
		if (config.prompts && this._serverCapabilities?.prompts?.listChanged) this._setupListChangedHandler("prompts", "notifications/prompts/list_changed", config.prompts, async () => {
			return (await this.listPrompts(void 0, { cacheMode: "refresh" })).prompts;
		});
		if (config.resources && this._serverCapabilities?.resources?.listChanged) this._setupListChangedHandler("resources", "notifications/resources/list_changed", config.resources, async () => {
			return (await this.listResources(void 0, { cacheMode: "refresh" })).resources;
		});
	}
	/**
	* Registers new capabilities. This can only be called before connecting to a transport.
	*
	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
	*/
	registerCapabilities(capabilities) {
		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
		this._capabilities = require_src.mergeCapabilities(this._capabilities, capabilities);
	}
	/**
	* Configure protocol version negotiation before connecting (equivalent to
	* passing `versionNegotiation` at construction time). Can only be called
	* before connecting to a transport. Passing `undefined` clears a previously
	* configured negotiation, restoring the default `'legacy'` posture.
	*
	* See {@linkcode ClientOptions | ClientOptions.versionNegotiation} for the mode semantics.
	*/
	setVersionNegotiation(options) {
		if (this.transport) throw new Error("Cannot configure version negotiation after connecting to transport");
		this._versionNegotiation = options;
	}
	/**
	* Enforces client-side validation for `elicitation/create` and `sampling/createMessage`
	* regardless of how the handler was registered.
	*/
	_wrapHandler(method, handler) {
		if (method === "elicitation/create") return async (request, ctx) => {
			const codec = require_src.codecForVersion(this._negotiatedProtocolVersion);
			let validatedRequest = codec.validateRequest("elicitation/create", request);
			if (!validatedRequest.ok && validatedRequest.reason === "not-in-era") validatedRequest = codec.validateInputRequest("elicitation/create", request);
			if (!validatedRequest.ok) throw new require_src.ProtocolError(validatedRequest.reason === "not-in-era" ? require_src.ProtocolErrorCode.InternalError : require_src.ProtocolErrorCode.InvalidParams, validatedRequest.reason === "not-in-era" ? "No wire schema for elicitation/create in the resolved era" : `Invalid elicitation request: ${validatedRequest.message}`);
			const { params } = validatedRequest.value;
			params.mode = params.mode ?? "form";
			const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
			if (params.mode === "form" && !supportsFormMode) throw new require_src.ProtocolError(require_src.ProtocolErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
			if (params.mode === "url" && !supportsUrlMode) throw new require_src.ProtocolError(require_src.ProtocolErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
			const result = await handler(request, ctx);
			let validationResult = codec.validateResult("elicitation/create", result);
			if (!validationResult.ok && validationResult.reason === "not-in-era") validationResult = codec.validateInputResponse("elicitation/create", result);
			if (!validationResult.ok) throw new require_src.ProtocolError(validationResult.reason === "not-in-era" ? require_src.ProtocolErrorCode.InternalError : require_src.ProtocolErrorCode.InvalidParams, validationResult.reason === "not-in-era" ? "No wire schema for elicitation/create in the resolved era" : `Invalid elicitation result: ${validationResult.message}`);
			const validatedResult = validationResult.value;
			const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
			if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema && this._capabilities.elicitation?.form?.applyDefaults) try {
				applyElicitationDefaults(requestedSchema, validatedResult.content);
			} catch {}
			return validatedResult;
		};
		if (method === "sampling/createMessage") return async (request, ctx) => {
			const codec = require_src.codecForVersion(this._negotiatedProtocolVersion);
			let validatedRequest = codec.validateRequest("sampling/createMessage", request);
			if (!validatedRequest.ok && validatedRequest.reason === "not-in-era") validatedRequest = codec.validateInputRequest("sampling/createMessage", request);
			if (!validatedRequest.ok) throw new require_src.ProtocolError(validatedRequest.reason === "not-in-era" ? require_src.ProtocolErrorCode.InternalError : require_src.ProtocolErrorCode.InvalidParams, validatedRequest.reason === "not-in-era" ? "No wire schema for sampling/createMessage in the resolved era" : `Invalid sampling request: ${validatedRequest.message}`);
			const { params } = validatedRequest.value;
			const result = await handler(request, ctx);
			const hasTools = Boolean(params.tools || params.toolChoice);
			let validatedResult = codec.samplingResultVariant(hasTools, result);
			if (!validatedResult.ok && validatedResult.reason === "not-in-era") validatedResult = codec.validateInputResponse("sampling/createMessage", result);
			if (!validatedResult.ok) throw new require_src.ProtocolError(validatedResult.reason === "not-in-era" ? require_src.ProtocolErrorCode.InternalError : require_src.ProtocolErrorCode.InvalidParams, validatedResult.reason === "not-in-era" ? "No result schema for sampling/createMessage in the resolved era" : `Invalid sampling result: ${validatedResult.message}`);
			return validatedResult.value;
		};
		return handler;
	}
	assertCapability(capability, method) {
		if (!this._serverCapabilities?.[capability]) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support ${capability} (required for ${method})`);
	}
	/**
	* Connects to a server via the given transport and performs the MCP initialization handshake.
	*
	* @example Basic usage (stdio)
	* ```ts source="./client.examples.ts#Client_connect_stdio"
	* const client = new Client({ name: 'my-client', version: '1.0.0' });
	* const transport = new StdioClientTransport({ command: 'my-mcp-server' });
	* await client.connect(transport);
	* ```
	*
	* @example Streamable HTTP with SSE fallback
	* ```ts source="./client.examples.ts#Client_connect_sseFallback"
	* const baseUrl = new URL(url);
	*
	* try {
	*     // Try modern Streamable HTTP transport first
	*     const client = new Client({ name: 'my-client', version: '1.0.0' });
	*     const transport = new StreamableHTTPClientTransport(baseUrl);
	*     await client.connect(transport);
	*     return { client, transport };
	* } catch {
	*     // Fall back to legacy SSE transport
	*     const client = new Client({ name: 'my-client', version: '1.0.0' });
	*     const transport = new SSEClientTransport(baseUrl);
	*     await client.connect(transport);
	*     return { client, transport };
	* }
	* ```
	*/
	async connect(transport, options) {
		if (options?.prior != null) return this._connectFromPrior(transport, validatePrior(options.prior), options);
		const negotiation = resolveVersionNegotiation(this._versionNegotiation, this._supportedProtocolVersionsOption);
		if (negotiation.kind !== "legacy") return this._connectNegotiated(transport, negotiation, options);
		return this._connectPlainLegacy(transport, options);
	}
	/**
	* Plain legacy connect — the pinned 2025 sequence, byte-untouched. The
	* `mode: 'legacy'` connect body, shared with the `prior` legacy verdict.
	*/
	async _connectPlainLegacy(transport, options) {
		await super.connect(transport);
		if (transport.sessionId !== void 0) {
			const negotiatedProtocolVersion = this._negotiatedProtocolVersion;
			if (negotiatedProtocolVersion !== void 0) transport.setProtocolVersion?.(negotiatedProtocolVersion);
			return;
		}
		this._resetConnectionState();
		await this._legacyHandshake(transport, options);
	}
	/**
	* The 2025 `initialize` handshake — the body of the plain legacy connect and
	* the `'auto'`-mode fallback path (same `initialize` body, zero 2026 headers;
	* on the stdio sibling path it opens the session child's fresh pipe, in the
	* in-place modes it rides the probed connection). Callers clear the negotiated protocol version before
	* the handshake; its completion sets the negotiated (legacy) version.
	*/
	async _legacyHandshake(transport, options) {
		const legacyVersions = require_src.legacyProtocolVersions(this._supportedProtocolVersions);
		try {
			const offeredVersion = legacyVersions[0];
			if (offeredVersion === void 0) throw new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, "Cannot run the initialize handshake: supportedProtocolVersions contains no pre-2026-07-28 protocol version");
			const result = await this.request({
				method: "initialize",
				params: {
					protocolVersion: offeredVersion,
					capabilities: this._capabilities,
					clientInfo: this._clientInfo
				}
			}, options);
			if (result === void 0) throw new Error(`Server sent invalid initialize result: ${result}`);
			if (!legacyVersions.includes(result.protocolVersion)) throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
			this._serverCapabilities = result.capabilities;
			this._serverVersion = result.serverInfo;
			this._cache.setServerIdentity(this._deriveServerIdentity(transport));
			if (transport.setProtocolVersion) transport.setProtocolVersion(result.protocolVersion);
			this._instructions = result.instructions;
			await this.notification({ method: "notifications/initialized" });
			this._negotiatedProtocolVersion = result.protocolVersion;
			if (this._listChangedConfig) this._setupListChangedHandlers(this._listChangedConfig);
		} catch (error) {
			this.close();
			throw error;
		}
	}
	/**
	* Negotiated connect (mode `'auto'` or `{ pin }`): probe with `server/discover`
	* before the Protocol machinery attaches — on a disposable sibling process for
	* the SDK's stdio transport, in place otherwise — then either establish the
	* modern era or perform the plain legacy handshake.
	*/
	async _connectNegotiated(transport, negotiation, options) {
		if (transport.sessionId !== void 0) {
			await super.connect(transport);
			const negotiatedProtocolVersion = this._negotiatedProtocolVersion;
			if (negotiatedProtocolVersion !== void 0 && transport.setProtocolVersion) transport.setProtocolVersion(negotiatedProtocolVersion);
			return;
		}
		this._resetConnectionState();
		let result;
		try {
			const transportKind = detectProbeTransportKind(transport);
			const baseDeps = {
				clientInfo: this._clientInfo,
				capabilities: this._capabilities,
				environment: detectProbeEnvironment(),
				defaultTimeoutMs: options?.timeout ?? require_src.DEFAULT_REQUEST_TIMEOUT_MSEC
			};
			const stdioParams = transportKind === "stdio" ? readStdioServerParams(transport) : void 0;
			result = stdioParams === void 0 ? await negotiateEra(negotiation, {
				...baseDeps,
				transport,
				transportKind
			}) : await negotiateStdioViaSibling(negotiation, transport, stdioParams, baseDeps);
		} catch (error) {
			await transport.close().catch(() => {});
			disarmSpentCloseGuard(transport);
			throw error;
		}
		disarmSpentCloseGuard(transport);
		await super.connect(transport);
		if (result.era === "legacy") {
			await this._legacyHandshake(transport, options);
			return;
		}
		this._serverCapabilities = result.discover.capabilities;
		this._serverVersion = serverInfoFromDiscover(result.discover);
		this._cache.setServerIdentity(this._deriveServerIdentity(transport));
		this._instructions = result.discover.instructions;
		this._discoverResult = result.discover;
		this._negotiatedProtocolVersion = result.version;
		if (transport.setProtocolVersion) transport.setProtocolVersion(result.version);
		if (this._listChangedConfig) {
			const config = this._listChangedConfig;
			const advertised = this._serverCapabilities;
			const effective = {
				...config.tools && advertised?.tools?.listChanged && { tools: config.tools },
				...config.prompts && advertised?.prompts?.listChanged && { prompts: config.prompts },
				...config.resources && advertised?.resources?.listChanged && { resources: config.resources }
			};
			let handlersRegistered = true;
			try {
				this._setupListChangedHandlers(effective);
			} catch (error) {
				handlersRegistered = false;
				this.onerror?.(error instanceof Error ? error : new Error(String(error)));
			}
			const filter = handlersRegistered ? {
				...effective.tools && { toolsListChanged: true },
				...effective.prompts && { promptsListChanged: true },
				...effective.resources && { resourcesListChanged: true }
			} : {};
			if (Object.keys(filter).length > 0) {
				const ackAbort = new AbortController();
				const onConnectAbort = () => ackAbort.abort(options?.signal?.reason);
				if (options?.signal?.aborted) onConnectAbort();
				options?.signal?.addEventListener("abort", onConnectAbort);
				try {
					this._autoOpenedSubscription = await this.listen(filter, {
						timeout: options?.timeout,
						signal: ackAbort.signal
					});
				} catch (error) {
					if (options?.signal?.aborted) {
						await this.close().catch(() => {});
						throw error;
					}
					this.onerror?.(error instanceof Error ? error : new Error(String(error)));
				} finally {
					options?.signal?.removeEventListener("abort", onConnectAbort);
				}
			}
		}
	}
	/**
	* Connect from a validated {@linkcode PriorDiscovery}: the modern arm
	* adopts the `DiscoverResult` (zero round trips; `EraNegotiationFailed`
	* on no 2026-07-28+ overlap), the legacy arm runs the plain legacy connect.
	*/
	async _connectFromPrior(transport, prior, options) {
		if (prior.kind === "legacy") return this._connectPlainLegacy(transport, options);
		const discover = prior.discover;
		this._resetConnectionState();
		const explicit = this._supportedProtocolVersionsOption;
		const version = (explicit && require_src.modernProtocolVersions(explicit).length > 0 ? require_src.modernProtocolVersions(explicit) : require_src.SUPPORTED_MODERN_PROTOCOL_VERSIONS).find((v) => discover.supportedVersions.includes(v));
		if (version === void 0) throw new require_src.SdkError(require_src.SdkErrorCode.EraNegotiationFailed, "connect({ prior }) with a modern verdict requires a 2026-07-28+ mutual protocol version; the supplied DiscoverResult and this client's supportedProtocolVersions have no modern overlap. For a server known to be legacy, pass prior: { kind: 'legacy' } to skip the probe and initialize directly, or use versionNegotiation: { mode: 'auto' } to re-probe with legacy fallback.");
		await super.connect(transport);
		this._discoverResult = discover;
		this._serverCapabilities = discover.capabilities;
		this._serverVersion = serverInfoFromDiscover(discover);
		this._cache.setServerIdentity(this._deriveServerIdentity(transport));
		this._instructions = discover.instructions;
		this._negotiatedProtocolVersion = version;
		transport.setProtocolVersion?.(version);
		if (this._listChangedConfig) try {
			this._setupListChangedHandlers(this._listChangedConfig);
		} catch (error) {
			this.onerror?.(error instanceof Error ? error : new Error(String(error)));
		}
	}
	/**
	* After initialization has completed, this will be populated with the server's reported capabilities.
	*/
	getServerCapabilities() {
		return this._serverCapabilities;
	}
	/**
	* The connected server's self-reported name and version, when it
	* identified itself: required on the legacy `initialize` result; a spec
	* SHOULD in the discover result's `_meta` on 2026-07-28, so a successful
	* modern connect against an anonymous server leaves this `undefined`.
	*/
	getServerVersion() {
		return this._serverVersion;
	}
	/**
	* The connected server's identity for response-cache partitioning. The
	* `serverInfo` `name@version` pair when available (required on
	* `initialize`; a SHOULD in the discover result's `_meta` since spec PR
	* #3002); falls back to the transport's `sessionId`, then to a
	* per-connection surrogate. The surrogate matters since #3002 made
	* identity optional: without it, two identity-less servers reached over
	* sessionId-less transports would share the cache's pre-connect `''`
	* partition and read each other's entries — no stable identity means no
	* cross-connection cache reuse. The value itself is server-controlled —
	* the collision-safety of the storage partition comes from
	* {@linkcode ClientResponseCache}'s JSON-array encoding around it, not
	* from any character it does or does not contain.
	*/
	_deriveServerIdentity(transport) {
		const v = this._serverVersion;
		if (v !== void 0) return `${v.name}@${v.version}`;
		return transport.sessionId ?? `anonymous:${Date.now()}-${Math.random().toString(36).slice(2)}`;
	}
	/**
	* After initialization has completed, this will be populated with the protocol version negotiated
	* during the initialize handshake. When manually reconstructing a transport for reconnection, pass this
	* value to the new transport so it continues sending the required `mcp-protocol-version` header.
	*/
	getNegotiatedProtocolVersion() {
		return this._negotiatedProtocolVersion;
	}
	/**
	* After initialization has completed, this returns the protocol era of the
	* connection: `'modern'` when the connection negotiated a 2026-07-28+
	* revision (via `server/discover`), `'legacy'` for the 2025-era
	* `initialize` handshake, or `undefined` before the connection is
	* established.
	*/
	getProtocolEra() {
		const version = this._negotiatedProtocolVersion;
		if (version === void 0) return void 0;
		return require_src.isModernProtocolVersion(version) ? "modern" : "legacy";
	}
	/**
	* After initialization has completed, this may be populated with information about the server's instructions.
	*/
	getInstructions() {
		return this._instructions;
	}
	/**
	* The {@linkcode DiscoverResult} from the last `'auto'`/pinned probe,
	* {@linkcode discover} call, or `connect({ prior })` that adopted a
	* modern verdict (a legacy verdict leaves this `undefined` — there is no
	* `DiscoverResult` on that path). Persistable via `JSON.stringify`; wrap
	* as `{ kind: 'modern', discover }` and feed to {@linkcode ConnectOptions}
	* `prior`.
	*/
	getDiscoverResult() {
		return this._discoverResult;
	}
	assertCapabilityForMethod(method) {
		switch (method) {
			case "logging/setLevel":
				if (!this._serverCapabilities?.logging) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support logging (required for ${method})`);
				break;
			case "prompts/get":
			case "prompts/list":
				if (!this._serverCapabilities?.prompts) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support prompts (required for ${method})`);
				break;
			case "resources/list":
			case "resources/templates/list":
			case "resources/read":
			case "resources/subscribe":
			case "resources/unsubscribe":
				if (!this._serverCapabilities?.resources) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support resources (required for ${method})`);
				if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support resource subscriptions (required for ${method})`);
				break;
			case "tools/call":
			case "tools/list":
				if (!this._serverCapabilities?.tools) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support tools (required for ${method})`);
				break;
			case "completion/complete":
				if (!this._serverCapabilities?.completions) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Server does not support completions (required for ${method})`);
				break;
			case "initialize": break;
			case "server/discover": break;
			case "ping": break;
		}
	}
	assertNotificationCapability(method) {
		switch (method) {
			case "notifications/roots/list_changed":
				if (!this._capabilities.roots?.listChanged) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Client does not support roots list changed notifications (required for ${method})`);
				break;
			case "notifications/initialized": break;
			case "notifications/cancelled": break;
			case "notifications/progress": break;
		}
	}
	assertRequestHandlerCapability(method) {
		switch (method) {
			case "sampling/createMessage":
				if (!this._capabilities.sampling) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Client does not support sampling capability (required for ${method})`);
				break;
			case "elicitation/create":
				if (!this._capabilities.elicitation) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Client does not support elicitation capability (required for ${method})`);
				break;
			case "roots/list":
				if (!this._capabilities.roots) throw new require_src.SdkError(require_src.SdkErrorCode.CapabilityNotSupported, `Client does not support roots capability (required for ${method})`);
				break;
			case "ping": break;
		}
	}
	async ping(options) {
		return this.request({ method: "ping" }, options);
	}
	/**
	* Send `server/discover` (2026-07-28+) and record the result for
	* {@linkcode getDiscoverResult}.
	*/
	async discover(options) {
		const result = await this._requestWithSchema({ method: "server/discover" }, _modelcontextprotocol_core_internal.DiscoverResultSchema, options);
		this._discoverResult = result;
		return result;
	}
	/** Requests argument autocompletion suggestions from the server for a prompt or resource. */
	async complete(params, options) {
		return this.request({
			method: "completion/complete",
			params
		}, options);
	}
	/**
	* Sets the minimum severity level for log messages sent by the server.
	*
	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
	* Remains functional during the deprecation window (at least twelve months).
	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
	*/
	async setLoggingLevel(level, options) {
		return this.request({
			method: "logging/setLevel",
			params: { level }
		}, options);
	}
	/** Retrieves a prompt by name from the server, passing the given arguments for template substitution. */
	async getPrompt(params, options) {
		return this.request({
			method: "prompts/get",
			params
		}, options);
	}
	/**
	* Lists available prompts.
	*
	* Called without a `cursor` (the common case), this walks every page and
	* returns the complete aggregated list with no `nextCursor`; the
	* aggregate is also written to the {@linkcode ResponseCacheStore}. Pass an
	* explicit `{ cursor }` to fetch a single page and walk pagination
	* yourself — the per-page path returns the server's raw page (with
	* `nextCursor` for the next call) and does not write the response cache.
	* The auto-aggregate path is capped by
	* {@linkcode ClientOptions | ClientOptions.listMaxPages} (default 64); the per-page path
	* is not.
	*
	* Returns an empty list if the server does not advertise prompts capability
	* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
	*
	* @example
	* ```ts source="./client.examples.ts#Client_listPrompts_pagination"
	* // No cursor → all pages aggregated for you.
	* const { prompts } = await client.listPrompts();
	* console.log(
	*     'Available prompts:',
	*     prompts.map(p => p.name)
	* );
	* ```
	*/
	async listPrompts(params, options) {
		if (!this._serverCapabilities?.prompts && !this._enforceStrictCapabilities) {
			console.debug("Client.listPrompts() called but server does not advertise prompts capability - returning empty list");
			return { prompts: [] };
		}
		if (params?.cursor !== void 0) return this.request({
			method: "prompts/list",
			params
		}, options);
		const hit = await this._serveFromCache("prompts/list", void 0, options);
		if (hit !== void 0) return hit;
		return this._listAllPages("prompts/list", params, options, (r) => r.prompts);
	}
	/**
	* Lists available resources.
	*
	* Called without a `cursor` (the common case), this walks every page and
	* returns the complete aggregated list with no `nextCursor`; the
	* aggregate is also written to the {@linkcode ResponseCacheStore}. Pass an
	* explicit `{ cursor }` to fetch a single page and walk pagination
	* yourself — the per-page path returns the server's raw page (with
	* `nextCursor` for the next call) and does not write the response cache.
	* The auto-aggregate path is capped by
	* {@linkcode ClientOptions | ClientOptions.listMaxPages} (default 64); the per-page path
	* is not.
	*
	* Returns an empty list if the server does not advertise resources capability
	* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
	*
	* @example
	* ```ts source="./client.examples.ts#Client_listResources_pagination"
	* // No cursor → all pages aggregated for you.
	* const { resources } = await client.listResources();
	* console.log(
	*     'Available resources:',
	*     resources.map(r => r.name)
	* );
	* ```
	*/
	async listResources(params, options) {
		if (!this._serverCapabilities?.resources && !this._enforceStrictCapabilities) {
			console.debug("Client.listResources() called but server does not advertise resources capability - returning empty list");
			return { resources: [] };
		}
		if (params?.cursor !== void 0) return this.request({
			method: "resources/list",
			params
		}, options);
		const hit = await this._serveFromCache("resources/list", void 0, options);
		if (hit !== void 0) return hit;
		return this._listAllPages("resources/list", params, options, (r) => r.resources);
	}
	/**
	* Lists available resource URI templates for dynamic resources.
	*
	* Called without a `cursor`, this walks every page and returns the
	* complete aggregated list with no `nextCursor`; the aggregate is
	* also written to the {@linkcode ResponseCacheStore}. Pass an explicit
	* `{ cursor }` to fetch a single page — see
	* {@linkcode listResources | listResources()} for the per-page contract.
	*
	* Returns an empty list if the server does not advertise resources capability
	* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
	*/
	async listResourceTemplates(params, options) {
		if (!this._serverCapabilities?.resources && !this._enforceStrictCapabilities) {
			console.debug("Client.listResourceTemplates() called but server does not advertise resources capability - returning empty list");
			return { resourceTemplates: [] };
		}
		if (params?.cursor !== void 0) return this.request({
			method: "resources/templates/list",
			params
		}, options);
		const hit = await this._serveFromCache("resources/templates/list", void 0, options);
		if (hit !== void 0) return hit;
		return this._listAllPages("resources/templates/list", params, options, (r) => r.resourceTemplates);
	}
	/**
	* Walk every page of a paginated list verb, aggregate, and write ONE
	* entry to the response cache. Internal — backs the public `list*`
	* methods' no-`cursor` auto-aggregate path. Page 1's result object is
	* mutated in place (its items array is extended; `nextCursor` is
	* cleared); page-1 metadata (`ttlMs`, `cacheScope`, `_meta`) is preserved.
	* A page with the same items and `nextCursor` as the previous page ends the walk;
	* {@linkcode ClientOptions.listMaxPages} is a hard cap — hitting it
	* throws, so a partial aggregate is never cached. The
	* captured-generation guard skips the write when a `list_changed` landed
	* mid-walk, so the eviction is never overwritten by a stale aggregate.
	* `finalize` runs on the complete aggregate before the cache write — the
	* SEP-2243 invalid-`x-mcp-header` exclusion hooks here so the cached
	* `tools/list` entry is already filtered.
	*
	* The caller's `baseParams` (everything except `cursor`) is threaded into
	* every page request — page 1 sends `{...baseParams}`, later pages
	* `{...baseParams, cursor}` — so a typed, documented `_meta` (e.g. W3C
	* trace context) supplied to the public `list*()` reaches every wire
	* request the walk issues.
	*/
	async _listAllPages(method, baseParams, options, items, finalize) {
		const bypass = options?.cacheMode === "bypass";
		const generation = this._cache.captureGeneration(method);
		const acc = await this.request({
			method,
			...baseParams && { params: { ...baseParams } }
		}, options);
		let cursor = acc.nextCursor;
		let previous = acc;
		let pages = 1;
		while (cursor !== void 0) {
			if (this._listMaxPages !== 0 && pages >= this._listMaxPages) throw new require_src.SdkError(require_src.SdkErrorCode.ListPaginationExceeded, `${method}: exceeded listMaxPages (${this._listMaxPages}); server pagination did not terminate`, {
				method,
				listMaxPages: this._listMaxPages
			});
			const page = await this.request({
				method,
				params: {
					...baseParams,
					cursor
				}
			}, options);
			if (page.nextCursor === cursor && JSON.stringify(items(page)) === JSON.stringify(items(previous))) break;
			items(acc).push(...items(page));
			previous = page;
			cursor = page.nextCursor;
			pages++;
		}
		delete acc.nextCursor;
		finalize?.(acc);
		if (bypass) return acc;
		await this._cache.write(method, acc, generation, this._freshness(acc));
		return acc;
	}
	/**
	* Compute the {@linkcode ClientResponseCache.write} freshness payload from
	* a cacheable result body. The single seam through which the client reads
	* `ttlMs`/`cacheScope` (mcp.d's `cachedFetch` engine). The fields pass
	* through the loose result schema, so they are read off the runtime body;
	* a missing `ttlMs` falls back to
	* {@linkcode ClientOptions | ClientOptions.defaultCacheTtlMs}; an explicit server-sent
	* `ttlMs` (including `0` — the spec's "immediately stale") is honoured
	* as-is. The default of `0` means `expiresAt === now()` ⇒ never served,
	* only stored. A missing `cacheScope` is treated as `'private'` — the
	* spec's `'public'` grant ("any client … MAY serve to any user") is too
	* strong to infer by default, and matches this SDK's server-side stamp
	* default.
	*/
	_freshness(result, params) {
		const body = result;
		const ttlMs = typeof body.ttlMs === "number" ? body.ttlMs : this._defaultCacheTtlMs;
		const scope = body.cacheScope === "public" ? "public" : "private";
		return {
			expiresAt: this._cache.now() + Math.min(Math.max(0, ttlMs), MAX_CACHE_TTL_MS),
			scope,
			params
		};
	}
	/**
	* The cache-serving front of every cacheable verb (mcp.d's `cachedFetch`
	* read half): under `cacheMode: 'use'` (the default), a fresh held entry
	* is served and the round trip is skipped. `'refresh'` and `'bypass'`
	* always fetch (the caller decides whether to write). Freshness and
	* decoding live in {@linkcode ClientResponseCache.read}; every hit is
	* freshly parsed, so the caller owns it outright. A custom store
	* whose `get()` rejects is routed to `onerror` and treated as a miss —
	* cache bookkeeping never blocks a request from reaching the wire.
	*/
	async _serveFromCache(method, params, options) {
		if (options?.cacheMode === "bypass" || options?.cacheMode === "refresh") return void 0;
		const hit = await this._cache.read(method, params).catch((error) => void this._reportStoreError(error));
		if (hit !== void 0) {
			if (options?.signal?.aborted) {
				const reason = options.signal.reason;
				throw reason instanceof require_src.SdkError ? reason : new require_src.SdkError(require_src.SdkErrorCode.RequestTimeout, String(reason));
			}
			return hit.value;
		}
	}
	/** Route a custom-store failure to `onerror` without aborting the surrounding dispatch. */
	_reportStoreError(e) {
		this.onerror?.(e instanceof Error ? e : new Error(String(e)));
	}
	/**
	* Compile a single tool's `outputSchema`. Passed as the compile callback to
	* {@linkcode ClientResponseCache.outputValidator} so the cache class stays
	* free of any validator-provider dependency, and called directly for the
	* `options.toolDefinition` path of {@linkcode callTool} (a one-off
	* caller-supplied definition is compiled in isolation and never enters the
	* cache, so it cannot poison the listed tool of the same name).
	*
	* Returns `undefined` when the tool has no `outputSchema`, or a
	* discriminated `{ok}` result otherwise. SEP-2106: ANY throw from the
	* validator engine — unsupported `$schema` dialect, invalid `pattern`
	* regex, unresolvable `$ref`, or any other engine error — is captured as
	* `{ok: false, compileError}` so one bad schema does not poison the rest
	* of the listing; `callTool()` surfaces it as an `InvalidParams` error
	* before the request. The `{ok}` discriminator (not
	* `compileError !== undefined`) means a custom provider that does
	* `throw undefined` is still treated as a captured failure.
	*/
	_compileOutputValidator(tool) {
		if (!tool.outputSchema) return void 0;
		try {
			return {
				ok: true,
				validator: this._jsonSchemaValidator.getValidator(tool.outputSchema)
			};
		} catch (error) {
			return {
				ok: false,
				compileError: error
			};
		}
	}
	/**
	* Resolve the SEP-2243 `x-mcp-header` declaration scan for a tool name.
	*
	* The caller-supplied `toolDefinition` escape hatch wins; otherwise the
	* cached `tools/list` entry (via the cache's `toolDefinition`) is the
	* source. Freshness is the response cache's lifecycle: `list_changed`
	* evicts, otherwise the held schema is the best information available
	* regardless of age, and a stale schema is recovered through the
	* `HEADER_MISMATCH` → evict-refetch-retry path in {@linkcode callTool}.
	* On a miss the call proceeds without `Mcp-Param-*` headers (the spec's
	* "client SHOULD send without custom headers" guidance) and relies on the
	* same recovery.
	*/
	async _resolveXMcpHeaderScan(name, override) {
		const tool = override ?? await this._cache.toolDefinition(name);
		return tool === void 0 ? void 0 : require_src.scanXMcpHeaderDeclarations(tool.inputSchema);
	}
	/**
	* Reads the contents of a resource by URI.
	*
	* Honours the result's `ttlMs`/`cacheScope` (SEP-2549): a still-fresh
	* cached body for the same `uri` is returned without a round trip
	* (`cacheMode: 'use'`, the default). The cache key is `{method, uri}`
	* partitioned by the resolved scope — `'private'` (the default when the
	* server omits the field) is stored under this client's
	* {@linkcode ClientOptions | ClientOptions.cachePartition}, so a shared
	* store cannot serve one principal's resource body to another. Unlike the
	* list verbs, a result whose resolved TTL is ≤0 is **not** stored
	* (`resources/read` has no derived index and the URI keyspace is
	* unbounded).
	*/
	async readResource(params, options) {
		const hit = await this._serveFromCache("resources/read", params.uri, options);
		if (hit !== void 0) return hit;
		const generation = this._cache.captureGeneration("resources/read", params.uri);
		const result = await this.request({
			method: "resources/read",
			params
		}, options);
		if (options?.cacheMode !== "bypass") {
			const freshness = this._freshness(result, params.uri);
			if (freshness.expiresAt > this._cache.now()) await this._cache.write("resources/read", result, generation, freshness);
			else if (options?.cacheMode === "refresh") await this._cache.evictKey("resources/read", params.uri);
		}
		return result;
	}
	/** Subscribes to change notifications for a resource. The server must support resource subscriptions. */
	async subscribeResource(params, options) {
		return this.request({
			method: "resources/subscribe",
			params
		}, options);
	}
	/** Unsubscribes from change notifications for a resource. */
	async unsubscribeResource(params, options) {
		return this.request({
			method: "resources/unsubscribe",
			params
		}, options);
	}
	/**
	* Opens a `subscriptions/listen` stream (protocol revision 2026-07-28).
	*
	* Resolves once the server's `notifications/subscriptions/acknowledged`
	* arrives (the standard request timeout applies to this ack phase). Change
	* notifications delivered on the stream are dispatched to the existing
	* {@linkcode setNotificationHandler} registrations — the same handlers the
	* 2025-era unsolicited notifications fire on a legacy connection — so
	* `listen()` is era-transparent for consumers that already register those.
	*
	* `close()` tears the subscription down by aborting the listen request's
	* `requestSignal` (closes the SSE stream where the transport honors it)
	* AND sending `notifications/cancelled` referencing the listen request id
	* — both, unconditionally, so any spec-compliant server on any transport
	* sees the cancel. No automatic re-listen — call `listen()` again to
	* re-establish.
	*
	* On a 2025-era connection this throws a typed
	* {@linkcode SdkErrorCode.MethodNotSupportedByProtocolVersion} steering to
	* `resources/subscribe` and `ClientOptions.listChanged` (the legacy
	* unsolicited delivery model still applies there); no transparent shim.
	*/
	async listen(filter, options) {
		if (this.transport === void 0) throw new require_src.SdkError(require_src.SdkErrorCode.NotConnected, "Not connected");
		const negotiated = this._negotiatedProtocolVersion;
		if (negotiated === void 0 || !require_src.isModernProtocolVersion(negotiated)) throw new require_src.SdkError(require_src.SdkErrorCode.MethodNotSupportedByProtocolVersion, `subscriptions/listen requires a 2026-07-28-era connection (negotiated: ${negotiated ?? "none"}). On a 2025-era connection, change notifications are delivered unsolicited: use ClientOptions.listChanged and resources/subscribe instead.`, {
			method: "subscriptions/listen",
			protocolVersion: negotiated
		});
		if (options?.signal?.aborted) {
			const reason = options.signal.reason;
			throw reason instanceof require_src.SdkError ? reason : new require_src.SdkError(require_src.SdkErrorCode.RequestTimeout, String(reason));
		}
		const requestAbort = new AbortController();
		const listenId = `listen:${this._nextListenId++}`;
		let state = "opening";
		let ackTimer;
		let onCallerAbort;
		let resolveOpening;
		let rejectOpening;
		const opening = new Promise((resolve, reject) => {
			resolveOpening = resolve;
			rejectOpening = reject;
		});
		let resolveClosed;
		const closed = new Promise((resolve) => {
			resolveClosed = resolve;
		});
		const settle = (outcome) => {
			if (state === "closed") return;
			const wasOpening = state === "opening";
			if (ackTimer !== void 0) {
				clearTimeout(ackTimer);
				ackTimer = void 0;
			}
			if ("ack" in outcome) {
				state = "open";
				resolveOpening(outcome.ack);
				return;
			}
			state = "closed";
			if (onCallerAbort !== void 0) options?.signal?.removeEventListener("abort", onCallerAbort);
			this._listenState.delete(listenId);
			requestAbort.abort();
			resolveClosed(outcome.cause);
			if (wasOpening) rejectOpening(outcome.error ?? new require_src.SdkError(require_src.SdkErrorCode.ConnectionClosed, "subscriptions/listen closed before the server acknowledged"));
		};
		const wireTeardown = async () => {
			requestAbort.abort();
			await this.notification({
				method: "notifications/cancelled",
				params: { requestId: listenId }
			}).catch(() => {});
		};
		const close = async () => {
			if (state === "closed") return;
			settle({ cause: "local" });
			await wireTeardown();
		};
		this._listenState.set(listenId, { settle });
		const ackTimeout = options?.timeout ?? require_src.DEFAULT_REQUEST_TIMEOUT_MSEC;
		ackTimer = setTimeout(() => {
			settle({
				cause: "remote",
				error: new require_src.SdkError(require_src.SdkErrorCode.RequestTimeout, "subscriptions/listen ack timed out", { timeout: ackTimeout })
			});
			wireTeardown().catch(() => {});
		}, ackTimeout);
		if (options?.signal) {
			const callerSignal = options.signal;
			onCallerAbort = () => {
				if (state === "closed") return;
				const reason = callerSignal.reason;
				settle({
					cause: "local",
					error: reason instanceof Error ? reason : new Error(String(reason ?? "Aborted"))
				});
				wireTeardown().catch(() => {});
			};
			callerSignal.addEventListener("abort", onCallerAbort, { once: true });
		}
		const jsonrpcRequest = {
			jsonrpc: "2.0",
			id: listenId,
			method: "subscriptions/listen",
			params: {
				_meta: { ...this._outboundMetaEnvelope() },
				notifications: filter
			}
		};
		const routeSendFailure = (error) => {
			settle({
				cause: "remote",
				error: error instanceof Error ? error : new Error(String(error))
			});
		};
		try {
			this.transport.send(jsonrpcRequest, {
				requestSignal: requestAbort.signal,
				onRequestStreamEnd: () => settle({
					cause: "remote",
					error: /* @__PURE__ */ new Error("subscriptions/listen: stream ended")
				})
			}).catch(routeSendFailure);
		} catch (error) {
			routeSendFailure(error);
		}
		return {
			honoredFilter: await opening,
			close,
			closed
		};
	}
	/**
	* The subscription auto-opened by `ClientOptions.listChanged` on a modern
	* connection — the listen filter is the intersection of the configured
	* sub-options and the server-advertised `listChanged` capabilities.
	* `undefined` on a legacy connection, before connect, or when that
	* intersection is empty (auto-open skipped). Exposed so the consumer can
	* `close()` it.
	*/
	get autoOpenedSubscription() {
		return this._autoOpenedSubscription;
	}
	/**
	* Transport-level demux for `subscriptions/listen` notifications, before
	* any decoding/era-gating/handler dispatch. Consumes the leading
	* `notifications/subscriptions/acknowledged` referencing a live
	* subscription id (resolves the ack waiter) and an inbound
	* `notifications/cancelled` referencing a live string-typed subscription
	* id (server-side teardown on stdio). Change notifications carrying a
	* subscription id pass through to the existing registered handlers via
	* `super`. An unmatched ack/cancelled is NOT consumed: it reaches
	* `setNotificationHandler` / `fallbackNotificationHandler` instead of
	* being silently swallowed.
	*/
	_onnotification(raw, extra) {
		const evicted = Object.hasOwn(LIST_CHANGED_EVICTIONS, raw.method) ? LIST_CHANGED_EVICTIONS[raw.method] : void 0;
		if (raw.method === "notifications/resources/updated") {
			const uri = raw.params?.uri;
			if (typeof uri === "string") this._cache.evictKey("resources/read", uri);
		} else if (evicted !== void 0) for (const method of evicted) this._cache.evict(method);
		if (raw.method === "notifications/subscriptions/acknowledged") {
			const subscriptionId = raw.params?._meta?.[_modelcontextprotocol_core_internal.SUBSCRIPTION_ID_META_KEY];
			const entry = typeof subscriptionId === "string" ? this._listenState.get(subscriptionId) : void 0;
			if (entry !== void 0) {
				const honored = this._wireCodec().validateNotification("notifications/subscriptions/acknowledged", raw);
				entry.settle({ ack: honored.ok ? honored.value.params.notifications : {} });
				return;
			}
		}
		if (raw.method === "notifications/cancelled") {
			const cancelledId = raw.params?.requestId;
			const entry = typeof cancelledId === "string" ? this._listenState.get(cancelledId) : void 0;
			if (entry !== void 0) {
				entry.settle({
					cause: "remote",
					error: /* @__PURE__ */ new Error("subscriptions/listen: server cancelled the subscription")
				});
				return;
			}
		}
		super._onnotification(raw, extra);
	}
	/**
	* Transport-level demux for `subscriptions/listen` responses. A JSON-RPC
	* ERROR for the listen id is the server's pre-ack capacity/params
	* rejection; a JSON-RPC RESULT for the listen id is the spec's
	* `SubscriptionsListenResult` — the server's GRACEFUL-close signal (sent
	* on shutdown). A string-id response that matches a live `_listenState`
	* entry is consumed here (Protocol's `_responseHandlers` map is keyed by
	* NUMBER and never holds a listen id, so passing a string-id response
	* through would surface as "unknown message ID" via `onerror`).
	*/
	_onresponse(response) {
		const id = response.id;
		const entry = typeof id === "string" ? this._listenState.get(id) : void 0;
		if (entry !== void 0) {
			if (require_src.isJSONRPCErrorResponse(response)) entry.settle({
				cause: "remote",
				error: require_src.ProtocolError.fromError(response.error.code, response.error.message, response.error.data)
			});
			else entry.settle({
				cause: "graceful",
				error: new require_src.SdkError(require_src.SdkErrorCode.ConnectionClosed, "subscriptions/listen: server closed the subscription gracefully before acknowledging")
			});
			return;
		}
		super._onresponse(response);
	}
	/**
	* Settle every live per-listen state machine on a transport-initiated
	* close (the server dropping the connection on stdio/InMemory) before
	* Protocol's `_onclose` tears the transport down. The base
	* `_responseHandlers` settlement does not reach `_listenState` (listen
	* ids are never registered there), so without this override a remote
	* close would leave an in-flight `listen()` / open `McpSubscription`
	* hanging.
	*/
	_onclose() {
		if (this._listenState.size > 0) {
			const reason = new require_src.SdkError(require_src.SdkErrorCode.ConnectionClosed, "Connection closed");
			for (const entry of this._listenState.values()) entry.settle({
				cause: "remote",
				error: reason
			});
			this._listenState.clear();
		}
		super._onclose();
	}
	/**
	* Calls a tool on the connected server and returns the result. Automatically validates structured output
	* if the tool has an `outputSchema`.
	*
	* Tool results have two error surfaces: `result.isError` for tool-level failures (the tool ran but reported
	* a problem), and thrown {@linkcode ProtocolError} for protocol-level failures or {@linkcode SdkError} for
	* SDK-level issues (timeouts, missing capabilities).
	*
	* @example Basic usage
	* ```ts source="./client.examples.ts#Client_callTool_basic"
	* const result = await client.callTool({
	*     name: 'calculate-bmi',
	*     arguments: { weightKg: 70, heightM: 1.75 }
	* });
	*
	* // Tool-level errors are returned in the result, not thrown
	* if (result.isError) {
	*     console.error('Tool error:', result.content);
	*     return;
	* }
	*
	* console.log(result.content);
	* ```
	*
	* @example Structured output
	* ```ts source="./client.examples.ts#Client_callTool_structuredOutput"
	* const result = await client.callTool({
	*     name: 'calculate-bmi',
	*     arguments: { weightKg: 70, heightM: 1.75 }
	* });
	*
	* // Machine-readable output for the client application. SEP-2106: structuredContent is
	* // `unknown` (any JSON value). Check for presence with `!== undefined` and narrow before use.
	* if (result.structuredContent !== undefined) {
	*     const sc: unknown = result.structuredContent; // e.g. { bmi: 22.86 }
	*     if (typeof sc === 'object' && sc !== null && 'bmi' in sc) {
	*         console.log(sc.bmi);
	*     }
	* }
	* ```
	*/
	async callTool(params, options) {
		const mirroringActive = this.getProtocolEra() === "modern" && detectProbeEnvironment() !== "browser";
		const buildSendOptions = async () => {
			if (!mirroringActive) return options;
			let scan;
			try {
				scan = await this._resolveXMcpHeaderScan(params.name, options?.toolDefinition);
			} catch (error) {
				this._reportStoreError(error);
			}
			if (!scan?.valid || scan.declarations.length === 0) return options;
			const paramHeaders = require_src.buildMcpParamHeaders(scan.declarations, params.arguments);
			return Object.keys(paramHeaders).length === 0 ? options : {
				...options,
				headers: {
					...options?.headers,
					...paramHeaders
				}
			};
		};
		let compiled = options?.toolDefinition === void 0 ? await this._cache.outputValidator(params.name, (tool) => this._compileOutputValidator(tool)).catch((error) => void this._reportStoreError(error)) : this._compileOutputValidator(options.toolDefinition);
		const assertCompiled = () => {
			if (compiled === void 0 || compiled.ok) return;
			const err = compiled.compileError;
			const message = (err instanceof Error ? err.message : String(err)).slice(0, 200);
			throw new require_src.ProtocolError(require_src.ProtocolErrorCode.InvalidParams, `Tool '${params.name}' has an invalid outputSchema: ${message}`);
		};
		assertCompiled();
		let result;
		try {
			result = await this.request({
				method: "tools/call",
				params
			}, await buildSendOptions());
		} catch (error) {
			const isHeaderMismatch = error instanceof require_src.ProtocolError && error.code === require_src.HEADER_MISMATCH_ERROR_CODE;
			if (!mirroringActive || !isHeaderMismatch || options?.toolDefinition !== void 0) throw error;
			const refreshOptions = {
				signal: options?.signal,
				timeout: options?.timeout,
				cacheMode: "refresh"
			};
			await this._cache.evict("tools/list");
			await this.listTools(void 0, refreshOptions).catch((error_) => this._reportStoreError(error_));
			compiled = await this._cache.outputValidator(params.name, (tool) => this._compileOutputValidator(tool)).catch((error_) => void this._reportStoreError(error_));
			assertCompiled();
			result = await this.request({
				method: "tools/call",
				params
			}, await buildSendOptions());
		}
		const validator = compiled !== void 0 && compiled.ok ? compiled.validator : void 0;
		if (validator) {
			if (result.structuredContent === void 0 && !result.isError) throw new require_src.ProtocolError(require_src.ProtocolErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
			if (result.structuredContent !== void 0 && !result.isError) try {
				const validationResult = validator(result.structuredContent);
				if (!validationResult.valid) throw new require_src.ProtocolError(require_src.ProtocolErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
			} catch (error) {
				if (error instanceof require_src.ProtocolError) throw error;
				throw new require_src.ProtocolError(require_src.ProtocolErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`);
			}
		}
		return result;
	}
	/**
	* Lists available tools.
	*
	* Called without a `cursor` (the common case), this walks every page and
	* returns the complete aggregated list with no `nextCursor`; the
	* aggregate is also written to the {@linkcode ResponseCacheStore} (the
	* source for {@linkcode callTool | callTool()}'s output-schema validation
	* and SEP-2243 `Mcp-Param-*` header mirroring). Pass an explicit
	* `{ cursor }` to fetch a single page and walk pagination yourself — the
	* per-page path returns the server's raw page (with `nextCursor` for the
	* next call) and does not write the response cache. The auto-aggregate
	* path is capped by {@linkcode ClientOptions | ClientOptions.listMaxPages} (default 64);
	* the per-page path is not.
	*
	* Returns an empty list if the server does not advertise tools capability
	* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
	*
	* @example
	* ```ts source="./client.examples.ts#Client_listTools_pagination"
	* // No cursor → all pages aggregated for you.
	* const { tools } = await client.listTools();
	* console.log(
	*     'Available tools:',
	*     tools.map(t => t.name)
	* );
	* ```
	*/
	async listTools(params, options) {
		if (!this._serverCapabilities?.tools && !this._enforceStrictCapabilities) {
			console.debug("Client.listTools() called but server does not advertise tools capability - returning empty list");
			return { tools: [] };
		}
		if (params?.cursor !== void 0) {
			const page = await this.request({
				method: "tools/list",
				params
			}, options);
			this._excludeInvalidXMcpHeaderTools(page);
			return page;
		}
		const hit = await this._serveFromCache("tools/list", void 0, options);
		if (hit !== void 0) return hit;
		return this._listAllPages("tools/list", params, options, (r) => r.tools, (acc) => this._excludeInvalidXMcpHeaderTools(acc));
	}
	/**
	* SEP-2243 (protocol revision 2026-07-28): a Streamable HTTP client MUST
	* exclude tool definitions whose `x-mcp-header` declarations violate the
	* constraints, and SHOULD log a warning naming the tool and the reason.
	* Applied to the CACHED aggregated `tools/list` result (so the entry
	* mirroring reads never holds an unmirrorable tool) AND to every public
	* per-page {@linkcode listTools | listTools()} return (the spec's MUST
	* has no carve-out for paginated reads). The gate is era-only on
	* non-stdio transports — `detectProbeTransportKind` cannot distinguish a
	* real HTTP transport from in-memory/custom transports (it only
	* positively recognizes stdio), and over-excluding on a non-HTTP modern
	* connection is harmless: those transports never carry per-request
	* headers, so an excluded tool would have been uncallable on a Streamable
	* HTTP arm of the same server. Mutates `result.tools` in place.
	*/
	_excludeInvalidXMcpHeaderTools(result) {
		if (this.getProtocolEra() !== "modern" || !this.transport || detectProbeTransportKind(this.transport) === "stdio") return;
		const filtered = result.tools.filter((tool) => {
			const scan = require_src.scanXMcpHeaderDeclarations(tool.inputSchema);
			if (!scan.valid) {
				console.warn(`[mcp-sdk] excluding tool '${tool.name}' from tools/list: invalid x-mcp-header declaration — ${scan.reason}`);
				return false;
			}
			return true;
		});
		if (filtered.length !== result.tools.length) result.tools = filtered;
	}
	/**
	* Set up a single list changed handler.
	* @internal
	*/
	_setupListChangedHandler(listType, notificationMethod, options, fetcher) {
		const parseResult = require_src.parseSchema(_modelcontextprotocol_core_internal.ListChangedOptionsBaseSchema, options);
		if (!parseResult.success) throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
		if (typeof options.onChanged !== "function") throw new TypeError(`Invalid ${listType} listChanged options: onChanged must be a function`);
		const { autoRefresh, debounceMs } = parseResult.data;
		const { onChanged } = options;
		const refresh = async () => {
			if (!autoRefresh) {
				onChanged(null, null);
				return;
			}
			try {
				onChanged(null, await fetcher());
			} catch (error) {
				onChanged(error instanceof Error ? error : new Error(String(error)), null);
			}
		};
		const handler = () => {
			if (debounceMs) {
				const existingTimer = this._listChangedDebounceTimers.get(listType);
				if (existingTimer) clearTimeout(existingTimer);
				const timer = setTimeout(refresh, debounceMs);
				this._listChangedDebounceTimers.set(listType, timer);
			} else refresh();
		};
		this.setNotificationHandler(notificationMethod, handler);
	}
	/**
	* Notifies the server that the client's root list has changed. Requires the `roots.listChanged` capability.
	*
	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
	* Remains functional during the deprecation window (at least twelve months).
	* Migrate to passing paths via tool parameters, resource URIs, or configuration.
	*/
	async sendRootsListChanged() {
		return this.notification({ method: "notifications/roots/list_changed" });
	}
};

//#endregion
//#region src/client/crossAppAccess.ts
/**
* Requests a JWT Authorization Grant (ID-JAG) from an enterprise IdP using RFC 8693 Token Exchange.
*
* This function performs step 2 of the Enterprise Managed Authorization flow:
* exchanges an ID Token for a JWT Authorization Grant that can be used with the target MCP server.
*
* @param options - Configuration for the token exchange request
* @returns The JWT Authorization Grant and related metadata
* @throws {Error} If the token exchange fails or returns an error response
*
* @example
* ```ts
* const result = await requestJwtAuthorizationGrant({
*     tokenEndpoint: 'https://idp.example.com/token',
*     audience: 'https://auth.chat.example/',
*     resource: 'https://mcp.chat.example/',
*     idToken: 'eyJhbGciOiJS...',
*     clientId: 'my-idp-client',
*     clientSecret: 'my-idp-secret',
*     scope: 'chat.read chat.history'
* });
*
* // Use result.jwtAuthGrant with the MCP server's authorization server
* ```
*/
async function requestJwtAuthorizationGrant(options) {
	const { tokenEndpoint, audience, resource, idToken, clientId, clientSecret, scope, fetchFn = fetch } = options;
	const tokenUrl = assertSecureTokenEndpoint(tokenEndpoint);
	const params = new URLSearchParams({
		grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
		requested_token_type: "urn:ietf:params:oauth:token-type:id-jag",
		audience: String(audience),
		resource: String(resource),
		subject_token: idToken,
		subject_token_type: "urn:ietf:params:oauth:token-type:id_token",
		client_id: clientId
	});
	if (clientSecret) params.set("client_secret", clientSecret);
	if (scope) params.set("scope", scope);
	const response = await require_src.fetchWithinOrigin(fetchFn)(tokenUrl, {
		method: "POST",
		headers: { "Content-Type": "application/x-www-form-urlencoded" },
		body: params.toString()
	});
	if (!response.ok) {
		const errorBody = await response.json().catch(() => ({}));
		const parseResult$1 = _modelcontextprotocol_core_internal.OAuthErrorResponseSchema.safeParse(errorBody);
		if (parseResult$1.success) {
			const { error, error_description } = parseResult$1.data;
			throw new Error(`Token exchange failed: ${error}${error_description ? ` - ${error_description}` : ""}`);
		}
		throw new Error(`Token exchange failed with status ${response.status}: ${JSON.stringify(errorBody)}`);
	}
	const parseResult = _modelcontextprotocol_core_internal.IdJagTokenExchangeResponseSchema.safeParse(await response.json());
	if (!parseResult.success) throw new Error(`Invalid token exchange response: ${parseResult.error.message}`);
	return {
		jwtAuthGrant: parseResult.data.access_token,
		expiresIn: parseResult.data.expires_in,
		scope: parseResult.data.scope
	};
}
/**
* Discovers the IdP's token endpoint and requests a JWT Authorization Grant.
*
* This is a convenience wrapper around {@linkcode requestJwtAuthorizationGrant} that
* first performs OAuth metadata discovery to find the token endpoint.
*
* @param options - Configuration including IdP URL for discovery
* @returns The JWT Authorization Grant and related metadata
* @throws {Error} If discovery fails or the token exchange fails
*
* @example
* ```ts
* const result = await discoverAndRequestJwtAuthGrant({
*     idpUrl: 'https://idp.example.com',
*     audience: 'https://auth.chat.example/',
*     resource: 'https://mcp.chat.example/',
*     idToken: await getIdToken(),
*     clientId: 'my-idp-client',
*     clientSecret: 'my-idp-secret'
* });
* ```
*/
async function discoverAndRequestJwtAuthGrant(options) {
	const { idpUrl, fetchFn = fetch, ...restOptions } = options;
	const metadata = await discoverAuthorizationServerMetadata(String(idpUrl), { fetchFn });
	if (!metadata?.token_endpoint) throw new Error(`Failed to discover token endpoint for IdP: ${idpUrl}`);
	return requestJwtAuthorizationGrant({
		...restOptions,
		tokenEndpoint: metadata.token_endpoint,
		fetchFn
	});
}
/**
* Exchanges a JWT Authorization Grant for an access token at the MCP server's authorization server.
*
* This function performs step 3 of the Enterprise Managed Authorization flow:
* uses the JWT Authorization Grant to obtain an access token from the MCP server.
*
* @param options - Configuration for the JWT grant exchange
* @returns OAuth tokens (access token, token type, etc.)
* @throws {Error} If the exchange fails or returns an error response
*
* Defaults to `client_secret_basic` (HTTP Basic Authorization header), matching
* `CrossAppAccessProvider`'s declared `token_endpoint_auth_method` and the
* SEP-990 conformance test requirements. Use `authMethod: 'client_secret_post'` only
* when the authorization server explicitly requires it.
*
* @example
* ```ts
* const tokens = await exchangeJwtAuthGrant({
*     tokenEndpoint: 'https://auth.chat.example/token',
*     jwtAuthGrant: 'eyJhbGci...',
*     clientId: 'my-mcp-client',
*     clientSecret: 'my-mcp-secret'
* });
*
* // Use tokens.access_token to access the MCP server
* ```
*/
async function exchangeJwtAuthGrant(options) {
	const { tokenEndpoint, jwtAuthGrant, clientId, clientSecret, authMethod = "client_secret_basic", fetchFn = fetch } = options;
	const tokenUrl = assertSecureTokenEndpoint(tokenEndpoint);
	const params = new URLSearchParams({
		grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
		assertion: jwtAuthGrant
	});
	const headers = new Headers({ "Content-Type": "application/x-www-form-urlencoded" });
	applyClientAuthentication(authMethod, {
		client_id: clientId,
		client_secret: clientSecret
	}, headers, params);
	const response = await require_src.fetchWithinOrigin(fetchFn)(tokenUrl, {
		method: "POST",
		headers,
		body: params.toString()
	});
	if (!response.ok) {
		const errorBody = await response.json().catch(() => ({}));
		const parseResult$1 = _modelcontextprotocol_core_internal.OAuthErrorResponseSchema.safeParse(errorBody);
		if (parseResult$1.success) {
			const { error, error_description } = parseResult$1.data;
			throw new Error(`JWT grant exchange failed: ${error}${error_description ? ` - ${error_description}` : ""}`);
		}
		throw new Error(`JWT grant exchange failed with status ${response.status}: ${JSON.stringify(errorBody)}`);
	}
	const responseBody = await response.json();
	const parseResult = _modelcontextprotocol_core_internal.OAuthTokensSchema.safeParse(require_src.withoutIssuer(responseBody));
	if (!parseResult.success) throw new Error(`Invalid token response: ${parseResult.error.message}`);
	return parseResult.data;
}

//#endregion
//#region src/client/dpop.ts
/** Asymmetric JWS algorithms usable for a DPoP proof (RFC 9449 §11.6 forbids symmetric algs and `none`). */
const DPOP_SUPPORTED_ALGS = [
	"ES256",
	"ES384",
	"ES512",
	"RS256",
	"RS384",
	"RS512",
	"PS256",
	"PS384",
	"PS512",
	"EdDSA"
];
const DEFAULT_DPOP_ALG = "ES256";
const DPOP_TYP = "dpop+jwt";
async function importJose() {
	if (globalThis.crypto === void 0) throw new TypeError("crypto is not available, please ensure you have Web Crypto API support for older Node.js versions (see https://github.com/modelcontextprotocol/typescript-sdk#nodejs-web-crypto-globalthiscrypto-compatibility)");
	return import("jose");
}
/** Generate an asymmetric DPoP signing key pair. Non-extractable by default (RFC 9449 §11). */
async function generateDpopKeyPair(options = {}) {
	const alg = options.alg ?? DEFAULT_DPOP_ALG;
	const jose = await importJose();
	const { publicKey, privateKey } = await jose.generateKeyPair(alg, { extractable: options.extractable ?? false });
	const publicJwk = await jose.exportJWK(publicKey);
	return {
		privateKey,
		publicKey,
		publicJwk,
		thumbprint: await jose.calculateJwkThumbprint(publicJwk, "sha256"),
		alg
	};
}
/**
* Compute the `ath` claim for a DPoP proof presented alongside an access token: the
* base64url-encoded SHA-256 digest of the ASCII access-token value (RFC 9449 §4.1).
*
* Uses Web Crypto (`crypto.subtle`) rather than a Node-only hashing API so this stays usable
* in browser and edge runtimes.
*/
async function accessTokenHash(accessToken) {
	if (globalThis.crypto?.subtle === void 0) throw new TypeError("crypto.subtle is not available, please ensure you have Web Crypto API support for older Node.js versions (see https://github.com/modelcontextprotocol/typescript-sdk#nodejs-web-crypto-globalthiscrypto-compatibility)");
	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(accessToken));
	return base64UrlEncode(new Uint8Array(digest));
}
function base64UrlEncode(bytes) {
	let binary = "";
	for (const byte of bytes) binary += String.fromCodePoint(byte);
	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
}
/** Strip the query and fragment from a URL, per RFC 9449 §4.2 (`htu` MUST NOT contain either). */
function stripQueryAndFragment(url) {
	const u = new URL(url.toString());
	return `${u.origin}${u.pathname}`;
}
/** A fresh, cryptographically random `jti` (RFC 9449 §4.2 — MUST be unique per proof). */
function randomJti() {
	const bytes = new Uint8Array(16);
	globalThis.crypto.getRandomValues(bytes);
	return base64UrlEncode(bytes);
}
/**
* A DPoP signing identity plus the small amount of state RFC 9449 requires across requests:
* the key pair and, per origin, the most recently server-supplied nonce (RFC 9449 §8/§9).
*
* One `DpopSession` is meant to live for the lifetime of a single OAuth client registration —
* the token endpoint and the resource server are different origins and get independent nonce
* slots, so a nonce challenge from one never leaks into proofs sent to the other.
*/
var DpopSession = class DpopSession {
	nonces = /* @__PURE__ */ new Map();
	constructor(keyPair) {
		this.keyPair = keyPair;
	}
	/** Create a session with a fresh key pair, or reuse a caller-supplied one. */
	static async create(options = {}) {
		return new DpopSession(options.keyPair ?? await generateDpopKeyPair({ alg: options.alg }));
	}
	/** RFC 7638 JWK SHA-256 thumbprint of the signing key — matches the token's `cnf.jkt` once bound. */
	get thumbprint() {
		return this.keyPair.thumbprint;
	}
	/** The JWS algorithm this session signs proofs with. */
	get alg() {
		return this.keyPair.alg;
	}
	/** The public JWK embedded in every proof's `jwk` header parameter. */
	get publicJwk() {
		return this.keyPair.publicJwk;
	}
	/** The remembered nonce for `url`'s origin, if the server has issued one (RFC 9449 §8/§9). */
	nonceFor(url) {
		return this.nonces.get(new URL(url.toString()).origin);
	}
	/** Record a server-supplied nonce for `url`'s origin (newest-wins, RFC 9449 §8.2). */
	rememberNonce(url, nonce) {
		this.nonces.set(new URL(url.toString()).origin, nonce);
	}
	/**
	* Capture a `DPoP-Nonce` response header, if present, for `url`'s origin. RFC 9449 §8.2 says a
	* fresh nonce may ride on *any* response (success or failure), so call this unconditionally
	* after every request, not only on a `use_dpop_nonce` challenge.
	*/
	observeNonce(response, url) {
		const nonce = response.headers.get("dpop-nonce");
		if (nonce) this.rememberNonce(url, nonce);
	}
	/**
	* Build a fresh DPoP proof JWT. Always mints a new `jti` — proofs are never cached or reused,
	* since RFC 9449 §4.3 step 9 requires each to be presented at most once.
	*/
	async buildProof(request) {
		const jose = await importJose();
		const htu = stripQueryAndFragment(request.htu);
		const nonce = request.nonce ?? this.nonceFor(request.htu);
		const payload = {
			jti: randomJti(),
			htm: request.htm.toUpperCase(),
			htu,
			iat: Math.floor(Date.now() / 1e3)
		};
		if (request.accessToken !== void 0) payload.ath = await accessTokenHash(request.accessToken);
		if (nonce !== void 0) payload.nonce = nonce;
		return new jose.SignJWT(payload).setProtectedHeader({
			alg: this.keyPair.alg,
			typ: DPOP_TYP,
			jwk: this.keyPair.publicJwk
		}).sign(this.keyPair.privateKey);
	}
};
/**
* Whether `wwwAuthenticate` advertises a `DPoP` auth-scheme challenge (matched at the start of the
* header or after a comma, per RFC 9110 §11.6.1 — a server may list several schemes together, e.g.
* `Bearer …, DPoP …`).
*/
function hasDpopChallenge(wwwAuthenticate) {
	return /(?:^|,)\s*dpop(?:\s|$|,)/i.test(wwwAuthenticate);
}
/**
* Whether `response` is a resource-server `use_dpop_nonce` challenge (RFC 9449 §9): a `401` whose
* `WWW-Authenticate` header carries a `DPoP` challenge with `error="use_dpop_nonce"`.
*
* A conformant retry re-signs the proof with the nonce {@linkcode DpopSession.observeNonce} just
* captured — never resend the original proof: RFC 9449 §4.2 requires a unique `jti` per proof, and
* replaying one across the challenge/retry boundary is itself a violation.
*/
function isDpopNonceChallenge(response) {
	if (response.status !== 401) return false;
	const wwwAuthenticate = response.headers.get("www-authenticate") ?? "";
	return hasDpopChallenge(wwwAuthenticate) && /use_dpop_nonce/i.test(wwwAuthenticate);
}

//#endregion
//#region src/client/middleware.ts
/**
* Creates a fetch wrapper that handles OAuth authentication automatically.
*
* This wrapper will:
* - Add `Authorization` headers with access tokens
* - Handle 401 responses by attempting re-authentication
* - Retry the original request after successful auth
* - Handle OAuth errors appropriately ({@linkcode index.OAuthErrorCode.InvalidClient | OAuthErrorCode.InvalidClient}, etc.)
* - When {@linkcode OAuthClientProvider.dpop | provider.dpop()} is implemented, present DPoP-bound
*   tokens with the `DPoP` scheme plus a per-request proof (RFC 9449 / SEP-1932) by composing
*   {@linkcode withDpopFromProvider} underneath — so a `use_dpop_nonce` challenge is retried
*   inline on every attempt, independently of the single re-authentication retry here
*
* The `baseUrl` parameter is optional and defaults to using the domain from the request URL.
* However, you should explicitly provide `baseUrl` when:
* - Making requests to multiple subdomains (e.g., api.example.com, cdn.example.com)
* - Using API paths that differ from OAuth discovery paths (e.g., requesting /api/v1/data but OAuth is at /)
* - The OAuth server is on a different domain than your API requests
* - You want to ensure consistent OAuth behavior regardless of request URLs
*
* For MCP transports, set `baseUrl` to the same URL you pass to the transport constructor.
*
* Note: This wrapper is designed for general-purpose fetch operations.
* MCP transports (SSE and StreamableHTTP) already have built-in OAuth handling
* and should not need this wrapper.
*
* @param provider - OAuth client provider for authentication
* @param baseUrl - Base URL for OAuth server discovery (defaults to request URL domain)
* @returns A fetch middleware function
*/
const withOAuth = (provider, baseUrl) => (baseNext) => {
	const next = provider.dpop ? withDpopFromProvider(provider)(baseNext) : baseNext;
	return async (input, init) => {
		const makeRequest = async () => {
			const headers = new Headers(init?.headers);
			const tokens = await provider.tokens();
			if (tokens) headers.set("Authorization", `Bearer ${tokens.access_token}`);
			return await next(input, {
				...init,
				headers
			});
		};
		let response = await makeRequest();
		if (response.status === 401) try {
			const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
			const result = await auth(provider, {
				serverUrl: baseUrl || (typeof input === "string" ? new URL(input).origin : input.origin),
				resourceMetadataUrl,
				scope,
				fetchFn: baseNext
			});
			if (result === "REDIRECT") throw new UnauthorizedError("Authentication requires user authorization - redirect initiated");
			if (result !== "AUTHORIZED") throw new UnauthorizedError(`Authentication failed with result: ${result}`);
			response = await makeRequest();
		} catch (error) {
			if (error instanceof UnauthorizedError) throw error;
			throw new UnauthorizedError(`Failed to re-authenticate: ${error instanceof Error ? error.message : String(error)}`);
		}
		if (response.status === 401) throw new UnauthorizedError(`Authentication failed for ${typeof input === "string" ? input : input.toString()}`);
		return response;
	};
};
/**
* Creates a fetch wrapper that presents an access token using the `DPoP` Authorization scheme
* (RFC 9449 / SEP-1932) instead of `Bearer`: every request carries `Authorization: DPoP <token>`
* plus a fresh `DPoP` proof bound to that request's method and URL, a resource-server
* `use_dpop_nonce` challenge (RFC 9449 §9) is retried once, inline, with the server-supplied nonce,
* and a `DPoP-Nonce` delivered on any response is remembered for the next proof (RFC 9449 §8.2).
*
* Because it wraps `fetch` itself, the proof is always bound to the request actually sent and every
* response is observed — which is why the MCP transports apply this wrapper internally (via
* {@linkcode withDpopFromProvider}) when their `authProvider` implements
* {@linkcode OAuthClientProvider.dpop | dpop()}, rather than threading request context through
* {@linkcode AuthProvider}.
*
* Use this directly when you already manage the access token yourself (a non-OAuth token source,
* or credentials obtained out-of-band) and only need DPoP's request-signing behavior — e.g.
* `fetch: withDpop(session, getToken)(fetch)` alongside a minimal `authProvider: { token }`.
*
* @param session - The DPoP signing session (key pair + nonce state), or a function resolving to
*   it. Reuse the same session across requests to the same server so its nonce state persists.
*   When the function resolves to `undefined` the request passes through unchanged.
* @param getToken - Returns the current access token, or `undefined` if none is available (the
*   request passes through unchanged — any `Authorization` header already on it is left as is).
* @returns A fetch middleware function
*/
const withDpop = (session, getToken) => (next) => {
	const resolveSession = typeof session === "function" ? session : () => session;
	return async (input, init) => {
		const method = (init?.method ?? "GET").toUpperCase();
		const url = new URL(input.toString());
		const activeSession = await resolveSession();
		if (!activeSession) return next(input, init);
		const makeRequest = async () => {
			const accessToken = await getToken();
			if (!accessToken) return next(input, init);
			const headers = new Headers(init?.headers);
			const proof = await activeSession.buildProof({
				htm: method,
				htu: url,
				accessToken
			});
			headers.set("Authorization", `DPoP ${accessToken}`);
			headers.set("DPoP", proof);
			return next(input, {
				...init,
				headers
			});
		};
		let response = await makeRequest();
		if (isDpopNonceChallenge(response) && response.headers.has("dpop-nonce")) {
			activeSession.observeNonce(response, url);
			await response.text?.().catch(() => {});
			response = await makeRequest();
		}
		activeSession.observeNonce(response, url);
		return response;
	};
};
/**
* {@linkcode withDpop} driven by an {@linkcode OAuthClientProvider}: the session comes from
* {@linkcode OAuthClientProvider.dpop | provider.dpop()} and the token from
* {@linkcode OAuthClientProvider.tokens | provider.tokens()} — presented with the DPoP scheme only
* when the AS actually issued `token_type: "DPoP"` (RFC 9449 §7.1); a Bearer token passes through
* untouched.
*
* This is what the MCP transports and {@linkcode withOAuth} compose internally when the provider
* implements `dpop()`. Use it directly only when building your own fetch pipeline around an
* `OAuthClientProvider` (e.g. a custom re-authorization middleware) — place it *innermost*, below
* whatever sets `Authorization: Bearer` and handles 401 re-authentication.
*/
const withDpopFromProvider = (provider) => withDpop(async () => {
	try {
		return await provider.dpop?.();
	} catch (error) {
		throw markAuthSeamEscape(error);
	}
}, async () => {
	let tokens;
	try {
		tokens = await provider.tokens();
	} catch (error) {
		throw markAuthSeamEscape(error);
	}
	return tokens?.token_type?.toLowerCase() === "dpop" ? tokens.access_token : void 0;
});
/**
* Creates a fetch middleware that logs HTTP requests and responses.
*
* When called without arguments `withLogging()`, it uses the default logger that:
* - Logs successful requests (2xx) to `console.log`
* - Logs error responses (4xx/5xx) and network errors to `console.error`
* - Logs all requests regardless of status (`statusLevel: 0`)
* - Does not include request or response headers in logs
* - Measures and displays request duration in milliseconds
*
* Important: the default logger uses both `console.log` and `console.error` so it should not be used with
* `stdio` transports and applications.
*
* @param options - Logging configuration options
* @returns A fetch middleware function
*/
const withLogging = (options = {}) => {
	const { logger, includeRequestHeaders = false, includeResponseHeaders = false, statusLevel = 0 } = options;
	const defaultLogger = (input) => {
		const { method, url, status, statusText, duration, requestHeaders, responseHeaders, error } = input;
		let message = error ? `HTTP ${method} ${url} failed: ${error.message} (${duration}ms)` : `HTTP ${method} ${url} ${status} ${statusText} (${duration}ms)`;
		if (includeRequestHeaders && requestHeaders) {
			const reqHeaders = [...requestHeaders.entries()].map(([key, value]) => `${key}: ${value}`).join(", ");
			message += `\n  Request Headers: {${reqHeaders}}`;
		}
		if (includeResponseHeaders && responseHeaders) {
			const resHeaders = [...responseHeaders.entries()].map(([key, value]) => `${key}: ${value}`).join(", ");
			message += `\n  Response Headers: {${resHeaders}}`;
		}
		if (error || status >= 400) console.error(message);
		else console.log(message);
	};
	const logFn = logger || defaultLogger;
	return (next) => async (input, init) => {
		const startTime = performance.now();
		const method = init?.method || "GET";
		const url = typeof input === "string" ? input : input.toString();
		const requestHeaders = includeRequestHeaders ? new Headers(init?.headers) : void 0;
		try {
			const response = await next(input, init);
			const duration = performance.now() - startTime;
			if (response.status >= statusLevel) logFn({
				method,
				url,
				status: response.status,
				statusText: response.statusText,
				duration,
				requestHeaders,
				responseHeaders: includeResponseHeaders ? response.headers : void 0
			});
			return response;
		} catch (error) {
			logFn({
				method,
				url,
				status: 0,
				statusText: "Network Error",
				duration: performance.now() - startTime,
				requestHeaders,
				error
			});
			throw error;
		}
	};
};
/**
* Composes multiple fetch middleware functions into a single middleware pipeline.
* Middleware are applied in the order they appear, creating a chain of handlers.
*
* @example
* ```ts source="./middleware.examples.ts#applyMiddlewares_basicUsage"
* // Create a middleware pipeline that handles both OAuth and logging
* const enhancedFetch = applyMiddlewares(withOAuth(oauthProvider, 'https://api.example.com'), withLogging({ statusLevel: 400 }))(fetch);
*
* // Use the enhanced fetch - it will handle auth and log errors
* const response = await enhancedFetch('https://api.example.com/data');
* ```
*
* @param middleware - Array of fetch middleware to compose into a pipeline
* @returns A single composed middleware function
*/
const applyMiddlewares = (...middleware) => {
	return (next) => {
		let handler = next;
		for (const mw of middleware) handler = mw(handler);
		return handler;
	};
};
/**
* Helper function to create custom fetch middleware with cleaner syntax.
* Provides the next handler and request details as separate parameters for easier access.
*
* @example
* ```ts source="./middleware.examples.ts#createMiddleware_examples"
* // Create custom authentication middleware
* const customAuthMiddleware = createMiddleware(async (next, input, init) => {
*     const headers = new Headers(init?.headers);
*     headers.set('X-Custom-Auth', 'my-token');
*
*     const response = await next(input, { ...init, headers });
*
*     if (response.status === 401) {
*         console.log('Authentication failed');
*     }
*
*     return response;
* });
*
* // Create conditional middleware
* const conditionalMiddleware = createMiddleware(async (next, input, init) => {
*     const url = typeof input === 'string' ? input : input.toString();
*
*     // Only add headers for API routes
*     if (url.includes('/api/')) {
*         const headers = new Headers(init?.headers);
*         headers.set('X-API-Version', 'v2');
*         return next(input, { ...init, headers });
*     }
*
*     // Pass through for non-API routes
*     return next(input, init);
* });
*
* // Create caching middleware
* const cacheMiddleware = createMiddleware(async (next, input, init) => {
*     const cacheKey = typeof input === 'string' ? input : input.toString();
*
*     // Check cache first
*     const cached = await getFromCache(cacheKey);
*     if (cached) {
*         return new Response(cached, { status: 200 });
*     }
*
*     // Make request and cache result
*     const response = await next(input, init);
*     if (response.ok) {
*         await saveToCache(cacheKey, await response.clone().text());
*     }
*
*     return response;
* });
* ```
*
* @param handler - Function that receives the next handler and request parameters
* @returns A fetch middleware function
*/
const createMiddleware = (handler) => {
	return (next) => (input, init) => handler(next, input, init);
};

//#endregion
//#region src/client/sse.ts
var SseError = class extends Error {
	static {
		Object.defineProperty(this, "mcpBrand", { value: "mcp.SseError" });
	}
	static [Symbol.hasInstance](value) {
		return require_src.brandedHasInstance(this, value);
	}
	/**
	* Brand-based type guard: equivalent to `value instanceof this`, as an
	* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
	* the caller's own brand via `this`, so every branded subclass gets a
	* correctly-scoped guard by inheritance. Must be invoked on the class —
	* in callback position write `v => SdkError.isInstance(v)`, not
	* `.filter(SdkError.isInstance)` (detached calls throw rather than
	* silently matching nothing).
	*/
	static isInstance(value) {
		if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
		return require_src.brandedHasInstance(this, value);
	}
	constructor(code, message, event) {
		super(`SSE error: ${message}`);
		this.code = code;
		this.event = event;
		require_src.stampErrorBrands(this, new.target);
	}
};
/**
* Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
* messages and make separate `POST` requests for sending messages.
* @deprecated SSEClientTransport is deprecated. Prefer to use {@linkcode index.StreamableHTTPClientTransport | StreamableHTTPClientTransport} where possible instead. Note that because some servers are still using SSE, clients may need to support both transports during the migration period.
*/
var SSEClientTransport = class {
	_eventSource;
	_endpoint;
	_abortController;
	_url;
	_resourceMetadataUrl;
	_scope;
	_eventSourceInit;
	_requestInit;
	_authProvider;
	_oauthProvider;
	_skipIssuerMetadataValidation;
	_fetch;
	_fetchWithInit;
	_redirectPolicy;
	_dpop;
	_protocolVersion;
	onclose;
	onerror;
	onmessage;
	constructor(url, opts) {
		this._url = url;
		this._resourceMetadataUrl = void 0;
		this._scope = void 0;
		this._eventSourceInit = opts?.eventSourceInit;
		this._requestInit = opts?.requestInit;
		this._skipIssuerMetadataValidation = opts?.skipIssuerMetadataValidation;
		this._fetch = opts?.fetch;
		if (isOAuthClientProvider(opts?.authProvider)) {
			this._oauthProvider = opts.authProvider;
			this._authProvider = adaptOAuthProvider(opts.authProvider, { skipIssuerMetadataValidation: opts.skipIssuerMetadataValidation });
			if (opts.authProvider.dpop) {
				this._dpop = withDpopFromProvider(opts.authProvider);
				this._fetch = this._dpop(opts.fetch ?? fetch);
			}
		} else this._authProvider = opts?.authProvider;
		this._redirectPolicy = opts?.redirectPolicy;
		this._fetchWithInit = require_src.createFetchWithInit(opts?.fetch, opts?.requestInit);
		if (this._redirectPolicy === "follow") this._fetchWithInit = require_src.fetchLeavingRedirects(this._fetchWithInit);
	}
	_last401Response;
	_connectAuthRetried = false;
	/** `baseFetch` with redirects handled as `redirectPolicy` says. */
	_redirects(baseFetch) {
		return this._redirectPolicy === "follow" ? baseFetch : require_src.fetchWithinOrigin(baseFetch);
	}
	/** Error text for a redirect `response` that was not followed, or `undefined` for any other response. */
	_unfollowedRedirect(url, response) {
		const text = this._redirectPolicy === "follow" ? void 0 : require_src.unfollowedRedirect(url, response);
		return text && `${text} (redirectPolicy: 'same-origin')`;
	}
	async _commonHeaders() {
		const headers = new Headers(this._requestInit?.headers || void 0);
		let token;
		try {
			token = await this._authProvider?.token();
		} catch (error) {
			throw markAuthSeamEscape(error);
		}
		if (token) headers.set("Authorization", `Bearer ${token}`);
		if (this._protocolVersion) headers.set("mcp-protocol-version", this._protocolVersion);
		return headers;
	}
	_startOrAuth() {
		const eventSourceFetch = this._eventSourceInit?.fetch;
		const fetchImpl = this._redirects(eventSourceFetch ? this._dpop?.(eventSourceFetch) ?? eventSourceFetch : this._fetch ?? fetch);
		let redirect;
		return new Promise((resolve, reject) => {
			this._eventSource = new eventsource.EventSource(this._url.href, {
				...this._eventSourceInit,
				fetch: async (url, init) => {
					const headers = await this._commonHeaders();
					headers.set("Accept", "text/event-stream");
					const response = await fetchImpl(url, {
						...init,
						headers
					});
					redirect = this._unfollowedRedirect(url, response);
					if (response.status === 401) {
						this._last401Response = response;
						if (response.headers.has("www-authenticate")) {
							const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
							this._resourceMetadataUrl = resourceMetadataUrl;
							this._scope = scope;
						}
					}
					return response;
				}
			});
			this._abortController = new AbortController();
			this._eventSource.onerror = (event) => {
				if (event.code === 401 && this._authProvider) {
					if (this._authProvider.onUnauthorized && this._last401Response && !this._connectAuthRetried) {
						const response = this._last401Response;
						this._last401Response = void 0;
						this._connectAuthRetried = true;
						this._eventSource?.close();
						this._authProvider.onUnauthorized({
							response,
							serverUrl: this._url,
							fetchFn: this._fetchWithInit
						}).then(() => this._startOrAuth().then(resolve, reject), (error$2) => {
							this._connectAuthRetried = false;
							markAuthSeamEscape(error$2);
							this.onerror?.(error$2);
							reject(error$2);
						});
						return;
					}
					const retried = this._connectAuthRetried;
					this._connectAuthRetried = false;
					const error$1 = markAuthSeamEscape(retried ? new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
						status: 401,
						statusText: this._last401Response?.statusText ?? ""
					}) : new UnauthorizedError());
					this._last401Response = void 0;
					reject(error$1);
					this.onerror?.(error$1);
					return;
				}
				this._connectAuthRetried = false;
				const error = new SseError(event.code, redirect ?? event.message, event);
				reject(error);
				this.onerror?.(error);
			};
			this._eventSource.onopen = () => {
				this._connectAuthRetried = false;
			};
			this._eventSource.addEventListener("endpoint", (event) => {
				const messageEvent = event;
				try {
					this._endpoint = new URL(messageEvent.data, this._url);
					if (this._endpoint.origin !== this._url.origin) throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
				} catch (error) {
					reject(error);
					this.onerror?.(error);
					this.close();
					return;
				}
				resolve();
			});
			this._eventSource.onmessage = (event) => {
				const messageEvent = event;
				let message;
				try {
					message = _modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
				} catch (error) {
					this.onerror?.(error);
					return;
				}
				this.onmessage?.(message);
			};
		});
	}
	async start() {
		if (this._eventSource) throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");
		return await this._startOrAuth();
	}
	async finishAuth(codeOrParams, iss) {
		if (!this._oauthProvider) throw new UnauthorizedError("finishAuth requires an OAuthClientProvider");
		const { authorizationCode, iss: issParam } = await resolveAuthorizationCallbackParams(codeOrParams, iss, this._oauthProvider, this._url, {
			fetchFn: this._fetchWithInit,
			resourceMetadataUrl: this._resourceMetadataUrl
		});
		if (await auth(this._oauthProvider, {
			serverUrl: this._url,
			authorizationCode,
			iss: issParam,
			resourceMetadataUrl: this._resourceMetadataUrl,
			scope: this._scope,
			fetchFn: this._fetchWithInit,
			skipIssuerMetadataValidation: this._skipIssuerMetadataValidation
		}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
	}
	async close() {
		this._abortController?.abort();
		this._eventSource?.close();
		this.onclose?.();
	}
	async send(message) {
		return this._send(message, false);
	}
	async _send(message, isAuthRetry) {
		if (!this._endpoint) throw new require_src.SdkError(require_src.SdkErrorCode.NotConnected, "Not connected");
		try {
			const headers = await this._commonHeaders();
			headers.set("content-type", "application/json");
			const init = {
				...this._requestInit,
				method: "POST",
				headers,
				body: JSON.stringify(message),
				signal: this._abortController?.signal
			};
			const response = await this._redirects(this._fetch ?? fetch)(this._endpoint, init);
			if (!response.ok) {
				if (response.status === 401 && this._authProvider) {
					if (response.headers.has("www-authenticate")) {
						const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
						this._resourceMetadataUrl = resourceMetadataUrl;
						this._scope = scope;
					}
					if (this._authProvider.onUnauthorized && !isAuthRetry) {
						try {
							await this._authProvider.onUnauthorized({
								response,
								serverUrl: this._url,
								fetchFn: this._fetchWithInit
							});
						} catch (error) {
							throw markAuthSeamEscape(error);
						}
						await response.text?.().catch(() => {});
						return this._send(message, true);
					}
					await response.text?.().catch(() => {});
					if (isAuthRetry) throw markAuthSeamEscape(new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
						status: 401,
						statusText: response.statusText
					}));
					throw markAuthSeamEscape(new UnauthorizedError());
				}
				const text = await response.text?.().catch(() => null);
				throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${this._unfollowedRedirect(this._endpoint, response) ?? text}`);
			}
			await response.text?.().catch(() => {});
		} catch (error) {
			this.onerror?.(error);
			throw error;
		}
	}
	setProtocolVersion(version) {
		this._protocolVersion = version;
	}
};

//#endregion
//#region src/client/streamableHttp.ts
/** Default cap on step-up re-authorization retries within a single send/stream-open. */
const DEFAULT_MAX_STEP_UP_RETRIES = 1;
const DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
	initialReconnectionDelay: 1e3,
	maxReconnectionDelay: 3e4,
	reconnectionDelayGrowFactor: 1.5,
	maxRetries: 2
};
/**
* Standard/auth header names the transport owns. The per-request
* `TransportSendOptions.headers` carrier MUST NOT be able to override these —
* they are derived from connection state (`authorization`, `mcp-session-id`)
* or from the message body itself (`mcp-protocol-version`, `mcp-method`,
* `mcp-name`), and a per-request override would let a caller produce a
* header/body disagreement the server's SEP-2243 cross-checks reject.
*/
const RESERVED_REQUEST_HEADER_NAMES = new Set([
	"authorization",
	"dpop",
	"content-type",
	"mcp-protocol-version",
	"mcp-method",
	"mcp-name",
	"mcp-session-id"
]);
/**
* `AbortSignal.any` with a manual fallback. `AbortSignal.any` landed in
* Node 20.3; this package's `engines` floor is `>=20`, so 20.0–20.2 must be
* served by the fallback combinator (a controller that aborts on the first
* of `a` or `b`). The native path is preferred because it propagates the
* originating signal's `reason` and participates in GC the way the spec
* defines.
*/
function anySignal(a, b) {
	if (typeof AbortSignal.any === "function") return AbortSignal.any([a, b]);
	const controller = new AbortController();
	if (a.aborted) return controller.abort(a.reason), controller.signal;
	if (b.aborted) return controller.abort(b.reason), controller.signal;
	const cleanup = () => {
		a.removeEventListener("abort", onA);
		b.removeEventListener("abort", onB);
	};
	function onA() {
		cleanup();
		controller.abort(a.reason);
	}
	function onB() {
		cleanup();
		controller.abort(b.reason);
	}
	a.addEventListener("abort", onA, { once: true });
	b.addEventListener("abort", onB, { once: true });
	return controller.signal;
}
/**
* Client transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
* It will connect to a server using HTTP `POST` for sending messages and HTTP `GET` with Server-Sent Events
* for receiving messages.
*/
var StreamableHTTPClientTransport = class {
	_abortController;
	_url;
	_resourceMetadataUrl;
	_scope;
	_requestInit;
	_authProvider;
	_oauthProvider;
	_skipIssuerMetadataValidation;
	_fetch;
	_fetchWithInit;
	_redirectPolicy;
	_sessionId;
	_reconnectionOptions;
	_protocolVersion;
	_onInsufficientScope;
	_maxStepUpRetries;
	_serverRetryMs;
	_reconnectionScheduler;
	_cancelReconnection;
	onclose;
	onerror;
	onmessage;
	/**
	* Streamable HTTP opens one POST (and SSE response stream) per outbound
	* request and honors `TransportSendOptions.requestSignal`. On a 2026-era
	* connection the protocol layer aborts that per-request stream as the
	* spec cancellation signal instead of POSTing `notifications/cancelled`.
	*/
	hasPerRequestStream = true;
	constructor(url, opts) {
		this._url = url;
		this._resourceMetadataUrl = void 0;
		this._scope = void 0;
		this._requestInit = opts?.requestInit;
		this._skipIssuerMetadataValidation = opts?.skipIssuerMetadataValidation;
		this._fetch = opts?.fetch;
		if (isOAuthClientProvider(opts?.authProvider)) {
			this._oauthProvider = opts.authProvider;
			this._authProvider = adaptOAuthProvider(opts.authProvider, { skipIssuerMetadataValidation: opts.skipIssuerMetadataValidation });
			if (opts.authProvider.dpop) this._fetch = withDpopFromProvider(opts.authProvider)(opts.fetch ?? fetch);
		} else this._authProvider = opts?.authProvider;
		this._redirectPolicy = opts?.redirectPolicy;
		this._fetchWithInit = require_src.createFetchWithInit(opts?.fetch, opts?.requestInit);
		if (this._redirectPolicy === "follow") this._fetchWithInit = require_src.fetchLeavingRedirects(this._fetchWithInit);
		this._sessionId = opts?.sessionId;
		this._protocolVersion = opts?.protocolVersion;
		this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
		this._reconnectionScheduler = opts?.reconnectionScheduler;
		this._onInsufficientScope = opts?.onInsufficientScope ?? "reauthorize";
		this._maxStepUpRetries = Math.max(0, opts?.maxStepUpRetries ?? DEFAULT_MAX_STEP_UP_RETRIES);
	}
	/**
	* SEP-2350 step-up: compute the union scope, decide whether refresh must be
	* bypassed, and run {@linkcode auth}. Returns the auth result so the caller
	* can decide whether to retry. Shared by the POST `_send` path and the GET
	* `_startOrAuthSse` path so both apply the same `'throw'` short-circuit,
	* the same superset-gated refresh bypass, and the same retry cap.
	*/
	async _stepUpAuthorize(challenge, stepUpRetries) {
		try {
			return await this._stepUpAuthorizeInner(challenge, stepUpRetries);
		} catch (error) {
			throw markAuthSeamEscape(error);
		}
	}
	async _stepUpAuthorizeInner(challenge, stepUpRetries) {
		if (this._onInsufficientScope === "throw") throw new InsufficientScopeError({
			requiredScope: challenge.scope,
			resourceMetadataUrl: challenge.resourceMetadataUrl,
			errorDescription: challenge.errorDescription
		});
		if (!this._oauthProvider) throw new InsufficientScopeError({
			requiredScope: challenge.scope,
			resourceMetadataUrl: challenge.resourceMetadataUrl,
			errorDescription: challenge.errorDescription
		});
		if (stepUpRetries >= this._maxStepUpRetries) throw new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpForbidden, `Server returned 403 insufficient_scope after step-up re-authorization (retry limit ${this._maxStepUpRetries} reached)`, {
			status: 403,
			statusText: challenge.statusText ?? "Forbidden",
			text: challenge.text
		});
		if (challenge.resourceMetadataUrl) this._resourceMetadataUrl = challenge.resourceMetadataUrl;
		const tokens = await this._oauthProvider.tokens();
		const unionScope = computeScopeUnion(this._scope, tokens?.scope, challenge.scope);
		this._scope = unionScope;
		const forceReauthorization = isStrictScopeSuperset(unionScope, tokens?.scope);
		return auth(this._oauthProvider, {
			serverUrl: this._url,
			resourceMetadataUrl: this._resourceMetadataUrl,
			scope: unionScope,
			forceReauthorization,
			fetchFn: this._fetchWithInit,
			skipIssuerMetadataValidation: this._skipIssuerMetadataValidation
		});
	}
	/** `baseFetch` with redirects handled as `redirectPolicy` says. */
	_redirects(baseFetch) {
		return this._redirectPolicy === "follow" ? baseFetch : require_src.fetchWithinOrigin(baseFetch);
	}
	/** Error text for a redirect `response` that was not followed, or `undefined` for any other response. */
	_unfollowedRedirect(url, response) {
		const text = this._redirectPolicy === "follow" ? void 0 : require_src.unfollowedRedirect(url, response);
		return text && `${text} (redirectPolicy: 'same-origin')`;
	}
	async _commonHeaders() {
		const headers = new Headers(this._requestInit?.headers || void 0);
		let token;
		try {
			token = await this._authProvider?.token();
		} catch (error) {
			throw markAuthSeamEscape(error);
		}
		if (token) headers.set("Authorization", `Bearer ${token}`);
		if (this._sessionId) headers.set("mcp-session-id", this._sessionId);
		if (this._protocolVersion) headers.set("mcp-protocol-version", this._protocolVersion);
		return headers;
	}
	/**
	* Body-derived per-request headers: when an outgoing request carries a
	* protocol-version claim in its `_meta` envelope (the version negotiation
	* probe is the first such sender), `MCP-Protocol-Version` and `Mcp-Method`
	* derive from the message itself. The connection-level version slot is
	* neither consulted nor mutated; messages without an envelope claim are
	* untouched, so no 2026 header can appear on a legacy exchange.
	*/
	_applyBodyDerivedHeaders(headers, message) {
		if (Array.isArray(message) || !require_src.isJSONRPCRequest(message)) return;
		const envelopeVersion = (message.params?._meta)?.[_modelcontextprotocol_core_internal.PROTOCOL_VERSION_META_KEY];
		if (typeof envelopeVersion !== "string") return;
		headers.set("mcp-protocol-version", envelopeVersion);
		headers.set("mcp-method", message.method);
		const source = require_src.mcpNameSource(message.method, message.params);
		if (source?.value !== void 0) headers.set("mcp-name", require_src.encodeMcpParamValue(source.value));
	}
	/**
	* `true` when the outbound message is a single request carrying a
	* modern-era protocol-version envelope claim — the same predicate that
	* gates body-derived `mcp-method`/`mcp-name` emission. Used to confine the
	* 400-body-as-ProtocolError delivery to modern-era exchanges only.
	*/
	_isModernEnvelopedRequest(message) {
		if (Array.isArray(message) || !require_src.isJSONRPCRequest(message)) return false;
		const v = (message.params?._meta)?.[_modelcontextprotocol_core_internal.PROTOCOL_VERSION_META_KEY];
		return typeof v === "string" && require_src.isModernProtocolVersion(v);
	}
	async _startOrAuthSse(options, isAuthRetry = false, stepUpRetries = 0) {
		const { resumptionToken, requestSignal } = options;
		const isIntentionalAbort = () => this._abortController?.signal.aborted === true || requestSignal?.aborted === true;
		try {
			const headers = await this._commonHeaders();
			const types = [...headers.get("accept")?.split(",").map((s) => s.trim().toLowerCase()) ?? [], "text/event-stream"];
			headers.set("accept", [...new Set(types)].join(", "));
			if (resumptionToken) headers.set("last-event-id", resumptionToken);
			const transportSignal = this._abortController?.signal;
			const signal = requestSignal !== void 0 && transportSignal !== void 0 ? anySignal(transportSignal, requestSignal) : requestSignal ?? transportSignal;
			const response = await this._redirects(this._fetch ?? fetch)(this._url, {
				...this._requestInit,
				method: "GET",
				headers,
				signal
			});
			if (!response.ok) {
				if (response.status === 401 && this._authProvider) {
					if (response.headers.has("www-authenticate")) {
						const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
						this._resourceMetadataUrl = resourceMetadataUrl;
						this._scope = computeScopeUnion(this._scope, scope);
					}
					if (this._authProvider.onUnauthorized && !isAuthRetry) {
						try {
							await this._authProvider.onUnauthorized({
								response,
								serverUrl: this._url,
								fetchFn: this._fetchWithInit
							});
						} catch (error) {
							throw markAuthSeamEscape(error);
						}
						await response.text?.().catch(() => {});
						return this._startOrAuthSse(options, true, stepUpRetries);
					}
					await response.text?.().catch(() => {});
					if (isAuthRetry) throw markAuthSeamEscape(new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
						status: 401,
						statusText: response.statusText
					}));
					throw markAuthSeamEscape(new UnauthorizedError());
				}
				if (response.status === 403) {
					const { resourceMetadataUrl, scope, error, errorDescription } = extractWWWAuthenticateParams(response);
					if (error === "insufficient_scope") {
						const text = await response.text?.().catch(() => null);
						if (await this._stepUpAuthorize({
							scope,
							resourceMetadataUrl,
							errorDescription,
							statusText: response.statusText,
							text
						}, stepUpRetries) !== "AUTHORIZED") throw markAuthSeamEscape(new UnauthorizedError());
						return this._startOrAuthSse(options, isAuthRetry, stepUpRetries + 1);
					}
				}
				await response.text?.().catch(() => {});
				if (response.status === 405) {
					options.onRequestStreamEnd?.();
					return;
				}
				const reason = this._unfollowedRedirect(this._url, response) ?? response.statusText;
				throw new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpFailedToOpenStream, `Failed to open SSE stream: ${reason}`, {
					status: response.status,
					statusText: response.statusText
				});
			}
			this._handleSseStream(response.body, options, true);
		} catch (error) {
			if (!isIntentionalAbort()) this.onerror?.(error);
			throw error;
		}
	}
	/**
	* Calculates the next reconnection delay using a backoff algorithm
	*
	* @param attempt Current reconnection attempt count for the specific stream
	* @returns Time to wait in milliseconds before next reconnection attempt
	*/
	_getNextReconnectionDelay(attempt) {
		if (this._serverRetryMs !== void 0) return this._serverRetryMs;
		const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
		const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
		const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
		return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
	}
	/**
	* Schedule a reconnection attempt using server-provided retry interval or backoff
	*
	* @param lastEventId The ID of the last received event for resumability
	* @param attemptCount Current reconnection attempt count for this specific stream
	*/
	_scheduleReconnection(options, attemptCount = 0) {
		const maxRetries = this._reconnectionOptions.maxRetries;
		if (attemptCount >= maxRetries) {
			this.onerror?.(/* @__PURE__ */ new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
			options.onRequestStreamEnd?.();
			return;
		}
		const delay = this._getNextReconnectionDelay(attemptCount);
		const reconnect = () => {
			this._cancelReconnection = void 0;
			if (this._abortController?.signal.aborted || options.requestSignal?.aborted) return;
			this._startOrAuthSse(options).catch((error) => {
				if (this._abortController?.signal.aborted || options.requestSignal?.aborted) return;
				this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
				try {
					this._scheduleReconnection(options, attemptCount + 1);
				} catch (scheduleError) {
					this.onerror?.(scheduleError instanceof Error ? scheduleError : new Error(String(scheduleError)));
				}
			});
		};
		if (this._reconnectionScheduler) {
			const cancel = this._reconnectionScheduler(reconnect, delay, attemptCount);
			this._cancelReconnection = typeof cancel === "function" ? cancel : void 0;
		} else {
			const handle = setTimeout(reconnect, delay);
			this._cancelReconnection = () => clearTimeout(handle);
		}
	}
	_handleSseStream(stream, options, isReconnectable) {
		if (!stream) {
			options.onRequestStreamEnd?.();
			return;
		}
		const { onresumptiontoken, replayMessageId, requestSignal, onRequestStreamEnd } = options;
		const isIntentionalAbort = () => this._abortController?.signal.aborted === true || requestSignal?.aborted === true;
		let lastEventId;
		let hasPrimingEvent = false;
		let receivedResponse = false;
		const processStream = async () => {
			try {
				const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new eventsource_parser_stream.EventSourceParserStream({ onRetry: (retryMs) => {
					this._serverRetryMs = retryMs;
				} })).getReader();
				while (true) {
					const { value: event, done } = await reader.read();
					if (done) break;
					if (event.id) {
						lastEventId = event.id;
						hasPrimingEvent = true;
						onresumptiontoken?.(event.id);
					}
					if (!event.data) continue;
					if (!event.event || event.event === "message") try {
						const message = _modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(JSON.parse(event.data));
						if (require_src.isJSONRPCResultResponse(message) || require_src.isJSONRPCErrorResponse(message)) {
							receivedResponse = true;
							if (replayMessageId !== void 0) message.id = replayMessageId;
						}
						this.onmessage?.(message);
					} catch (error) {
						this.onerror?.(error);
					}
				}
				if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !isIntentionalAbort()) this._scheduleReconnection({
					resumptionToken: lastEventId,
					onresumptiontoken,
					replayMessageId,
					requestSignal,
					onRequestStreamEnd
				}, 0);
				else if (!isIntentionalAbort()) onRequestStreamEnd?.();
			} catch (error) {
				if (isIntentionalAbort()) return;
				this.onerror?.(/* @__PURE__ */ new Error(`SSE stream disconnected: ${error}`));
				if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !isIntentionalAbort()) try {
					this._scheduleReconnection({
						resumptionToken: lastEventId,
						onresumptiontoken,
						replayMessageId,
						requestSignal,
						onRequestStreamEnd
					}, 0);
				} catch (error$1) {
					this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect: ${error$1 instanceof Error ? error$1.message : String(error$1)}`));
					onRequestStreamEnd?.();
				}
				else onRequestStreamEnd?.();
			}
		};
		processStream();
	}
	async start() {
		if (this._abortController) throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
		this._abortController = new AbortController();
	}
	async finishAuth(codeOrParams, iss) {
		if (!this._oauthProvider) throw new UnauthorizedError("finishAuth requires an OAuthClientProvider");
		const { authorizationCode, iss: issParam } = await resolveAuthorizationCallbackParams(codeOrParams, iss, this._oauthProvider, this._url, {
			fetchFn: this._fetchWithInit,
			resourceMetadataUrl: this._resourceMetadataUrl
		});
		if (await auth(this._oauthProvider, {
			serverUrl: this._url,
			authorizationCode,
			iss: issParam,
			resourceMetadataUrl: this._resourceMetadataUrl,
			scope: this._scope,
			fetchFn: this._fetchWithInit,
			skipIssuerMetadataValidation: this._skipIssuerMetadataValidation
		}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
	}
	async close() {
		try {
			this._cancelReconnection?.();
		} finally {
			this._cancelReconnection = void 0;
			this._abortController?.abort();
			this.onclose?.();
		}
	}
	async send(message, options) {
		return this._send(message, options, false);
	}
	async _send(message, options, isAuthRetry, stepUpRetries = 0) {
		try {
			const { resumptionToken, onresumptiontoken } = options || {};
			if (resumptionToken) {
				this._startOrAuthSse({
					resumptionToken,
					replayMessageId: require_src.isJSONRPCRequest(message) ? message.id : void 0,
					requestSignal: options?.requestSignal
				}).catch((error) => this.onerror?.(error));
				return;
			}
			const headers = await this._commonHeaders();
			this._applyBodyDerivedHeaders(headers, message);
			const isHandshake = Array.isArray(message) ? message.some((m) => require_src.isInitializeRequest(m)) : require_src.isInitializeRequest(message);
			if (isHandshake) headers.delete("mcp-session-id");
			if (options?.headers !== void 0) for (const [name, value] of Object.entries(options.headers)) {
				if (RESERVED_REQUEST_HEADER_NAMES.has(name.toLowerCase())) continue;
				headers.set(name, value);
			}
			headers.set("content-type", "application/json");
			const types = [
				...headers.get("accept")?.split(",").map((s) => s.trim().toLowerCase()) ?? [],
				"application/json",
				"text/event-stream"
			];
			headers.set("accept", [...new Set(types)].join(", "));
			const transportSignal = this._abortController?.signal;
			const signal = options?.requestSignal !== void 0 && transportSignal !== void 0 ? anySignal(transportSignal, options.requestSignal) : options?.requestSignal ?? transportSignal;
			const init = {
				...this._requestInit,
				method: "POST",
				headers,
				body: JSON.stringify(message),
				signal
			};
			const response = await this._redirects(this._fetch ?? fetch)(this._url, init);
			if (isHandshake && response.ok) this._sessionId = response.headers.get("mcp-session-id") || void 0;
			if (!response.ok) {
				if (response.status === 401 && this._authProvider) {
					if (response.headers.has("www-authenticate")) {
						const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
						this._resourceMetadataUrl = resourceMetadataUrl;
						this._scope = computeScopeUnion(this._scope, scope);
					}
					if (this._authProvider.onUnauthorized && !isAuthRetry) {
						try {
							await this._authProvider.onUnauthorized({
								response,
								serverUrl: this._url,
								fetchFn: this._fetchWithInit
							});
						} catch (error) {
							throw markAuthSeamEscape(error);
						}
						await response.text?.().catch(() => {});
						return this._send(message, options, true, stepUpRetries);
					}
					await response.text?.().catch(() => {});
					if (isAuthRetry) throw markAuthSeamEscape(new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
						status: 401,
						statusText: response.statusText
					}));
					throw markAuthSeamEscape(new UnauthorizedError());
				}
				const text = await response.text?.().catch(() => null);
				if (response.status === 403) {
					const { resourceMetadataUrl, scope, error, errorDescription } = extractWWWAuthenticateParams(response);
					if (error === "insufficient_scope") {
						if (await this._stepUpAuthorize({
							scope,
							resourceMetadataUrl,
							errorDescription,
							statusText: response.statusText,
							text
						}, stepUpRetries) !== "AUTHORIZED") throw markAuthSeamEscape(new UnauthorizedError());
						return this._send(message, options, isAuthRetry, stepUpRetries + 1);
					}
				}
				if (response.status === 400 && typeof text === "string" && this._isModernEnvelopedRequest(message)) try {
					const parsed = _modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(JSON.parse(text));
					const requests = (Array.isArray(message) ? message : [message]).filter((m) => require_src.isJSONRPCRequest(m));
					if (require_src.isJSONRPCErrorResponse(parsed) && requests.some((r) => r.id === parsed.id)) {
						this.onmessage?.(parsed);
						return;
					}
				} catch {}
				const reason = this._unfollowedRedirect(this._url, response) ?? text;
				throw new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpNotImplemented, `Error POSTing to endpoint: ${reason}`, {
					status: response.status,
					statusText: response.statusText,
					text
				});
			}
			if (response.status === 202) {
				await response.text?.().catch(() => {});
				if (require_src.isInitializedNotification(message)) this._startOrAuthSse({ resumptionToken: void 0 }).catch((error) => this.onerror?.(error));
				return;
			}
			const hasRequests = (Array.isArray(message) ? message : [message]).some((msg) => "method" in msg && "id" in msg && msg.id !== void 0);
			const contentType = response.headers.get("content-type");
			const responseMediaType = require_src.mediaTypeEssence(contentType);
			if (hasRequests) if (responseMediaType === "text/event-stream") this._handleSseStream(response.body, {
				onresumptiontoken,
				requestSignal: options?.requestSignal,
				onRequestStreamEnd: options?.onRequestStreamEnd
			}, false);
			else if (responseMediaType === "application/json") {
				const data = await response.json();
				const responseMessages = Array.isArray(data) ? data.map((msg) => _modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(msg)) : [_modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(data)];
				for (const msg of responseMessages) this.onmessage?.(msg);
			} else {
				await response.text?.().catch(() => {});
				throw new require_src.SdkError(require_src.SdkErrorCode.ClientHttpUnexpectedContent, `Unexpected content type: ${contentType}`, { contentType });
			}
			else await response.text?.().catch(() => {});
		} catch (error) {
			if (options?.requestSignal?.aborted !== true) this.onerror?.(error);
			throw error;
		}
	}
	get sessionId() {
		return this._sessionId;
	}
	/**
	* Terminates the current session by sending a `DELETE` request to the server.
	*
	* Clients that no longer need a particular session
	* (e.g., because the user is leaving the client application) SHOULD send an
	* HTTP `DELETE` to the MCP endpoint with the `Mcp-Session-Id` header to explicitly
	* terminate the session.
	*
	* The server MAY respond with HTTP `405 Method Not Allowed`, indicating that
	* the server does not allow clients to terminate sessions.
	*/
	async terminateSession() {
		if (!this._sessionId) return;
		try {
			const headers = await this._commonHeaders();
			const init = {
				...this._requestInit,
				method: "DELETE",
				headers,
				signal: this._abortController?.signal
			};
			const response = await this._redirects(this._fetch ?? fetch)(this._url, init);
			await response.text?.().catch(() => {});
			if (!response.ok && response.status !== 405) throw new require_src.SdkHttpError(require_src.SdkErrorCode.ClientHttpFailedToTerminateSession, `Failed to terminate session: ${this._unfollowedRedirect(this._url, response) ?? response.statusText}`, {
				status: response.status,
				statusText: response.statusText
			});
			this._sessionId = void 0;
		} catch (error) {
			this.onerror?.(error);
			throw error;
		}
	}
	setProtocolVersion(version) {
		this._protocolVersion = version;
	}
	get protocolVersion() {
		return this._protocolVersion;
	}
	/**
	* Resume an SSE stream from a previous event ID.
	* Opens a `GET` SSE connection with `Last-Event-ID` header to replay missed events.
	*
	* @param lastEventId The event ID to resume from
	* @param options Optional callback to receive new resumption tokens
	*/
	async resumeStream(lastEventId, options) {
		await this._startOrAuthSse({
			resumptionToken: lastEventId,
			onresumptiontoken: options?.onresumptiontoken
		});
	}
};

//#endregion
//#region src/fromJsonSchema.ts
let _defaultValidator;
function fromJsonSchema(schema, validator) {
	return require_src.fromJsonSchema(schema, validator ?? (_defaultValidator ??= new _modelcontextprotocol_client__shims.DefaultJsonSchemaValidator()));
}

//#endregion
exports.AuthorizationServerMismatchError = AuthorizationServerMismatchError;
Object.defineProperty(exports, 'BAGGAGE_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.BAGGAGE_META_KEY;
  }
});
Object.defineProperty(exports, 'CLIENT_CAPABILITIES_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.CLIENT_CAPABILITIES_META_KEY;
  }
});
Object.defineProperty(exports, 'CLIENT_INFO_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.CLIENT_INFO_META_KEY;
  }
});
exports.Client = Client;
exports.ClientCredentialsProvider = ClientCredentialsProvider;
exports.CrossAppAccessProvider = CrossAppAccessProvider;
Object.defineProperty(exports, 'DEFAULT_NEGOTIATED_PROTOCOL_VERSION', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
  }
});
exports.DEFAULT_REQUEST_TIMEOUT_MSEC = require_src.DEFAULT_REQUEST_TIMEOUT_MSEC;
exports.DPOP_SUPPORTED_ALGS = DPOP_SUPPORTED_ALGS;
exports.DpopSession = DpopSession;
Object.defineProperty(exports, 'INTERNAL_ERROR', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.INTERNAL_ERROR;
  }
});
Object.defineProperty(exports, 'INVALID_PARAMS', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.INVALID_PARAMS;
  }
});
Object.defineProperty(exports, 'INVALID_REQUEST', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.INVALID_REQUEST;
  }
});
exports.InMemoryResponseCacheStore = InMemoryResponseCacheStore;
exports.InMemoryTransport = require_src.InMemoryTransport;
exports.InsecureTokenEndpointError = InsecureTokenEndpointError;
exports.InsufficientScopeError = InsufficientScopeError;
exports.IssuerMismatchError = IssuerMismatchError;
Object.defineProperty(exports, 'JSONRPC_VERSION', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.JSONRPC_VERSION;
  }
});
Object.defineProperty(exports, 'LATEST_PROTOCOL_VERSION', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.LATEST_PROTOCOL_VERSION;
  }
});
Object.defineProperty(exports, 'LOG_LEVEL_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.LOG_LEVEL_META_KEY;
  }
});
exports.MAX_CACHE_TTL_MS = MAX_CACHE_TTL_MS;
Object.defineProperty(exports, 'METHOD_NOT_FOUND', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.METHOD_NOT_FOUND;
  }
});
exports.MissingRequiredClientCapabilityError = require_src.MissingRequiredClientCapabilityError;
exports.OAuthClientFlowError = OAuthClientFlowError;
exports.OAuthError = require_src.OAuthError;
exports.OAuthErrorCode = require_src.OAuthErrorCode;
Object.defineProperty(exports, 'PARSE_ERROR', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.PARSE_ERROR;
  }
});
Object.defineProperty(exports, 'PROTOCOL_VERSION_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.PROTOCOL_VERSION_META_KEY;
  }
});
exports.PrivateKeyJwtProvider = PrivateKeyJwtProvider;
exports.Protocol = require_src.Protocol;
exports.ProtocolError = require_src.ProtocolError;
exports.ProtocolErrorCode = require_src.ProtocolErrorCode;
Object.defineProperty(exports, 'RELATED_TASK_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.RELATED_TASK_META_KEY;
  }
});
exports.ReadBuffer = require_src.ReadBuffer;
exports.RegistrationRejectedError = RegistrationRejectedError;
exports.ResourceNotFoundError = require_src.ResourceNotFoundError;
Object.defineProperty(exports, 'SERVER_INFO_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.SERVER_INFO_META_KEY;
  }
});
exports.SSEClientTransport = SSEClientTransport;
exports.STDIO_DEFAULT_MAX_BUFFER_SIZE = require_src.STDIO_DEFAULT_MAX_BUFFER_SIZE;
Object.defineProperty(exports, 'SUBSCRIPTION_ID_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.SUBSCRIPTION_ID_META_KEY;
  }
});
Object.defineProperty(exports, 'SUPPORTED_PROTOCOL_VERSIONS', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.SUPPORTED_PROTOCOL_VERSIONS;
  }
});
exports.SdkError = require_src.SdkError;
exports.SdkErrorCode = require_src.SdkErrorCode;
exports.SdkHttpError = require_src.SdkHttpError;
exports.SseError = SseError;
exports.StaticPrivateKeyJwtProvider = StaticPrivateKeyJwtProvider;
exports.StreamableHTTPClientTransport = StreamableHTTPClientTransport;
Object.defineProperty(exports, 'TRACEPARENT_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.TRACEPARENT_META_KEY;
  }
});
Object.defineProperty(exports, 'TRACESTATE_META_KEY', {
  enumerable: true,
  get: function () {
    return _modelcontextprotocol_core_internal.TRACESTATE_META_KEY;
  }
});
exports.UnauthorizedError = UnauthorizedError;
exports.UnsupportedProtocolVersionError = require_src.UnsupportedProtocolVersionError;
exports.UriTemplate = require_src.UriTemplate;
exports.UrlElicitationRequiredError = require_src.UrlElicitationRequiredError;
exports.accessTokenHash = accessTokenHash;
exports.applyMiddlewares = applyMiddlewares;
exports.assertCompleteRequestPrompt = require_src.assertCompleteRequestPrompt;
exports.assertCompleteRequestResourceTemplate = require_src.assertCompleteRequestResourceTemplate;
exports.assertSecureTokenEndpoint = assertSecureTokenEndpoint;
exports.auth = auth;
exports.buildDiscoveryUrls = buildDiscoveryUrls;
exports.checkResourceAllowed = require_src.checkResourceAllowed;
exports.computeScopeUnion = computeScopeUnion;
exports.createFetchWithInit = require_src.createFetchWithInit;
exports.createMiddleware = createMiddleware;
exports.createPrivateKeyJwtAuth = createPrivateKeyJwtAuth;
exports.deserializeMessage = require_src.deserializeMessage;
exports.discoverAndRequestJwtAuthGrant = discoverAndRequestJwtAuthGrant;
exports.discoverAuthorizationServerMetadata = discoverAuthorizationServerMetadata;
exports.discoverOAuthMetadata = discoverOAuthMetadata;
exports.discoverOAuthProtectedResourceMetadata = discoverOAuthProtectedResourceMetadata;
exports.discoverOAuthServerInfo = discoverOAuthServerInfo;
exports.exchangeAuthorization = exchangeAuthorization;
exports.exchangeJwtAuthGrant = exchangeJwtAuthGrant;
exports.extractResourceMetadataUrl = extractResourceMetadataUrl;
exports.extractWWWAuthenticateParams = extractWWWAuthenticateParams;
exports.fetchToken = fetchToken;
exports.fromJsonSchema = fromJsonSchema;
exports.generateDpopKeyPair = generateDpopKeyPair;
exports.getDisplayName = require_src.getDisplayName;
exports.getSupportedElicitationModes = getSupportedElicitationModes;
exports.isCallToolResult = require_src.isCallToolResult;
exports.isDpopNonceChallenge = isDpopNonceChallenge;
exports.isHttpsUrl = isHttpsUrl;
exports.isInitializeRequest = require_src.isInitializeRequest;
exports.isInitializedNotification = require_src.isInitializedNotification;
exports.isInputRequiredResult = require_src.isInputRequiredResult;
exports.isJSONRPCErrorResponse = require_src.isJSONRPCErrorResponse;
exports.isJSONRPCNotification = require_src.isJSONRPCNotification;
exports.isJSONRPCRequest = require_src.isJSONRPCRequest;
exports.isJSONRPCResponse = require_src.isJSONRPCResponse;
exports.isJSONRPCResultResponse = require_src.isJSONRPCResultResponse;
exports.isJsonContentType = require_src.isJsonContentType;
exports.isSpecType = require_src.isSpecType;
exports.isStrictScopeSuperset = isStrictScopeSuperset;
exports.isTaskAugmentedRequestParams = require_src.isTaskAugmentedRequestParams;
exports.mergeCapabilities = require_src.mergeCapabilities;
exports.parseErrorResponse = parseErrorResponse;
exports.parseJSONRPCMessage = require_src.parseJSONRPCMessage;
exports.preloadSchemas = require_src.preloadSchemas;
exports.prepareAuthorizationCodeRequest = prepareAuthorizationCodeRequest;
exports.refreshAuthorization = refreshAuthorization;
exports.registerClient = registerClient;
exports.requestJwtAuthorizationGrant = requestJwtAuthorizationGrant;
exports.resolveClientMetadata = resolveClientMetadata;
exports.resourceUrlFromServerUrl = require_src.resourceUrlFromServerUrl;
exports.selectClientAuthMethod = selectClientAuthMethod;
exports.selectResourceURL = selectResourceURL;
exports.serializeMessage = require_src.serializeMessage;
exports.specTypeSchemas = require_src.specTypeSchemas;
exports.startAuthorization = startAuthorization;
exports.validateAuthorizationResponseIssuer = validateAuthorizationResponseIssuer;
exports.validateClientMetadataUrl = validateClientMetadataUrl;
exports.withDpop = withDpop;
exports.withDpopFromProvider = withDpopFromProvider;
exports.withInputRequired = require_src.withInputRequired;
exports.withLogging = withLogging;
exports.withOAuth = withOAuth;
//# sourceMappingURL=index.cjs.map