@vercel/connect 2.2.0 → 2.3.1

package/README.md

@@ -2,12 +2,13 @@
 
 SDK for obtaining scoped tokens for third-party services on behalf of apps or users. Authenticates the calling Vercel project via [`@vercel/oidc`](https://www.npmjs.com/package/@vercel/oidc) and exchanges the OIDC token for a Vercel Connect-issued credential.
 
-Seven entrypoints, all ESM:
+Eight entrypoints, all ESM:
 
 - `@vercel/connect` — core token / authorization SDK
 - `@vercel/connect/chat` — adapter helpers for the [Chat SDK](https://chat-sdk.dev) (`chat`): `connectSlackAdapter`, `connectDiscordAdapter`, `connectGitHubAdapter`, `connectLinearAdapter`, `connectNotionAdapter`, `connectTelegramAdapter`, `connectSendblueAdapter`, `connectTeamsAdapter` (no Chat SDK dependency — returns structural config)
 - `@vercel/connect/ai-sdk` — [Vercel AI SDK](https://ai-sdk.dev) glue: re-exports `connectAuthProvider` for MCP transports (optional peers: `ai`, `@ai-sdk/mcp`)
-- `@vercel/connect/mcp` — canonical MCP-spec `OAuthClientProvider` for any MCP client (optional peer: `@ai-sdk/mcp`)
+- `@vercel/connect/mcp` — canonical MCP-spec `OAuthClientProvider` for any MCP client (no SDK dependency; returns a self-contained `ConnectOAuthClientProvider` assignable to `@ai-sdk/mcp` and `@modelcontextprotocol/sdk`)
+- `@vercel/connect/tanstack-ai` — [TanStack AI](https://tanstack.com/ai) glue: `connectMCPTransport` builds a `@tanstack/ai-mcp` transport config with a Connect `authProvider` (eager consent on Streamable HTTP, spec 401 flow on SSE), plus `getConsentChallenge` (no TanStack, AI SDK, or MCP SDK dependency)
 - `@vercel/connect/eve` — adapter helpers for [Eve](https://github.com/vercel/eve) connections (optional peer: `eve`)
 - `@vercel/connect/betterauth` — [Better Auth](https://www.better-auth.com/) `genericOAuth` provider (optional peer: `better-auth`)
 - `@vercel/connect/authjs` — [Auth.js](https://authjs.dev/) `OAuth2Config` provider (optional peer: `@auth/core`)
@@ -121,6 +122,62 @@ SDK's `toolApproval` option or `wrapMcpTools` from `@ai-sdk/policy-opa`.
 
 Non-AI-SDK MCP clients (the official MCP TypeScript SDK, Mastra, etc.)
 can import the same `connectAuthProvider` from `@vercel/connect/mcp`.
+TanStack AI has its own subpath, `@vercel/connect/tanstack-ai`, described
+below.
+
+### TanStack AI + MCP
+
+`@tanstack/ai-mcp`'s `createMCPClient` passes `transport.authProvider`
+straight to the official `@modelcontextprotocol/sdk` transports.
+`connectMCPTransport` builds that transport config with a Connect-backed
+`authProvider` and picks the consent mode per transport: on Streamable HTTP
+(`type: 'http'`) a missing grant fails eagerly inside `createMCPClient`, at
+the route boundary, instead of mid-run inside a tool call where TanStack
+would feed the error back to the model as text; on SSE it keeps the MCP-spec
+401 flow, because the SSE EventSource would turn an eager throw into a
+reconnect loop. TanStack wraps connect failures in `MCPConnectionError`;
+`getConsentChallenge` looks through the `cause` chain for you. The adapter
+also supplies a fixed discovery state so the official SDK never fetches OAuth
+metadata from URLs the MCP server names in `WWW-Authenticate`, and the
+transport refuses HTTP redirects by default (`redirect: 'error'`, as in
+`@ai-sdk/mcp`).
+
+```ts
+import { chat, toServerSentEventsResponse } from '@tanstack/ai';
+import { createMCPClient } from '@tanstack/ai-mcp';
+import {
+  connectMCPTransport,
+  getConsentChallenge,
+} from '@vercel/connect/tanstack-ai';
+
+export async function POST(request: Request) {
+  try {
+    const linear = await createMCPClient({
+      transport: connectMCPTransport(
+        { type: 'http', url: 'https://mcp.linear.app/mcp' },
+        'oauth/linear',
+        { subject: { type: 'user', id: userId } },
+        { redirectUrl: 'https://app.example.com/integrations' }
+      ),
+    });
+    const stream = chat({ adapter, messages, mcp: { clients: [linear] } });
+    return toServerSentEventsResponse(stream);
+  } catch (err) {
+    const challenge = getConsentChallenge(err);
+    if (challenge) return Response.redirect(challenge.url);
+    throw err;
+  }
+}
+```
+
+`createMCPClients` pools take the same per-entry transport config, so one
+`connectMCPTransport` per connector drops in. `connectAuthProvider` is also
+re-exported for hand-built transports; only pass `consent: 'eager'` with
+`type: 'http'`. Tool-call approval remains independent of Connect: use
+TanStack's `needsApproval` on tool definitions. See the
+[TanStack AI integration guide](https://github.com/vercel/vercel/blob/main/packages/connect/docs/tanstack-ai-mcp-integration.md)
+for the eager-consent rationale, the SSE caveat, pool caveats, and the
+`redirectUrl` fix for official-SDK transports.
 
 ### Eve
 

package/dist/ai-sdk/index.d.ts

@@ -11,10 +11,12 @@
  * the AI SDK's own `toolApproval` primitive (and `wrapMcpTools` in
  * `@ai-sdk/policy-opa`). See `docs/ai-sdk-mcp-integration.md`.
  *
- * Both `ai` and `@ai-sdk/mcp` are optional peer dependencies:
- * importing this entrypoint requires them to be installed in the
- * consumer project, but the rest of `@vercel/connect` works without
- * them.
+ * This entrypoint has no runtime or type import of `ai` or
+ * `@ai-sdk/mcp`; `connectAuthProvider` returns the self-contained
+ * `ConnectOAuthClientProvider`, which the test suite asserts is
+ * assignable to `@ai-sdk/mcp`'s `OAuthClientProvider`. Both packages
+ * are declared as optional peers only to signal the tested version
+ * ranges.
  *
  * ```ts
  * import { createMCPClient } from '@ai-sdk/mcp';
@@ -48,5 +50,5 @@
  * }
  * ```
  */
-export { connectAuthProvider, ConsentRequiredError, type ConnectAuthProviderOptions, type ConsentChallenge, } from '../mcp/connect-auth-provider.js';
+export { CONNECT_DISCOVERY_STATE, CONNECT_MANAGED_REDIRECT_URL, connectAuthProvider, ConsentRequiredError, getConsentChallenge, isConsentRequiredError, type ConnectAuthProviderOptions, type ConnectConsentMode, type ConnectOAuthClientInformation, type ConnectOAuthClientMetadata, type ConnectOAuthClientProvider, type ConnectOAuthDiscoveryState, type ConnectOAuthTokens, type ConsentChallenge, } from '../mcp/connect-auth-provider.js';
 export { ConnectError, ConnectorInstallationRequiredError, NoValidTokenError, UserAuthorizationRequiredError, type ConnectErrorOptions, type ConnectTokenExchangeSubject, type ConnectTokenParams, type ConnectTokenSubject, type ConnectVendorErrorPayload, } from '../token.js';

package/dist/ai-sdk/index.js

@@ -11,10 +11,12 @@
  * the AI SDK's own `toolApproval` primitive (and `wrapMcpTools` in
  * `@ai-sdk/policy-opa`). See `docs/ai-sdk-mcp-integration.md`.
  *
- * Both `ai` and `@ai-sdk/mcp` are optional peer dependencies:
- * importing this entrypoint requires them to be installed in the
- * consumer project, but the rest of `@vercel/connect` works without
- * them.
+ * This entrypoint has no runtime or type import of `ai` or
+ * `@ai-sdk/mcp`; `connectAuthProvider` returns the self-contained
+ * `ConnectOAuthClientProvider`, which the test suite asserts is
+ * assignable to `@ai-sdk/mcp`'s `OAuthClientProvider`. Both packages
+ * are declared as optional peers only to signal the tested version
+ * ranges.
  *
  * ```ts
  * import { createMCPClient } from '@ai-sdk/mcp';
@@ -48,5 +50,5 @@
  * }
  * ```
  */
-export { connectAuthProvider, ConsentRequiredError, } from '../mcp/connect-auth-provider.js';
+export { CONNECT_DISCOVERY_STATE, CONNECT_MANAGED_REDIRECT_URL, connectAuthProvider, ConsentRequiredError, getConsentChallenge, isConsentRequiredError, } from '../mcp/connect-auth-provider.js';
 export { ConnectError, ConnectorInstallationRequiredError, NoValidTokenError, UserAuthorizationRequiredError, } from '../token.js';

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { deleteTokenCacheEntry, getToken, getTokenResponse, revokeToken, Connect
 export { startAuthorization, type ConnectAuthorizationOptions, type ConnectAuthorizationResponse, } from './authorization.js';
 export { experimental_startInstallation, type ConnectInstallationOptions, type ConnectInstallationParams, type ConnectInstallationResponse, } from './installation.js';
 export type { ConnectAuthorizationDetail } from './authorization-details.js';
-export { getConnectorMetadata, type ConnectorMetadata, } from './connector.js';
+export { getConnectorMetadata, type ConnectorMetadata } from './connector.js';

package/dist/index.js

@@ -1,4 +1,4 @@
 export { deleteTokenCacheEntry, getToken, getTokenResponse, revokeToken, ConnectError, NoValidTokenError, UserAuthorizationRequiredError, ConnectorInstallationRequiredError, } from './token.js';
 export { startAuthorization, } from './authorization.js';
 export { experimental_startInstallation, } from './installation.js';
-export { getConnectorMetadata, } from './connector.js';
+export { getConnectorMetadata } from './connector.js';

package/dist/mcp/connect-auth-provider.d.ts

@@ -1,5 +1,117 @@
-import type { OAuthClientProvider } from '@ai-sdk/mcp';
 import { type ConnectTokenParams } from '../token.js';
+/**
+ * OAuth token set as consumed by MCP client transports (RFC 6749 §5.1).
+ * Structurally identical to `OAuthTokens` in both `@ai-sdk/mcp` and
+ * `@modelcontextprotocol/sdk`; declared here so this module has no
+ * type dependency on either package.
+ */
+export interface ConnectOAuthTokens {
+    access_token: string;
+    token_type: string;
+    expires_in?: number;
+    scope?: string;
+    refresh_token?: string;
+    id_token?: string;
+}
+/**
+ * Minimal OAuth client metadata (RFC 7591 §2). Only consulted by MCP
+ * transports during dynamic client registration, which the Connect
+ * adapter never triggers.
+ */
+export interface ConnectOAuthClientMetadata {
+    redirect_uris: string[];
+}
+/** OAuth client identity reported to MCP transports. */
+export interface ConnectOAuthClientInformation {
+    client_id: string;
+}
+/**
+ * Structural mirror of the official SDK's `OAuthDiscoveryState`: the
+ * result of RFC 9728 protected-resource discovery plus authorization
+ * server metadata. {@link connectAuthProvider} returns a fixed state
+ * naming Connect as the authorization server so the SDK never performs
+ * network discovery; see {@link CONNECT_DISCOVERY_STATE}.
+ */
+export interface ConnectOAuthDiscoveryState {
+    authorizationServerUrl: string;
+    authorizationServerMetadata: {
+        issuer: string;
+        authorization_endpoint: string;
+        token_endpoint: string;
+        response_types_supported: string[];
+        code_challenge_methods_supported: string[];
+    };
+    resourceMetadata: {
+        resource: string;
+        authorization_servers: string[];
+    };
+}
+/**
+ * The MCP-spec `OAuthClientProvider` members implemented by
+ * {@link connectAuthProvider}.
+ *
+ * This is the intersection of the required surface of
+ * `OAuthClientProvider` from `@ai-sdk/mcp` and from the official
+ * `@modelcontextprotocol/sdk` (`client/auth.js`), so a value of this
+ * type is assignable to either interface without a cast. The optional
+ * members those interfaces declare (`state`, `invalidateCredentials`,
+ * `addClientAuthentication`, `prepareTokenRequest`, discovery-state
+ * hooks, …) are deliberately omitted: Connect owns registration, PKCE,
+ * refresh, and storage server-side, and declaring them here would tie
+ * this type to one SDK's parameter types. The test suite asserts
+ * assignability against both SDKs.
+ *
+ * The exceptions are the three discovery hooks at the bottom. They
+ * are optional in the official SDK's interface and absent from
+ * `@ai-sdk/mcp`'s, and are implemented here so the official SDK's
+ * `auth()` never fetches discovery documents from URLs chosen by the
+ * MCP server's `WWW-Authenticate` header (a blind-SSRF vector when
+ * the configured server is compromised). Connect is the authorization
+ * server from this adapter's point of view, so there is nothing to
+ * discover.
+ */
+export interface ConnectOAuthClientProvider {
+    tokens(): Promise<ConnectOAuthTokens | undefined>;
+    saveTokens(tokens: ConnectOAuthTokens): void;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    get redirectUrl(): string;
+    get clientMetadata(): ConnectOAuthClientMetadata;
+    clientInformation(): ConnectOAuthClientInformation;
+    discoveryState(): ConnectOAuthDiscoveryState;
+    saveDiscoveryState(state: unknown): void;
+    validateResourceURL(serverUrl: string | URL, resource?: string): Promise<URL | undefined>;
+}
+/**
+ * How {@link connectAuthProvider} surfaces a missing Connect grant.
+ *
+ * - `'transport'` (default) — `tokens()` returns `undefined` and the
+ *   MCP transport's own 401 → `auth()` orchestrator eventually calls
+ *   `redirectToAuthorization`, where the Connect consent URL is
+ *   raised. This is the MCP-spec contract and works with every
+ *   transport in `@ai-sdk/mcp` and `@modelcontextprotocol/sdk`.
+ * - `'eager'` — `tokens()` itself raises the consent challenge, before
+ *   any request reaches the MCP server. Connect authoritatively knows
+ *   whether a grant exists, so this skips the transport's
+ *   protected-resource discovery round-trips and surfaces the
+ *   challenge on the very first request (the MCP `initialize`
+ *   handshake) instead of mid-run inside a tool call.
+ *
+ *   **Streamable HTTP only.** The official SDK's
+ *   `StreamableHTTPClientTransport` (and `@ai-sdk/mcp`'s HTTP
+ *   transport) call `tokens()` per request and let a throw propagate
+ *   to the caller. The official `SSEClientTransport` instead calls
+ *   `tokens()` inside the `fetch` it hands to its EventSource, which
+ *   treats any throw as a retryable network error: the consent error
+ *   is flattened to a cause-less `SseError` and the EventSource
+ *   reconnects every few seconds, minting a new Connect authorization
+ *   request each time, until the transport is closed. Never combine
+ *   `'eager'` with an SSE transport; `connectMCPTransport` in
+ *   `@vercel/connect/tanstack-ai` selects the mode per transport type
+ *   for you.
+ */
+export type ConnectConsentMode = 'transport' | 'eager';
 /** Options accepted by {@link connectAuthProvider}. */
 export interface ConnectAuthProviderOptions {
     /**
@@ -20,8 +132,16 @@ export interface ConnectAuthProviderOptions {
      * `startAuthorization` (as its `callbackUrl`) and also surfaced
      * through the MCP-spec `OAuthClientProvider.redirectUrl` getter.
      *
-     * Defaults to an empty string — Connect then falls back to the
-     * connector's server-side registered redirect.
+     * When omitted, Connect falls back to the connector's server-side
+     * registered redirect, and the `redirectUrl` getter reports
+     * {@link CONNECT_MANAGED_REDIRECT_URL} instead of an empty string.
+     * The official `@modelcontextprotocol/sdk` treats a falsy
+     * `redirectUrl` as a request for its non-interactive
+     * client-credentials flow, which would bypass Connect's consent
+     * page entirely; a non-empty placeholder keeps that transport on
+     * the interactive path. The placeholder is never used as a real
+     * redirect: `redirectToAuthorization` discards the SDK-built
+     * authorization URL in favour of Connect's own consent URL.
      */
     readonly redirectUrl?: string;
     /**
@@ -35,10 +155,29 @@ export interface ConnectAuthProviderOptions {
      * Called when Vercel Connect reports that the user has not yet
      * authorized the connector. The caller decides how to surface the
      * consent URL — `redirect()`, throw a typed error, emit a custom
-     * UI chunk, etc. If omitted, `connectAuthProvider` throws
-     * {@link ConsentRequiredError}.
+     * UI chunk, etc.
+     *
+     * In `'transport'` consent mode the callback replaces the default
+     * {@link ConsentRequiredError}: if it returns normally, this adapter
+     * throws nothing. The MCP transport still fails the request with
+     * its own generic `UnauthorizedError` (which carries no `cause`, so
+     * {@link getConsentChallenge} cannot recover the URL from it); a
+     * non-throwing callback is therefore only useful for side effects
+     * such as logging or emitting a UI chunk, or when the callback
+     * itself redirects by throwing (e.g. a framework `redirect()`).
+     *
+     * In `'eager'` mode the callback runs first and
+     * {@link ConsentRequiredError} is thrown regardless, because
+     * `tokens()` must abort the outgoing request; returning `undefined`
+     * there would let the transport proceed unauthenticated and raise
+     * the challenge a second time.
      */
     readonly onConsentRequired?: (challenge: ConsentChallenge) => void | Promise<void>;
+    /**
+     * Where the consent challenge is raised. See
+     * {@link ConnectConsentMode}. Defaults to `'transport'`.
+     */
+    readonly consent?: ConnectConsentMode;
 }
 /**
  * Returned to {@link ConnectAuthProviderOptions.onConsentRequired} (or
@@ -68,6 +207,11 @@ export interface ConsentChallenge {
  * the configured subject. Catch at the boundary
  * (`route handler` / `streamText` call site) and redirect to
  * `error.url`.
+ *
+ * MCP client libraries often wrap connection failures in their own
+ * error type (for example `@tanstack/ai-mcp`'s `MCPConnectionError`)
+ * with this error on `cause`. Use {@link getConsentChallenge} to find
+ * it anywhere in a `cause` chain.
  */
 export declare class ConsentRequiredError extends Error {
     readonly name = "ConsentRequiredError";
@@ -81,13 +225,79 @@ export declare class ConsentRequiredError extends Error {
     constructor(challenge: ConsentChallenge);
 }
 /**
- * Builds an MCP-spec {@link OAuthClientProvider} backed by Vercel
+ * Type guard for {@link ConsentRequiredError}. Only matches the error
+ * itself; use {@link getConsentChallenge} to look through wrapping
+ * errors' `cause` chains.
+ */
+export declare function isConsentRequiredError(err: unknown): err is ConsentRequiredError;
+/**
+ * Finds a Connect consent challenge in `err` or anywhere along its
+ * `cause` chain and returns it, or `undefined` when none is present.
+ *
+ * MCP clients typically raise the adapter's {@link ConsentRequiredError}
+ * from inside their connect / tool-call machinery and re-wrap it —
+ * `@tanstack/ai-mcp`'s `createMCPClient` throws `MCPConnectionError`
+ * with the original error on `cause`. This helper lets a route handler
+ * branch on consent without knowing the wrapping shape:
+ *
+ * ```ts
+ * } catch (err) {
+ *   const challenge = getConsentChallenge(err);
+ *   if (challenge) return Response.redirect(challenge.url);
+ *   throw err;
+ * }
+ * ```
+ *
+ * Matching is by `instanceof` first, then structurally on
+ * `name === 'ConsentRequiredError'` so a duplicated copy of
+ * `@vercel/connect` in the dependency graph is still recognized.
+ */
+export declare function getConsentChallenge(err: unknown): ConsentChallenge | undefined;
+/**
+ * Value reported by `OAuthClientProvider.redirectUrl` when no
+ * {@link ConnectAuthProviderOptions.redirectUrl} is configured.
+ *
+ * Connect's hosted consent flow owns the real post-consent redirect
+ * (the connector's server-side registered redirect), so this URL is
+ * never followed. It exists only so the official
+ * `@modelcontextprotocol/sdk` `auth()` orchestrator — which treats a
+ * falsy `redirectUrl` as "run the non-interactive client-credentials
+ * flow" — stays on the interactive path and reaches
+ * `redirectToAuthorization`.
+ */
+export declare const CONNECT_MANAGED_REDIRECT_URL = "https://connect.vercel.com/";
+/**
+ * Discovery state returned by `OAuthClientProvider.discoveryState()`.
+ *
+ * The official `@modelcontextprotocol/sdk` `auth()` orchestrator runs
+ * RFC 9728 discovery on every 401: it fetches the URL named by the MCP
+ * server's `WWW-Authenticate: Bearer resource_metadata="…"` parameter,
+ * then the authorization-server metadata at whatever host that
+ * document names. Neither URL is validated, so a compromised MCP
+ * server can point them at private-network addresses (blind SSRF).
+ * When a provider returns a complete cached state the orchestrator
+ * skips every discovery fetch, so this adapter returns one that names
+ * Connect as the authorization server. None of these endpoints is
+ * ever called: `redirectToAuthorization` discards the authorization
+ * URL the SDK builds from them in favour of Connect's own consent URL,
+ * and the token endpoint is only used for refresh and code exchange,
+ * both of which Connect performs server-side.
+ */
+export declare const CONNECT_DISCOVERY_STATE: ConnectOAuthDiscoveryState;
+/**
+ * Builds an MCP-spec `OAuthClientProvider` backed by Vercel
  * Connect. The returned object delegates `tokens()` to
  * {@link getTokenResponse} and `redirectToAuthorization` to
  * {@link startAuthorization}. Connect owns client registration, PKCE,
  * state, and the callback handshake server-side, so most of the
  * `OAuthClientProvider` surface is intentionally a no-op.
  *
+ * The returned object satisfies both `@ai-sdk/mcp`'s and the official
+ * `@modelcontextprotocol/sdk`'s `OAuthClientProvider` interfaces, so
+ * it plugs into `createMCPClient` from either `@ai-sdk/mcp` or
+ * `@tanstack/ai-mcp`, and into a hand-built
+ * `StreamableHTTPClientTransport`.
+ *
  * @param connector Vercel Connect connector UID (e.g. `oauth/linear`)
  *   or opaque connector id.
  * @param params Token request parameters — always specify a
@@ -96,4 +306,4 @@ export declare class ConsentRequiredError extends Error {
  *   security semantics.
  * @param options Optional adapter behavior overrides.
  */
-export declare function connectAuthProvider(connector: string, params: ConnectTokenParams, options?: ConnectAuthProviderOptions): OAuthClientProvider;
+export declare function connectAuthProvider(connector: string, params: ConnectTokenParams, options?: ConnectAuthProviderOptions): ConnectOAuthClientProvider;

package/dist/mcp/connect-auth-provider.js

@@ -1,11 +1,16 @@
 import { startAuthorization } from '../authorization.js';
-import { ConnectorInstallationRequiredError, UserAuthorizationRequiredError, getTokenResponse, } from '../token.js';
+import { UserAuthorizationRequiredError, getTokenResponse, } from '../token.js';
 /**
  * Thrown by the {@link connectAuthProvider} default
  * `onConsentRequired` handler when the user has no Connect grant for
  * the configured subject. Catch at the boundary
  * (`route handler` / `streamText` call site) and redirect to
  * `error.url`.
+ *
+ * MCP client libraries often wrap connection failures in their own
+ * error type (for example `@tanstack/ai-mcp`'s `MCPConnectionError`)
+ * with this error on `cause`. Use {@link getConsentChallenge} to find
+ * it anywhere in a `cause` chain.
  */
 export class ConsentRequiredError extends Error {
     name = 'ConsentRequiredError';
@@ -27,17 +32,144 @@ export class ConsentRequiredError extends Error {
         this.expiresAt = challenge.expiresAt;
     }
 }
+/**
+ * Type guard for {@link ConsentRequiredError}. Only matches the error
+ * itself; use {@link getConsentChallenge} to look through wrapping
+ * errors' `cause` chains.
+ */
+export function isConsentRequiredError(err) {
+    return err instanceof ConsentRequiredError;
+}
+/** Upper bound on `cause` hops walked by {@link getConsentChallenge}. */
+const MAX_CAUSE_DEPTH = 16;
+/**
+ * Finds a Connect consent challenge in `err` or anywhere along its
+ * `cause` chain and returns it, or `undefined` when none is present.
+ *
+ * MCP clients typically raise the adapter's {@link ConsentRequiredError}
+ * from inside their connect / tool-call machinery and re-wrap it —
+ * `@tanstack/ai-mcp`'s `createMCPClient` throws `MCPConnectionError`
+ * with the original error on `cause`. This helper lets a route handler
+ * branch on consent without knowing the wrapping shape:
+ *
+ * ```ts
+ * } catch (err) {
+ *   const challenge = getConsentChallenge(err);
+ *   if (challenge) return Response.redirect(challenge.url);
+ *   throw err;
+ * }
+ * ```
+ *
+ * Matching is by `instanceof` first, then structurally on
+ * `name === 'ConsentRequiredError'` so a duplicated copy of
+ * `@vercel/connect` in the dependency graph is still recognized.
+ */
+export function getConsentChallenge(err) {
+    let current = err;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth++) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        const challenge = toConsentChallenge(current);
+        if (challenge) {
+            return challenge;
+        }
+        current = current.cause;
+    }
+    return undefined;
+}
+function toConsentChallenge(candidate) {
+    if (candidate instanceof ConsentRequiredError) {
+        return {
+            connector: candidate.connector,
+            subject: candidate.subject,
+            url: candidate.url,
+            request: candidate.request,
+            verifier: candidate.verifier,
+            deviceCode: candidate.deviceCode,
+            expiresAt: candidate.expiresAt,
+        };
+    }
+    const value = candidate;
+    if (value.name === 'ConsentRequiredError' &&
+        typeof value.url === 'string' &&
+        typeof value.connector === 'string' &&
+        typeof value.request === 'string' &&
+        typeof value.verifier === 'string' &&
+        value.subject !== undefined) {
+        return {
+            connector: value.connector,
+            subject: value.subject,
+            url: value.url,
+            request: value.request,
+            verifier: value.verifier,
+            deviceCode: value.deviceCode,
+            expiresAt: value.expiresAt,
+        };
+    }
+    return undefined;
+}
+/**
+ * Value reported by `OAuthClientProvider.redirectUrl` when no
+ * {@link ConnectAuthProviderOptions.redirectUrl} is configured.
+ *
+ * Connect's hosted consent flow owns the real post-consent redirect
+ * (the connector's server-side registered redirect), so this URL is
+ * never followed. It exists only so the official
+ * `@modelcontextprotocol/sdk` `auth()` orchestrator — which treats a
+ * falsy `redirectUrl` as "run the non-interactive client-credentials
+ * flow" — stays on the interactive path and reaches
+ * `redirectToAuthorization`.
+ */
+export const CONNECT_MANAGED_REDIRECT_URL = 'https://connect.vercel.com/';
+/**
+ * Discovery state returned by `OAuthClientProvider.discoveryState()`.
+ *
+ * The official `@modelcontextprotocol/sdk` `auth()` orchestrator runs
+ * RFC 9728 discovery on every 401: it fetches the URL named by the MCP
+ * server's `WWW-Authenticate: Bearer resource_metadata="…"` parameter,
+ * then the authorization-server metadata at whatever host that
+ * document names. Neither URL is validated, so a compromised MCP
+ * server can point them at private-network addresses (blind SSRF).
+ * When a provider returns a complete cached state the orchestrator
+ * skips every discovery fetch, so this adapter returns one that names
+ * Connect as the authorization server. None of these endpoints is
+ * ever called: `redirectToAuthorization` discards the authorization
+ * URL the SDK builds from them in favour of Connect's own consent URL,
+ * and the token endpoint is only used for refresh and code exchange,
+ * both of which Connect performs server-side.
+ */
+export const CONNECT_DISCOVERY_STATE = {
+    authorizationServerUrl: 'https://connect.vercel.com',
+    authorizationServerMetadata: {
+        issuer: 'https://connect.vercel.com',
+        authorization_endpoint: 'https://connect.vercel.com/',
+        token_endpoint: 'https://connect.vercel.com/',
+        response_types_supported: ['code'],
+        code_challenge_methods_supported: ['S256'],
+    },
+    resourceMetadata: {
+        resource: 'https://connect.vercel.com/',
+        authorization_servers: ['https://connect.vercel.com'],
+    },
+};
 const EMPTY_CLIENT_METADATA = {
     redirect_uris: [],
 };
 /**
- * Builds an MCP-spec {@link OAuthClientProvider} backed by Vercel
+ * Builds an MCP-spec `OAuthClientProvider` backed by Vercel
  * Connect. The returned object delegates `tokens()` to
  * {@link getTokenResponse} and `redirectToAuthorization` to
  * {@link startAuthorization}. Connect owns client registration, PKCE,
  * state, and the callback handshake server-side, so most of the
  * `OAuthClientProvider` surface is intentionally a no-op.
  *
+ * The returned object satisfies both `@ai-sdk/mcp`'s and the official
+ * `@modelcontextprotocol/sdk`'s `OAuthClientProvider` interfaces, so
+ * it plugs into `createMCPClient` from either `@ai-sdk/mcp` or
+ * `@tanstack/ai-mcp`, and into a hand-built
+ * `StreamableHTTPClientTransport`.
+ *
  * @param connector Vercel Connect connector UID (e.g. `oauth/linear`)
  *   or opaque connector id.
  * @param params Token request parameters — always specify a
@@ -47,7 +179,8 @@ const EMPTY_CLIENT_METADATA = {
  * @param options Optional adapter behavior overrides.
  */
 export function connectAuthProvider(connector, params, options) {
-    const redirectUrl = options?.redirectUrl ?? '';
+    const configuredRedirectUrl = options?.redirectUrl;
+    const consentMode = options?.consent ?? 'transport';
     async function resolveVercelToken() {
         const { vercelToken } = options ?? {};
         if (typeof vercelToken === 'function') {
@@ -55,6 +188,27 @@ export function connectAuthProvider(connector, params, options) {
         }
         return vercelToken;
     }
+    /** Asks Connect for a consent URL for the configured subject. */
+    async function mintConsentChallenge() {
+        const vercelToken = await resolveVercelToken();
+        const response = await startAuthorization(connector, params, {
+            ...(vercelToken !== undefined && { vercelToken }),
+            // Forward the post-consent return URL so the user lands back
+            // in the app. Omitted => Connect uses the connector's
+            // registered redirect.
+            ...(configuredRedirectUrl && { callbackUrl: configuredRedirectUrl }),
+            ...(options?.deviceCode && { deviceCode: true }),
+        });
+        return {
+            connector,
+            subject: params.subject,
+            url: response.url,
+            request: response.request,
+            verifier: response.verifier,
+            deviceCode: response.deviceCode,
+            expiresAt: response.expiresAt,
+        };
+    }
     return {
         async tokens() {
             try {
@@ -68,42 +222,34 @@ export function connectAuthProvider(connector, params, options) {
                 };
             }
             catch (err) {
-                if (err instanceof UserAuthorizationRequiredError) {
+                if (!(err instanceof UserAuthorizationRequiredError)) {
+                    // ConnectorInstallationRequiredError (a configuration
+                    // problem, not a per-user consent issue) and everything
+                    // else propagate as-is rather than masquerading as a
+                    // consent challenge.
+                    throw err;
+                }
+                if (consentMode === 'transport') {
                     // Returning undefined lets the MCP transport's auth()
                     // orchestrator trigger redirectToAuthorization below,
                     // where we surface the Connect consent URL.
                     return undefined;
                 }
-                if (err instanceof ConnectorInstallationRequiredError) {
-                    // Configuration problem, not a per-user issue. Surface
-                    // immediately rather than masking as a consent challenge.
-                    throw err;
-                }
-                throw err;
+                // Eager: surface Connect's consent URL right here, before
+                // the transport sends anything. Connect is authoritative
+                // about the missing grant, so there is nothing to gain from
+                // letting the server 401 first. The callback runs for side
+                // effects, then the request is aborted unconditionally.
+                const challenge = await mintConsentChallenge();
+                await options?.onConsentRequired?.(challenge);
+                throw new ConsentRequiredError(challenge);
             }
         },
         async redirectToAuthorization(_authorizationUrl) {
             // The URL argument is the MCP server's discovered authorization
             // endpoint. We ignore it — Connect has its own consent URL
             // backed by the connector's registered OAuth client.
-            const vercelToken = await resolveVercelToken();
-            const response = await startAuthorization(connector, params, {
-                ...(vercelToken !== undefined && { vercelToken }),
-                // Forward the post-consent return URL so the user lands back
-                // in the app. Falsy (the default empty string) => Connect uses
-                // the connector's registered redirect.
-                ...(redirectUrl && { callbackUrl: redirectUrl }),
-                ...(options?.deviceCode && { deviceCode: true }),
-            });
-            const challenge = {
-                connector,
-                subject: params.subject,
-                url: response.url,
-                request: response.request,
-                verifier: response.verifier,
-                deviceCode: response.deviceCode,
-                expiresAt: response.expiresAt,
-            };
+            const challenge = await mintConsentChallenge();
             if (options?.onConsentRequired) {
                 await options.onConsentRequired(challenge);
                 return;
@@ -126,10 +272,13 @@ export function connectAuthProvider(connector, params, options) {
             throw new Error('@vercel/connect: OAuthClientProvider.codeVerifier() is unsupported. Vercel Connect owns the PKCE flow server-side; this method should never be invoked by a correctly-configured MCP transport.');
         },
         get redirectUrl() {
-            // Same value forwarded to Connect as the post-consent return
-            // URL. Surfaced here to satisfy the OAuthClientProvider
-            // contract; the standard flow that reads it is never triggered.
-            return redirectUrl;
+            // The configured post-consent return URL, or a non-empty
+            // placeholder. Must never be falsy: the official MCP SDK's
+            // auth() reads `!provider.redirectUrl` as "non-interactive
+            // flow" and would try a client-credentials token request
+            // against the third-party authorization server instead of
+            // calling redirectToAuthorization.
+            return configuredRedirectUrl || CONNECT_MANAGED_REDIRECT_URL;
         },
         get clientMetadata() {
             // Returned only during dynamic client registration, which we
@@ -144,5 +293,21 @@ export function connectAuthProvider(connector, params, options) {
             // returning a synthetic value.
             return { client_id: connector };
         },
+        discoveryState() {
+            // Pre-empts RFC 9728 discovery so the official SDK never fetches
+            // URLs chosen by the MCP server's WWW-Authenticate header.
+            return CONNECT_DISCOVERY_STATE;
+        },
+        saveDiscoveryState(_state) {
+            // No-op: the state above is fixed and never needs persisting.
+        },
+        async validateResourceURL() {
+            // Bypasses the SDK's check that the synthetic resource metadata
+            // matches the MCP server URL (it would throw before reaching
+            // redirectToAuthorization). Returning undefined also omits the
+            // RFC 8707 `resource` parameter from the authorization URL the
+            // SDK builds, which is discarded anyway.
+            return undefined;
+        },
     };
 }

package/dist/mcp/index.d.ts

@@ -9,9 +9,12 @@
  * `@vercel/connect/ai-sdk` instead; that subpath re-exports from
  * here.
  *
- * `@ai-sdk/mcp` is an optional peer dependency: importing this
- * entrypoint requires it to be installed in the consumer project,
- * but the rest of `@vercel/connect` works without it.
+ * This entrypoint has no runtime or type import of `@ai-sdk/mcp` or
+ * `@modelcontextprotocol/sdk`; `connectAuthProvider` returns the
+ * self-contained `ConnectOAuthClientProvider`, which the test suite
+ * asserts is assignable to both SDKs' `OAuthClientProvider`. Both
+ * packages are declared as optional peers only to signal the tested
+ * version ranges.
  *
  * ```ts
  * import { createMCPClient } from '@ai-sdk/mcp';
@@ -29,5 +32,5 @@
  * });
  * ```
  */
-export { connectAuthProvider, ConsentRequiredError, type ConnectAuthProviderOptions, type ConsentChallenge, } from './connect-auth-provider.js';
+export { CONNECT_DISCOVERY_STATE, CONNECT_MANAGED_REDIRECT_URL, connectAuthProvider, ConsentRequiredError, getConsentChallenge, isConsentRequiredError, type ConnectAuthProviderOptions, type ConnectConsentMode, type ConnectOAuthClientInformation, type ConnectOAuthClientMetadata, type ConnectOAuthClientProvider, type ConnectOAuthDiscoveryState, type ConnectOAuthTokens, type ConsentChallenge, } from './connect-auth-provider.js';
 export { ConnectError, ConnectorInstallationRequiredError, NoValidTokenError, UserAuthorizationRequiredError, type ConnectErrorOptions, type ConnectTokenExchangeSubject, type ConnectTokenParams, type ConnectTokenSubject, type ConnectVendorErrorPayload, } from '../token.js';

package/dist/mcp/index.js

@@ -9,9 +9,12 @@
  * `@vercel/connect/ai-sdk` instead; that subpath re-exports from
  * here.
  *
- * `@ai-sdk/mcp` is an optional peer dependency: importing this
- * entrypoint requires it to be installed in the consumer project,
- * but the rest of `@vercel/connect` works without it.
+ * This entrypoint has no runtime or type import of `@ai-sdk/mcp` or
+ * `@modelcontextprotocol/sdk`; `connectAuthProvider` returns the
+ * self-contained `ConnectOAuthClientProvider`, which the test suite
+ * asserts is assignable to both SDKs' `OAuthClientProvider`. Both
+ * packages are declared as optional peers only to signal the tested
+ * version ranges.
  *
  * ```ts
  * import { createMCPClient } from '@ai-sdk/mcp';
@@ -29,5 +32,5 @@
  * });
  * ```
  */
-export { connectAuthProvider, ConsentRequiredError, } from './connect-auth-provider.js';
+export { CONNECT_DISCOVERY_STATE, CONNECT_MANAGED_REDIRECT_URL, connectAuthProvider, ConsentRequiredError, getConsentChallenge, isConsentRequiredError, } from './connect-auth-provider.js';
 export { ConnectError, ConnectorInstallationRequiredError, NoValidTokenError, UserAuthorizationRequiredError, } from '../token.js';

package/dist/tanstack-ai/index.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Public surface of the `@vercel/connect/tanstack-ai` subpath.
+ *
+ * [TanStack AI](https://tanstack.com/ai)'s MCP client
+ * (`@tanstack/ai-mcp`) is built directly on the official
+ * `@modelcontextprotocol/sdk` transports and accepts any MCP-spec
+ * `OAuthClientProvider` on its `http` / `sse` transport config. This
+ * subpath adds one TanStack-shaped helper on top of the shared Connect
+ * adapter:
+ *
+ * - {@link connectMCPTransport} builds the whole
+ *   `createMCPClient({ transport })` config and picks the consent mode
+ *   per transport type: `'eager'` for Streamable HTTP, `'transport'`
+ *   for SSE. Eager consent makes `tokens()` raise the Connect consent
+ *   challenge before the first request (the MCP `initialize`
+ *   handshake) leaves the process, so a missing grant always fails at
+ *   the route boundary, never mid-run inside a tool call where
+ *   TanStack's chat loop would swallow it into an
+ *   `Error executing tool: …` result the model sees instead of the
+ *   user. Eager mode is unsafe on SSE (see `ConnectConsentMode`), so
+ *   SSE configs keep the MCP-spec 401 flow.
+ * - {@link getConsentChallenge} looks through `MCPConnectionError`
+ *   (and any other wrapper) `cause` chains so the route handler can
+ *   redirect without knowing the wrapping shape.
+ *
+ * `connectAuthProvider` is re-exported unchanged from
+ * `@vercel/connect/mcp` for callers who build the transport config
+ * themselves; pass `consent: 'eager'` explicitly only with
+ * `type: 'http'`.
+ *
+ * Nothing here imports `@tanstack/ai`, `@tanstack/ai-mcp`,
+ * `@ai-sdk/mcp`, or `@modelcontextprotocol/sdk`: the returned provider
+ * is the self-contained `ConnectOAuthClientProvider`, which the test
+ * suite asserts is assignable to both SDKs' `OAuthClientProvider`
+ * interfaces, and the transport config types below mirror
+ * `@tanstack/ai-mcp`'s structurally. See
+ * `docs/tanstack-ai-mcp-integration.md`.
+ *
+ * ```ts
+ * import { chat, toServerSentEventsResponse } from '@tanstack/ai';
+ * import { createMCPClient } from '@tanstack/ai-mcp';
+ * import {
+ *   connectMCPTransport,
+ *   getConsentChallenge,
+ * } from '@vercel/connect/tanstack-ai';
+ *
+ * export async function POST(request: Request) {
+ *   try {
+ *     const linear = await createMCPClient({
+ *       transport: connectMCPTransport(
+ *         { type: 'http', url: 'https://mcp.linear.app/mcp' },
+ *         'oauth/linear',
+ *         { subject: { type: 'user', id: userId } },
+ *         { redirectUrl: 'https://app.example.com/integrations' }
+ *       ),
+ *     });
+ *     const stream = chat({ adapter, messages, mcp: { clients: [linear] } });
+ *     return toServerSentEventsResponse(stream);
+ *   } catch (err) {
+ *     const challenge = getConsentChallenge(err);
+ *     if (challenge) return Response.redirect(challenge.url);
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+import { type ConnectAuthProviderOptions, type ConnectOAuthClientProvider } from '../mcp/connect-auth-provider.js';
+import type { ConnectTokenParams } from '../token.js';
+/**
+ * The network transport configs accepted by `@tanstack/ai-mcp`'s
+ * `createMCPClient` / `createMCPClients`, mirrored structurally so this
+ * module needs no TanStack import. `type: 'http'` is Streamable HTTP
+ * (preferred, edge-safe); `type: 'sse'` is the legacy SSE transport.
+ */
+export interface ConnectMCPTransportConfig {
+    readonly type: 'http' | 'sse';
+    readonly url: string;
+    /** Extra headers sent with every request (e.g. deployment-protection bypass). */
+    readonly headers?: Record<string, string>;
+    /** Bring-your-own `fetch`, forwarded to the SDK transport. */
+    readonly fetch?: typeof fetch;
+}
+/**
+ * {@link ConnectMCPTransportConfig} with the Connect provider attached
+ * and, unless `redirect: 'follow'` was requested, a `fetch` that refuses
+ * HTTP redirects.
+ */
+export type ConnectMCPTransport<T extends ConnectMCPTransportConfig> = T & {
+    readonly fetch?: typeof fetch;
+    readonly authProvider: ConnectOAuthClientProvider;
+};
+/** Options accepted by {@link connectMCPTransport}. */
+export interface ConnectMCPTransportOptions extends ConnectAuthProviderOptions {
+    /**
+     * How HTTP redirects from the MCP server are handled, for every
+     * request the transport makes (`initialize`, tool calls, the SSE
+     * stream, session teardown).
+     *
+     * - `'error'` (default): the request fails instead of following the
+     *   redirect. The official SDK otherwise uses native fetch's
+     *   `'follow'`, which lets a compromised MCP server bounce the
+     *   application to private-network URLs (a blind GET; the Fetch
+     *   spec strips `Authorization` on cross-origin redirects). This
+     *   matches `@ai-sdk/mcp`, whose transport also defaults to
+     *   `'error'`.
+     * - `'follow'`: native behavior, for an endpoint that legitimately
+     *   redirects. `config.fetch` is then passed through untouched.
+     *
+     * The policy is applied by wrapping `config.fetch` (or the global
+     * `fetch`, resolved at call time), so a caller-supplied guarded
+     * fetch keeps its own protections. On `type: 'http'` the wrapper
+     * passes fetch's own `redirect: 'error'`, which rejects the request.
+     * On `type: 'sse'` it passes `redirect: 'manual'` instead: the
+     * official SDK's `SSEClientTransport` runs `fetch` inside an
+     * EventSource that treats any rejection as a retryable network
+     * error and reconnects every few seconds with no handle left for
+     * the caller to close, whereas a non-200 response is terminal. With
+     * `'manual'` the 3xx comes back as that terminal response, so the
+     * connection fails once and stays closed.
+     */
+    readonly redirect?: 'follow' | 'error';
+}
+/**
+ * Builds a `@tanstack/ai-mcp` transport config whose `authProvider` is
+ * backed by Vercel Connect, choosing the consent mode that is safe for
+ * the transport: `'eager'` for `type: 'http'` (consent surfaces inside
+ * `createMCPClient`, before any request reaches the server) and
+ * `'transport'` for `type: 'sse'` (the MCP-spec 401 flow; eager mode
+ * would be flattened into a retry loop by the SSE EventSource). An
+ * explicit `options.consent` overrides the choice — only do that with
+ * `type: 'http'`.
+ *
+ * `headers` on `config` are passed through untouched. `fetch` is
+ * wrapped to refuse HTTP redirects unless `options.redirect` is
+ * `'follow'`; see {@link ConnectMCPTransportOptions.redirect}.
+ *
+ * @param config TanStack transport config without `authProvider`.
+ * @param connector Vercel Connect connector UID (e.g. `oauth/linear`)
+ *   or opaque connector id.
+ * @param params Token request parameters — always specify a `subject`.
+ * @param options Optional adapter and transport behavior overrides.
+ */
+export declare function connectMCPTransport<T extends ConnectMCPTransportConfig>(config: T, connector: string, params: ConnectTokenParams, options?: ConnectMCPTransportOptions): ConnectMCPTransport<T>;
+export { CONNECT_DISCOVERY_STATE, CONNECT_MANAGED_REDIRECT_URL, connectAuthProvider, ConsentRequiredError, getConsentChallenge, isConsentRequiredError, type ConnectAuthProviderOptions, type ConnectConsentMode, type ConnectOAuthClientInformation, type ConnectOAuthClientMetadata, type ConnectOAuthClientProvider, type ConnectOAuthDiscoveryState, type ConnectOAuthTokens, type ConsentChallenge, } from '../mcp/connect-auth-provider.js';
+export { ConnectError, ConnectorInstallationRequiredError, NoValidTokenError, UserAuthorizationRequiredError, type ConnectErrorOptions, type ConnectTokenExchangeSubject, type ConnectTokenParams, type ConnectTokenSubject, type ConnectVendorErrorPayload, } from '../token.js';

package/dist/tanstack-ai/index.js

@@ -0,0 +1,120 @@
+/**
+ * Public surface of the `@vercel/connect/tanstack-ai` subpath.
+ *
+ * [TanStack AI](https://tanstack.com/ai)'s MCP client
+ * (`@tanstack/ai-mcp`) is built directly on the official
+ * `@modelcontextprotocol/sdk` transports and accepts any MCP-spec
+ * `OAuthClientProvider` on its `http` / `sse` transport config. This
+ * subpath adds one TanStack-shaped helper on top of the shared Connect
+ * adapter:
+ *
+ * - {@link connectMCPTransport} builds the whole
+ *   `createMCPClient({ transport })` config and picks the consent mode
+ *   per transport type: `'eager'` for Streamable HTTP, `'transport'`
+ *   for SSE. Eager consent makes `tokens()` raise the Connect consent
+ *   challenge before the first request (the MCP `initialize`
+ *   handshake) leaves the process, so a missing grant always fails at
+ *   the route boundary, never mid-run inside a tool call where
+ *   TanStack's chat loop would swallow it into an
+ *   `Error executing tool: …` result the model sees instead of the
+ *   user. Eager mode is unsafe on SSE (see `ConnectConsentMode`), so
+ *   SSE configs keep the MCP-spec 401 flow.
+ * - {@link getConsentChallenge} looks through `MCPConnectionError`
+ *   (and any other wrapper) `cause` chains so the route handler can
+ *   redirect without knowing the wrapping shape.
+ *
+ * `connectAuthProvider` is re-exported unchanged from
+ * `@vercel/connect/mcp` for callers who build the transport config
+ * themselves; pass `consent: 'eager'` explicitly only with
+ * `type: 'http'`.
+ *
+ * Nothing here imports `@tanstack/ai`, `@tanstack/ai-mcp`,
+ * `@ai-sdk/mcp`, or `@modelcontextprotocol/sdk`: the returned provider
+ * is the self-contained `ConnectOAuthClientProvider`, which the test
+ * suite asserts is assignable to both SDKs' `OAuthClientProvider`
+ * interfaces, and the transport config types below mirror
+ * `@tanstack/ai-mcp`'s structurally. See
+ * `docs/tanstack-ai-mcp-integration.md`.
+ *
+ * ```ts
+ * import { chat, toServerSentEventsResponse } from '@tanstack/ai';
+ * import { createMCPClient } from '@tanstack/ai-mcp';
+ * import {
+ *   connectMCPTransport,
+ *   getConsentChallenge,
+ * } from '@vercel/connect/tanstack-ai';
+ *
+ * export async function POST(request: Request) {
+ *   try {
+ *     const linear = await createMCPClient({
+ *       transport: connectMCPTransport(
+ *         { type: 'http', url: 'https://mcp.linear.app/mcp' },
+ *         'oauth/linear',
+ *         { subject: { type: 'user', id: userId } },
+ *         { redirectUrl: 'https://app.example.com/integrations' }
+ *       ),
+ *     });
+ *     const stream = chat({ adapter, messages, mcp: { clients: [linear] } });
+ *     return toServerSentEventsResponse(stream);
+ *   } catch (err) {
+ *     const challenge = getConsentChallenge(err);
+ *     if (challenge) return Response.redirect(challenge.url);
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+import { connectAuthProvider, } from '../mcp/connect-auth-provider.js';
+/**
+ * Builds a `@tanstack/ai-mcp` transport config whose `authProvider` is
+ * backed by Vercel Connect, choosing the consent mode that is safe for
+ * the transport: `'eager'` for `type: 'http'` (consent surfaces inside
+ * `createMCPClient`, before any request reaches the server) and
+ * `'transport'` for `type: 'sse'` (the MCP-spec 401 flow; eager mode
+ * would be flattened into a retry loop by the SSE EventSource). An
+ * explicit `options.consent` overrides the choice — only do that with
+ * `type: 'http'`.
+ *
+ * `headers` on `config` are passed through untouched. `fetch` is
+ * wrapped to refuse HTTP redirects unless `options.redirect` is
+ * `'follow'`; see {@link ConnectMCPTransportOptions.redirect}.
+ *
+ * @param config TanStack transport config without `authProvider`.
+ * @param connector Vercel Connect connector UID (e.g. `oauth/linear`)
+ *   or opaque connector id.
+ * @param params Token request parameters — always specify a `subject`.
+ * @param options Optional adapter and transport behavior overrides.
+ */
+export function connectMCPTransport(config, connector, params, options) {
+    const { redirect = 'error', ...providerOptions } = options ?? {};
+    const consent = providerOptions.consent ?? (config.type === 'http' ? 'eager' : 'transport');
+    return {
+        ...config,
+        ...(redirect === 'error' && {
+            fetch: withoutRedirects(config.fetch, config.type),
+        }),
+        authProvider: connectAuthProvider(connector, params, {
+            ...providerOptions,
+            consent,
+        }),
+    };
+}
+/**
+ * Wraps `fetchImpl` (or the global `fetch`, looked up per call so
+ * request-scoped fetch shims keep working) so no request follows a
+ * server-chosen `Location`.
+ *
+ * Streamable HTTP gets `redirect: 'error'`: fetch rejects the 3xx with
+ * a `TypeError` and the SDK surfaces a connection error. SSE gets
+ * `redirect: 'manual'`: fetch resolves with the 3xx itself (status
+ * `303`, or `0` on runtimes that return an opaque redirect), which the
+ * SDK's EventSource treats as a terminal non-200 response. A rejection
+ * there would instead be treated as a transient network error and
+ * retried on a timer that outlives the failed `createMCPClient` call.
+ */
+function withoutRedirects(fetchImpl, transportType) {
+    const redirect = transportType === 'sse' ? 'manual' : 'error';
+    return (input, init) => (fetchImpl ?? fetch)(input, { ...init, redirect });
+}
+export { CONNECT_DISCOVERY_STATE, CONNECT_MANAGED_REDIRECT_URL, connectAuthProvider, ConsentRequiredError, getConsentChallenge, isConsentRequiredError, } from '../mcp/connect-auth-provider.js';
+export { ConnectError, ConnectorInstallationRequiredError, NoValidTokenError, UserAuthorizationRequiredError, } from '../token.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/connect",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {
@@ -36,6 +36,10 @@
     "./ai-sdk": {
       "types": "./dist/ai-sdk/index.d.ts",
       "default": "./dist/ai-sdk/index.js"
+    },
+    "./tanstack-ai": {
+      "types": "./dist/tanstack-ai/index.d.ts",
+      "default": "./dist/tanstack-ai/index.js"
     }
   },
   "files": [
@@ -48,9 +52,10 @@
     "@ai-sdk/mcp": "^1 || ^2",
     "@auth/core": ">=0.37.0",
     "@chat-adapter/slack": "^4.0.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "ai": "^6 || ^7.0.0-beta.0",
     "better-auth": ">=1.5.0",
-    "eve": ">=0.13.7"
+    "eve": ">=0.39.1"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/mcp": {
@@ -62,6 +67,9 @@
     "@chat-adapter/slack": {
       "optional": true
     },
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
     "ai": {
       "optional": true
     },
@@ -76,6 +84,8 @@
     "@ai-sdk/mcp": "2.0.0-beta.37",
     "@auth/core": "0.37.4",
     "@chat-adapter/slack": "4.31.0",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@tanstack/ai-mcp": "0.3.10",
     "ai": "7.0.26",
     "better-auth": "1.5.5",
     "eve": "0.39.1",