@openrouter/agent 0.9.0 → 0.11.0

package/esm/mcp/mcp-connection.d.ts

@@ -0,0 +1,150 @@
+import type { Client } from '@modelcontextprotocol/client';
+import type { MCPAuth } from './auth/auth-types.js';
+import type { MCPSdk } from './mcp-sdk.js';
+import type { MCPProtocolNegotiation, MCPTransportKind } from './transport-types.js';
+import type { ElicitationHandler } from './types.js';
+export interface ConnectOptions {
+    url: URL;
+    transport?: MCPTransportKind;
+    auth?: MCPAuth;
+    fetch?: typeof fetch;
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+    /**
+     * Streamable HTTP session id to resume.
+     *
+     * @deprecated Ignored by 2026-07-28 servers — protocol-level sessions are
+     * removed (SEP-2567). Still honoured on 2025-era connections.
+     */
+    sessionId?: string;
+    onElicitation?: ElicitationHandler;
+    protocolNegotiation?: MCPProtocolNegotiation;
+    /**
+     * Aborts the connect — every transport attempt, the negotiation probe, and
+     * the implicit legacy retry. Without this a caller with its own deadline has
+     * no way to bound the ladder, whose worst case is minutes (see
+     * {@link DEFAULT_PROBE_TIMEOUT_MS}).
+     */
+    signal?: AbortSignal;
+    /**
+     * Ceiling on the `server/discover` probe, in ms. Defaults to
+     * `DEFAULT_PROBE_TIMEOUT_MS` (30000).
+     *
+     * Raise it for a server that is slow to answer its first request; the SDK's own
+     * default is the full request timeout, which makes a hanging gateway far slower
+     * to fail than it needs to be.
+     */
+    probeTimeoutMs?: number;
+}
+export interface MCPConnection {
+    client: Client;
+    transport: MCPTransportKind;
+    /**
+     * Session id reported by the transport, when there is one.
+     *
+     * @deprecated `undefined` on 2026-07-28 connections (SEP-2567) and on SSE,
+     * which never had a protocol-level session.
+     */
+    sessionId?: string;
+    /**
+     * Register a callback for `tools/list_changed`. Settable after connect so the
+     * handle can wire it to its own `refresh()`. Replaces any prior handler.
+     */
+    setToolListChangedHandler(handler: () => void): void;
+    close(): Promise<void>;
+}
+/**
+ * Build the configured `Client` — negotiation mode, elicitation handler, and the
+ * `tools/list_changed` subscription — without connecting it.
+ *
+ * Exported for tests only, and deliberately not re-exported from the package
+ * entrypoint. It is the seam that lets a test drive the real handler wiring over
+ * `InMemoryTransport`: the notification method name is compile-checked (it is a
+ * `NotificationMethod` literal union, so a typo fails `tsc`), but the *dispatch*
+ * — that an inbound notification actually reaches `setToolListChangedHandler`'s
+ * callback — is only observable end to end. Without this seam, default-on
+ * `autoRefreshOnListChanged` could be silently dead with every test green.
+ *
+ * @internal
+ */
+export declare function makeClientForTest(options: ConnectOptions, onListChanged: () => void): Promise<Client>;
+/**
+ * Did any attempt behind this failure end in the server rejecting our
+ * credentials?
+ *
+ * Searches the whole tree rather than the `cause` spine, because a single
+ * `connect()` can fail more than once: `connectWithNegotiation` wraps transport
+ * errors in `MCPConnectionError`, and on the two-transport path it records both
+ * attempts in `errors`. Checking only `cause` would miss an `UnauthorizedError`
+ * from the Streamable HTTP attempt whenever the SSE fallback then failed for an
+ * unrelated reason — a URL that isn't an SSE endpoint answering 404 never
+ * reaches the auth path — and the retry would re-drive the OAuth flow anyway.
+ *
+ * Depth-capped: a cyclic `cause` would otherwise hang, and real chains here are
+ * two or three links.
+ *
+ * Exported for `rehydrateMCPTools`, whose fallback-to-`freshConnect` is a third
+ * reconnect layer with the same duplicated-OAuth hazard; deliberately not
+ * re-exported from the package entrypoint.
+ */
+interface AuthFailureArgs {
+    err: unknown;
+    auth: MCPAuth | undefined;
+    UnauthorizedErrorType: MCPSdk['UnauthorizedError'] | undefined;
+    depth?: number;
+}
+export declare function isAuthFailure({ err, auth, UnauthorizedErrorType, depth, }: AuthFailureArgs): boolean;
+/**
+ * Connect a `Client` to the MCP server, degrading to the 2025-era handshake if
+ * protocol negotiation gets in the way.
+ *
+ * We default `protocolNegotiation` to `'auto'` where the SDK defaults to
+ * `'legacy'`, so every connection's first request is a `server/discover` probe.
+ * On its own that would be a connectivity regression: a proxy, WAF, or strict
+ * gateway that hangs or 5xx's on an unknown method takes a server from working
+ * to failing, and the SSE fallback re-probes and fails identically — so the
+ * two-transport fallback, which looks like defense in depth, collapses to a
+ * single point of failure against exactly the infrastructure it should rescue.
+ *
+ * So when the caller left `protocolNegotiation` unset, a failed connect is
+ * retried once with `'legacy'`. That makes `'auto'` strictly additive: modern
+ * servers get the new revision, everything else lands exactly where it did
+ * before this package started probing. The cost is one extra attempt on a path
+ * that is already failing, which is where latency matters least.
+ *
+ * The retry fires on **any** failure rather than only on ones that look like
+ * probe timeouts. Inspecting the cause would avoid a wasted attempt against a
+ * genuinely dead server, but it would couple this to SDK error codes — and a
+ * reshaped error would silently disable the degradation, which is the failure
+ * mode this package keeps getting bitten by.
+ *
+ * Two bounds keep the retry from making a bad situation worse:
+ *
+ * 1. **It is skipped on an auth failure.** `UnauthorizedError` means the
+ *    transport reached the server and the credentials were rejected — nothing a
+ *    different protocol revision changes. Retrying would re-drive the OAuth
+ *    provider's authorization flow: a second `redirectToAuthorization`, a second
+ *    saved PKCE verifier overwriting the first. Replaying a failure that had
+ *    side effects is worse than not retrying.
+ * 2. **It re-walks the same transport ladder the first pass did.** An earlier
+ *    revision pinned Streamable HTTP to cap the attempt count, which broke the
+ *    case this whole mechanism exists for: a legacy server reachable *only* over
+ *    SSE, behind infrastructure that chokes on the probe, would fail under
+ *    `'auto'` and then never be offered SSE again. Correctness wins over the
+ *    attempt count here — a server that used to connect must still connect.
+ *
+ * So the worst case for a genuinely unreachable server is four `connect()`
+ * calls, two per negotiation mode. That is the honest cost of guaranteeing no
+ * working setup regresses, and it is paid only on a path that was already going
+ * to fail. The bound that matters is that it is a fixed multiple rather than a
+ * retry loop.
+ *
+ * An **explicit** `protocolNegotiation` is honoured exactly, including
+ * `'auto'`: asking for a mode means asking for its failures too, and silently
+ * ignoring a caller's `{ pin }` would defeat the point of pinning.
+ */
+export declare function connect(options: ConnectOptions): Promise<MCPConnection>;
+export {};
+//# sourceMappingURL=mcp-connection.d.ts.map

package/esm/mcp/mcp-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-connection.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAGP,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAKpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA0CrD,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,mBAAmB,CAAC,EAAE,sBAAsB,CAAC;IAC7C;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,gBAAgB,CAAC;IAC5B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,yBAAyB,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAoDD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,cAAc,EACvB,aAAa,EAAE,MAAM,IAAI,GACxB,OAAO,CAAC,MAAM,CAAC,CAKjB;AAsOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,UAAU,eAAe;IACvB,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAC;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,aAAa,CAAC,EAC5B,GAAG,EACH,IAAI,EACJ,qBAAqB,EACrB,KAAS,GACV,EAAE,eAAe,GAAG,OAAO,CAsD3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAiD7E"}

package/esm/mcp/mcp-connection.js

@@ -0,0 +1,478 @@
+import { resolveAuth } from './auth/auth-resolver.js';
+import { isOAuthAuth } from './auth/auth-types.js';
+import { closeQuietly } from './close-quietly.js';
+import { makeElicitationRequestHandler } from './elicitation.js';
+import { MCPConnectionError } from './errors.js';
+import { loadMcpSdk } from './mcp-sdk.js';
+import { PACKAGE_VERSION } from './version.js';
+/**
+ * Ceiling on the `server/discover` probe, in ms.
+ *
+ * The SDK falls back to the full request timeout (60s) when this is unset, which
+ * is a long time to spend on a liveness question: under the `'auto'` default the
+ * probe is the first request of every connection, and a gateway that black-holes
+ * it burns the whole budget per attempt — up to four attempts once the legacy
+ * retry re-walks the transport ladder, so minutes before `createMCPTools()`
+ * rejects on the no-configuration path.
+ *
+ * **But a probe timeout is not recoverable, so this cannot be tight.** On HTTP
+ * the SDK classifies a timed-out probe as an outage and rejects (only stdio
+ * treats it as a legacy verdict), and the legacy retry that follows sends
+ * `initialize` — which revision 2026-07-28 removed (SEP-2575). So a
+ * modern-only server slower than this ceiling fails *both* passes and does not
+ * connect at all, where the SDK's own default would have waited and succeeded.
+ * Serverless cold starts routinely exceed a few seconds, which makes an
+ * aggressive value a correctness bug rather than a latency tradeoff.
+ *
+ * 30s splits the difference: comfortably past a cold start, while keeping the
+ * probe from consuming the SDK's full 60s request budget per attempt. Note the
+ * ceiling bounds only the `'auto'` probes — the implicit legacy retry's
+ * `initialize` attempts still run under the SDK's own timeout, so the
+ * black-holed-gateway worst case on the default path is roughly
+ * 30s + 30s + 60s + 60s ≈ 3 minutes across the four attempts (vs ~2 minutes
+ * for the two attempts before this package probed at all). A caller with a
+ * harder deadline bounds the whole ladder with `signal`. Raise this with
+ * `probeTimeoutMs` for a server known to be slower; lower it when you control
+ * the server and want to fail fast.
+ */
+const DEFAULT_PROBE_TIMEOUT_MS = 30000;
+// Self-reported to every MCP server we connect to as `clientInfo`. Both the
+// implementation and generated version belong to the agent package.
+const DEFAULT_CLIENT_INFO = {
+    name: '@openrouter/agent',
+    version: PACKAGE_VERSION,
+};
+function buildStreamableHttp(sdk, options) {
+    const { headers, authProvider } = resolveAuth(options.auth);
+    return new sdk.StreamableHTTPClientTransport(options.url, {
+        requestInit: {
+            headers,
+        },
+        ...(authProvider !== undefined && {
+            authProvider,
+        }),
+        ...(options.fetch !== undefined && {
+            fetch: options.fetch,
+        }),
+        ...(options.sessionId !== undefined && {
+            sessionId: options.sessionId,
+        }),
+    });
+}
+function buildSse(sdk, options) {
+    const { headers, authProvider } = resolveAuth(options.auth);
+    return new sdk.SSEClientTransport(options.url, {
+        requestInit: {
+            headers,
+        },
+        ...(authProvider !== undefined && {
+            authProvider,
+        }),
+        ...(options.fetch !== undefined && {
+            fetch: options.fetch,
+        }),
+    });
+}
+/** Per-call request options threaded into the SDK's `connect()`. */
+function connectRequestOptions(options) {
+    return options.signal !== undefined
+        ? {
+            signal: options.signal,
+        }
+        : undefined;
+}
+/**
+ * Build the configured `Client` — negotiation mode, elicitation handler, and the
+ * `tools/list_changed` subscription — without connecting it.
+ *
+ * Exported for tests only, and deliberately not re-exported from the package
+ * entrypoint. It is the seam that lets a test drive the real handler wiring over
+ * `InMemoryTransport`: the notification method name is compile-checked (it is a
+ * `NotificationMethod` literal union, so a typo fails `tsc`), but the *dispatch*
+ * — that an inbound notification actually reaches `setToolListChangedHandler`'s
+ * callback — is only observable end to end. Without this seam, default-on
+ * `autoRefreshOnListChanged` could be silently dead with every test green.
+ *
+ * @internal
+ */
+export async function makeClientForTest(options, onListChanged) {
+    const sdk = await loadMcpSdk();
+    return makeClient(sdk, options, {
+        handler: onListChanged,
+    });
+}
+function makeClient(sdk, options, listChanged) {
+    const client = new sdk.Client(options.clientInfo ?? DEFAULT_CLIENT_INFO, {
+        capabilities: {
+            elicitation: {},
+        },
+        // The SDK defaults to 'legacy'; we default to 'auto' so callers reach both
+        // 2025-era and 2026-07-28 servers without configuring anything.
+        //
+        // `inputRequired` is deliberately left unset: its defaults (auto-fulfil on,
+        // 10 rounds) are what we want, and pinning them here would freeze values
+        // the SDK may tune.
+        versionNegotiation: {
+            mode: options.protocolNegotiation ?? 'auto',
+            probe: {
+                timeoutMs: options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS,
+            },
+        },
+    });
+    // Method-name-first in SDK v2; spec methods supply their own schema. This one
+    // handler serves both protocol eras: on 2025-era connections the server sends
+    // `elicitation/create` directly, and on 2026-07-28 the multi-round-trip driver
+    // dispatches `input_required` through this same handler, then retries the
+    // original call with the collected `inputResponses`.
+    client.setRequestHandler('elicitation/create', makeElicitationRequestHandler(options.onElicitation));
+    // Kept as a notification handler rather than `ClientOptions.listChanged`: the
+    // latter re-lists tools itself, duplicating the handle's own `refresh()` and
+    // its cache write. Notification handlers are era-transparent.
+    client.setNotificationHandler('notifications/tools/list_changed', () => {
+        listChanged.handler?.();
+    });
+    return client;
+}
+/**
+ * Connect a `Client` to the MCP server.
+ *
+ * Defaults to Streamable HTTP and falls back to SSE on connection failure
+ * (legacy servers), unless a transport is pinned explicitly. Auth, the
+ * elicitation handler, and the list_changed subscription are wired into the
+ * single connected client so they apply to discovery and every tool call.
+ *
+ * When the caller does not set `protocolNegotiation`, a failed connect is
+ * retried once with `'legacy'` — see {@link connect} below, which owns that
+ * policy; this function performs exactly one negotiation mode.
+ */
+async function connectWithNegotiation(sdk, options) {
+    const preferred = options.transport ?? 'streamableHttp';
+    const listChanged = {
+        handler: undefined,
+    };
+    if (preferred === 'sse') {
+        const client = makeClient(sdk, options, listChanged);
+        try {
+            await client.connect(buildSse(sdk, options), connectRequestOptions(options));
+        }
+        catch (sseErr) {
+            // Same transport-release reason as the Streamable HTTP path below.
+            await closeQuietly(client);
+            // Wrapped like every other path. Rethrowing raw here made the error type a
+            // caller sees depend on whether `protocolNegotiation` happened to be set —
+            // unset, the outer retry aggregated it into an `MCPConnectionError`; set, the
+            // transport error escaped. Same server, same failure, different `catch`.
+            throw new MCPConnectionError('Failed to connect over SSE', {
+                cause: sseErr,
+            });
+        }
+        return wrap({
+            client,
+            transport: 'sse',
+            listChanged,
+        });
+    }
+    // Streamable HTTP, with SSE fallback when the transport wasn't pinned.
+    const client = makeClient(sdk, options, listChanged);
+    try {
+        const http = buildStreamableHttp(sdk, options);
+        await client.connect(http, connectRequestOptions(options));
+        return wrap({
+            client,
+            transport: 'streamableHttp',
+            listChanged,
+            ...(http.sessionId !== undefined && {
+                sessionId: http.sessionId,
+            }),
+        });
+    }
+    catch (httpErr) {
+        // Release the failed client's transport. The SDK cleans up after a failed
+        // probe or `initialize` handshake, but not when `transport.start()` itself
+        // throws: the base connect stores the transport before starting it and
+        // propagates without teardown, leaving a keep-alive socket open. Releasing
+        // unconditionally is safe on the paths the SDK already handles — see
+        // `closeQuietly`, which tolerates any close outcome rather than depending on
+        // what the SDK does internally.
+        await closeQuietly(client);
+        if (options.transport === 'streamableHttp' ||
+            isAuthFailure({
+                err: httpErr,
+                auth: options.auth,
+                UnauthorizedErrorType: sdk.UnauthorizedError,
+            })) {
+            // Auth failures stop here rather than falling through. The SSE attempt
+            // would carry the same `authProvider` into the SDK's auth path — a second
+            // `redirectToAuthorization`, a second `saveCodeVerifier` overwriting the
+            // first — which is the duplicated side effect `connect()`'s retry guard
+            // exists to prevent. Guarding one and not the other left the hazard inside
+            // a single pass, where it is arguably worse: the caller did not even opt
+            // into a second negotiation mode.
+            throw new MCPConnectionError('Failed to connect over Streamable HTTP', {
+                cause: httpErr,
+            });
+        }
+        // An aborted caller gets no fallback: the same signal rides into the SSE
+        // attempt, but whether it interrupts `transport.start()` promptly is the
+        // SDK's business — checking here makes "abort means stop dialling"
+        // deterministic instead of dependent on where the SDK polls the signal.
+        if (options.signal?.aborted === true) {
+            throw new MCPConnectionError('Failed to connect over Streamable HTTP', {
+                cause: httpErr,
+            });
+        }
+        // Fall back to SSE on a fresh client (the failed one may be half-initialized).
+        // Under `'auto'` this re-probes, so a probe-hostile server fails here too —
+        // which is why `connect()` retries the whole thing under `'legacy'` when the
+        // caller did not pin a negotiation mode.
+        const sseClient = makeClient(sdk, options, listChanged);
+        try {
+            await sseClient.connect(buildSse(sdk, options), connectRequestOptions(options));
+            return wrap({
+                client: sseClient,
+                transport: 'sse',
+                listChanged,
+            });
+        }
+        catch (sseErr) {
+            await closeQuietly(sseClient);
+            // Both failures are kept. `sseErr` is the `cause` because it is the last
+            // thing tried, but discarding `httpErr` loses information the caller needs:
+            // an `UnauthorizedError` from the HTTP attempt is what tells `connect()` not
+            // to retry, and a 404/405 from an endpoint that simply isn't an SSE URL
+            // would otherwise hide it. `errors` matches `AggregateError`'s shape so the
+            // pair is discoverable without a bespoke field.
+            throw new MCPConnectionError('Failed to connect over Streamable HTTP and SSE', {
+                cause: sseErr,
+                errors: [
+                    httpErr,
+                    sseErr,
+                ],
+            });
+        }
+    }
+}
+/**
+ * Reduce one pass's failure to the list of attempts behind it.
+ *
+ * A pass that tried both transports is already an `MCPConnectionError` carrying
+ * them in `errors`; unwrapping keeps `errors` a flat list of real attempts rather
+ * than a tree of wrappers, so a caller can iterate it without recursing. A pass
+ * that tried one transport contributes itself.
+ */
+function flattenAttempts(err) {
+    if (err instanceof MCPConnectionError) {
+        if (err.errors.length > 0) {
+            return err.errors;
+        }
+        // A single-transport pass wraps its one failure with only `cause` set, so
+        // returning it as-is would put an opaque wrapper in a list documented as
+        // holding real attempts — and a caller scanning for a rejected token would
+        // have to know to dig through `cause` on some entries but not others.
+        if (err.cause !== undefined) {
+            return [
+                err.cause,
+            ];
+        }
+    }
+    return [
+        err,
+    ];
+}
+/**
+ * Does this error carry an HTTP status that means "your credentials were the
+ * problem"?
+ *
+ * 401 only, deliberately. The suppression this feeds exists to avoid re-driving
+ * OAuth side effects, and in SDK v2 those side effects (`saveCodeVerifier`,
+ * `redirectToAuthorization`) live exclusively behind the transport's
+ * `status === 401 && this._authProvider` branch — a 403 never enters the OAuth
+ * flow at all. Meanwhile proxies and WAFs commonly answer an unknown method
+ * like `server/discover` with 403 without consulting credentials, so treating
+ * 403 as a credential rejection made exactly the deployments the legacy retry
+ * exists to rescue permanently unreachable, for OAuth users only. A 403 retry
+ * re-drives nothing; a 401 retry re-drives the flow. Match the side effect,
+ * not the status class.
+ *
+ * Read via a duck-typed `status` rather than `instanceof SdkHttpError` plus an
+ * `SdkErrorCode` comparison: the numeric status is the stable half of that
+ * contract, and it also catches a gateway surfacing 401 in some other error
+ * shape.
+ *
+ * Only consulted when the caller configured OAuth — see {@link isAuthFailure}.
+ */
+function isAuthStatus(err) {
+    // Errors only. A plain object carrying a `status` is far more likely to be a
+    // response, a log record, or some other payload that happens to travel in a
+    // `cause` than an authoritative rejection — the SDK itself builds log entries
+    // with `status: 0`, and treating one of those as a credential failure would
+    // silently suppress the retry and make a probe-hostile server unreachable.
+    if (!(err instanceof Error) || !('status' in err)) {
+        return false;
+    }
+    const { status } = err;
+    return status === 401;
+}
+export function isAuthFailure({ err, auth, UnauthorizedErrorType, depth = 0, }) {
+    if (depth >= 8) {
+        return false;
+    }
+    // `UnauthorizedError` is unconditional: the SDK only throws it from the
+    // provider-wrapped fetch and the authorization flow itself, so it inherently
+    // means an OAuth provider is in play and its flow would be re-driven.
+    if (UnauthorizedErrorType !== undefined && err instanceof UnauthorizedErrorType) {
+        return true;
+    }
+    // A bare 401 status counts only when the caller configured OAuth — the one
+    // auth kind where a 401 retry has side effects (a second
+    // `redirectToAuthorization`, an overwritten PKCE verifier). 403 never
+    // suppresses, even under OAuth: the SDK's PKCE writes live exclusively behind
+    // its 401 branch, so a 403 retry re-drives nothing — while proxies and WAFs
+    // commonly answer an unknown method like `server/discover` with 403, exactly
+    // the probe-hostile infrastructure the retry exists to rescue. With bearer,
+    // headers, or no auth, no status suppresses.
+    if (isOAuthAuth(auth) && isAuthStatus(err)) {
+        return true;
+    }
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    // Covers our own `errors` and `AggregateError`'s alike — Node's
+    // happy-eyeballs path and some fetch implementations report a 401 as an
+    // `AggregateError` member rather than as a `cause`, which a spine-only walk
+    // would miss.
+    const { errors } = err;
+    if (Array.isArray(errors)) {
+        for (const nested of errors) {
+            if (isAuthFailure({
+                err: nested,
+                auth,
+                UnauthorizedErrorType,
+                depth: depth + 1,
+            })) {
+                return true;
+            }
+        }
+    }
+    return (err.cause !== undefined &&
+        isAuthFailure({
+            err: err.cause,
+            auth,
+            UnauthorizedErrorType,
+            depth: depth + 1,
+        }));
+}
+/**
+ * Connect a `Client` to the MCP server, degrading to the 2025-era handshake if
+ * protocol negotiation gets in the way.
+ *
+ * We default `protocolNegotiation` to `'auto'` where the SDK defaults to
+ * `'legacy'`, so every connection's first request is a `server/discover` probe.
+ * On its own that would be a connectivity regression: a proxy, WAF, or strict
+ * gateway that hangs or 5xx's on an unknown method takes a server from working
+ * to failing, and the SSE fallback re-probes and fails identically — so the
+ * two-transport fallback, which looks like defense in depth, collapses to a
+ * single point of failure against exactly the infrastructure it should rescue.
+ *
+ * So when the caller left `protocolNegotiation` unset, a failed connect is
+ * retried once with `'legacy'`. That makes `'auto'` strictly additive: modern
+ * servers get the new revision, everything else lands exactly where it did
+ * before this package started probing. The cost is one extra attempt on a path
+ * that is already failing, which is where latency matters least.
+ *
+ * The retry fires on **any** failure rather than only on ones that look like
+ * probe timeouts. Inspecting the cause would avoid a wasted attempt against a
+ * genuinely dead server, but it would couple this to SDK error codes — and a
+ * reshaped error would silently disable the degradation, which is the failure
+ * mode this package keeps getting bitten by.
+ *
+ * Two bounds keep the retry from making a bad situation worse:
+ *
+ * 1. **It is skipped on an auth failure.** `UnauthorizedError` means the
+ *    transport reached the server and the credentials were rejected — nothing a
+ *    different protocol revision changes. Retrying would re-drive the OAuth
+ *    provider's authorization flow: a second `redirectToAuthorization`, a second
+ *    saved PKCE verifier overwriting the first. Replaying a failure that had
+ *    side effects is worse than not retrying.
+ * 2. **It re-walks the same transport ladder the first pass did.** An earlier
+ *    revision pinned Streamable HTTP to cap the attempt count, which broke the
+ *    case this whole mechanism exists for: a legacy server reachable *only* over
+ *    SSE, behind infrastructure that chokes on the probe, would fail under
+ *    `'auto'` and then never be offered SSE again. Correctness wins over the
+ *    attempt count here — a server that used to connect must still connect.
+ *
+ * So the worst case for a genuinely unreachable server is four `connect()`
+ * calls, two per negotiation mode. That is the honest cost of guaranteeing no
+ * working setup regresses, and it is paid only on a path that was already going
+ * to fail. The bound that matters is that it is a fixed multiple rather than a
+ * retry loop.
+ *
+ * An **explicit** `protocolNegotiation` is honoured exactly, including
+ * `'auto'`: asking for a mode means asking for its failures too, and silently
+ * ignoring a caller's `{ pin }` would defeat the point of pinning.
+ */
+export async function connect(options) {
+    const sdk = await loadMcpSdk();
+    if (options.protocolNegotiation !== undefined) {
+        return connectWithNegotiation(sdk, options);
+    }
+    try {
+        return await connectWithNegotiation(sdk, options);
+    }
+    catch (autoErr) {
+        // A caller-initiated abort is not a server problem: retrying under
+        // `'legacy'` would immediately re-abort (or worse, outlive the caller's
+        // deadline). Surface the abort as-is.
+        if (options.signal?.aborted === true) {
+            throw autoErr;
+        }
+        if (isAuthFailure({
+            err: autoErr,
+            auth: options.auth,
+            UnauthorizedErrorType: sdk.UnauthorizedError,
+        })) {
+            throw autoErr;
+        }
+        // Not inspecting the error for *whether* the probe was at fault: that would
+        // couple us to SDK error codes, and a reshaped error would silently disable
+        // the whole degradation. `UnauthorizedError` above is the one exception,
+        // because there the cost of retrying is a duplicated side effect rather than
+        // a wasted dial — and if that check ever stops matching we merely retry,
+        // which is the pre-existing behavior rather than a silent loss of function.
+        try {
+            return await connectWithNegotiation(sdk, {
+                ...options,
+                protocolNegotiation: 'legacy',
+            });
+        }
+        catch (legacyErr) {
+            // Carry both passes. Letting `legacyErr` propagate untouched would drop
+            // everything the `'auto'` pass learned — up to half the attempts, and any
+            // auth-shaped rejection that `isAuthFailure` did not match — which would
+            // also make `MCPConnectionError.errors` a lie about being every failure in
+            // attempt order.
+            throw new MCPConnectionError('Failed to connect over any transport or protocol revision', {
+                cause: legacyErr,
+                errors: [
+                    ...flattenAttempts(autoErr),
+                    ...flattenAttempts(legacyErr),
+                ],
+            });
+        }
+    }
+}
+function wrap(args) {
+    const { client, transport, listChanged, sessionId } = args;
+    return {
+        client,
+        transport,
+        ...(sessionId !== undefined && {
+            sessionId,
+        }),
+        setToolListChangedHandler: (handler) => {
+            listChanged.handler = handler;
+        },
+        close: () => client.close(),
+    };
+}
+//# sourceMappingURL=mcp-connection.js.map

package/esm/mcp/mcp-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-connection.js","sourceRoot":"","sources":["../../src/mcp/mcp-connection.ts"],"names":[],"mappings":"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"}

package/esm/mcp/mcp-sdk.d.ts

@@ -0,0 +1,10 @@
+import type { Client, SSEClientTransport, StreamableHTTPClientTransport, UnauthorizedError } from '@modelcontextprotocol/client';
+export interface MCPSdk {
+    Client: typeof Client;
+    SSEClientTransport: typeof SSEClientTransport;
+    StreamableHTTPClientTransport: typeof StreamableHTTPClientTransport;
+    UnauthorizedError: typeof UnauthorizedError;
+}
+/** Load the optional MCP client only when a connection is actually requested. */
+export declare function loadMcpSdk(): Promise<MCPSdk>;
+//# sourceMappingURL=mcp-sdk.d.ts.map

package/esm/mcp/mcp-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-sdk.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp-sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,kBAAkB,EAClB,6BAA6B,EAC7B,iBAAiB,EAClB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,kBAAkB,EAAE,OAAO,kBAAkB,CAAC;IAC9C,6BAA6B,EAAE,OAAO,6BAA6B,CAAC;IACpE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;CAC7C;AAqBD,iFAAiF;AACjF,wBAAgB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAkB5C"}