@adcp/sdk 5.23.0

package/dist/lib/server/auth-signature.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignatureAsAuthenticator = verifySignatureAsAuthenticator;
+exports.requireSignatureWhenPresent = requireSignatureWhenPresent;
+exports.requireAuthenticatedOrSigned = requireAuthenticatedOrSigned;
+exports.mcpToolNameResolver = mcpToolNameResolver;
+const errors_1 = require("../signing/errors");
+const replay_1 = require("../signing/replay");
+const revocation_1 = require("../signing/revocation");
+const verifier_1 = require("../signing/verifier");
+const auth_1 = require("./auth");
+/**
+ * Build an {@link Authenticator} that verifies an RFC 9421 request signature.
+ *
+ * Behavior matrix:
+ * - No `Signature-Input` header → returns `null` (fall through to next authenticator).
+ * - Signature present and valid → returns {@link AuthPrincipal}.
+ * - Signature present but invalid → throws {@link AuthError} (surfaces as 401).
+ *
+ * Populates `req.verifiedSigner` on success so downstream handlers see the
+ * same side-channel state as the Express-shaped middleware.
+ */
+function verifySignatureAsAuthenticator(options) {
+    // Instantiate defaults once at wire-up time so every request on this
+    // authenticator shares the same replay/revocation state — lazy
+    // per-request construction would defeat replay detection entirely.
+    const replayStore = options.replayStore ?? new replay_1.InMemoryReplayStore();
+    const revocationStore = options.revocationStore ?? new revocation_1.InMemoryRevocationStore();
+    const authenticator = async (req) => {
+        if (!hasSignatureHeader(req))
+            return null;
+        const body = req.rawBody ?? '';
+        const url = options.getUrl ? options.getUrl(req) : defaultUrl(req);
+        const requestLike = {
+            method: req.method ?? 'GET',
+            url,
+            headers: req.headers,
+            body,
+        };
+        let result;
+        try {
+            result = await (0, verifier_1.verifyRequestSignature)(requestLike, {
+                capability: options.capability,
+                jwks: options.jwks,
+                replayStore,
+                revocationStore,
+                now: options.now,
+                operation: options.resolveOperation(req),
+                agentUrlForKeyid: options.agentUrlForKeyid,
+            });
+        }
+        catch (err) {
+            if (err instanceof errors_1.RequestSignatureError) {
+                throw new auth_1.AuthError(`Signature rejected (${err.code}).`, { cause: err });
+            }
+            throw new auth_1.AuthError('Signature verification failed.', { cause: err });
+        }
+        if (result.status !== 'verified') {
+            // Unreachable: `hasSignatureHeader` already gated entry, so the verifier
+            // either throws (missing-pair / invalid / replayed / etc.) or returns
+            // `status: 'verified'`. Fail loud if the verifier contract changes —
+            // silently returning `null` would fall through to the next authenticator
+            // as if no signature were present, breaking the auth invariant.
+            throw new auth_1.AuthError('Signature verification returned unexpected status.', {
+                cause: new Error(`verifier returned status="${result.status}"`),
+            });
+        }
+        // keyid is buyer-controlled (JWK spec places no charset restriction on
+        // `kid`). Bound it to a URL-safe shape — explicitly excluding `:` — before
+        // interpolating into the principal string, so downstream tenant-isolation
+        // checks that split `signing:<keyid>` on the first `:` can't be confused
+        // by a colon embedded in the signer's key id.
+        if (!SAFE_KEYID.test(result.keyid)) {
+            throw new auth_1.AuthError('Signature key id contains unsupported characters.', {
+                cause: new Error(`keyid=${JSON.stringify(result.keyid)} fails /^[A-Za-z0-9._-]{1,256}$/`),
+            });
+        }
+        const signer = {
+            keyid: result.keyid,
+            verified_at: result.verified_at,
+            ...(result.agent_url !== undefined ? { agent_url: result.agent_url } : {}),
+        };
+        const principal = options.makePrincipal
+            ? options.makePrincipal(signer)
+            : {
+                principal: `signing:${signer.keyid}`,
+                claims: {
+                    signature: {
+                        keyid: signer.keyid,
+                        verified_at: signer.verified_at,
+                        ...(signer.agent_url !== undefined ? { agent_url: signer.agent_url } : {}),
+                    },
+                },
+            };
+        // Write the side-channel state only after the principal is fully built so
+        // a throw from `makePrincipal` leaves `req.verifiedSigner` unset — the
+        // request didn't actually authenticate, downstream handlers must not see
+        // a stale "verified" marker on a rejected request.
+        req.verifiedSigner = signer;
+        return principal;
+    };
+    return (0, auth_1.tagAuthenticatorNeedsRawBody)(authenticator);
+}
+/**
+ * Compose a signature authenticator with a fallback under presence-gated
+ * semantics: if the incoming request declares a `Signature-Input` header,
+ * the signature authenticator is the ONLY path — its result (principal,
+ * `null`, or thrown {@link AuthError}) is the final outcome and the fallback
+ * never runs. Without `Signature-Input`, the fallback handles the request.
+ *
+ * Pass {@link RequireSignatureWhenPresentOptions.requiredFor} to enforce
+ * `required_for` for the no-signature path: when the fallback produces no
+ * principal on an operation that MUST be signed, the gate throws an
+ * {@link AuthError} whose cause is a {@link RequestSignatureError} with
+ * code `request_signature_required` — `serve()` maps that into a 401
+ * with the RFC 9421 `WWW-Authenticate: Signature` challenge.
+ */
+function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {}) {
+    const requiredFor = new Set(options.requiredFor ?? []);
+    const resolveOperation = options.resolveOperation;
+    const combined = async (req) => {
+        if (hasSignatureHeader(req)) {
+            const result = await signatureAuth(req);
+            if (result === null) {
+                // A signature was declared but the sig authenticator didn't recognize
+                // it. Falling through to the fallback would re-open the bypass the
+                // presence gate exists to prevent — fail closed.
+                throw new auth_1.AuthError('Signature declared but not recognized.');
+            }
+            return result;
+        }
+        // Catch the fallback's throw so the `requiredFor` pre-check can run
+        // regardless of fallback outcome. Without this, a caller presenting
+        // a bad bearer on a required-for op triggers `anyOf` to throw an
+        // `AuthError` with Bearer semantics, propagating past the pre-check
+        // and producing `WWW-Authenticate: Bearer` — the conformance grader
+        // reads the wrong error code on the exact vector this helper
+        // exists to close.
+        let fallbackResult = null;
+        let fallbackError;
+        let fallbackThrew = false;
+        try {
+            fallbackResult = await fallbackAuth(req);
+        }
+        catch (err) {
+            fallbackThrew = true;
+            fallbackError = err;
+        }
+        // Valid fallback principal short-circuits everything: this is the
+        // documented "bearer bypass on required_for" semantic (per adcp#2586 —
+        // a valid credential is sufficient even when signing is required for
+        // unauthenticated callers). Return before the pre-check so the
+        // control flow below only runs on `fallbackResult === null`.
+        if (fallbackResult !== null)
+            return fallbackResult;
+        // `requiredFor` pre-check: when the op requires a signature AND no
+        // signature was presented AND no valid fallback credential,
+        // surface `request_signature_required` regardless of whether the
+        // fallback threw (bad bearer) or returned null (no creds).
+        if (requiredFor.size > 0 && resolveOperation) {
+            const operation = resolveOperation(req);
+            if (operation && requiredFor.has(operation)) {
+                throw new auth_1.AuthError(`Signature required for ${operation}.`, {
+                    cause: new errors_1.RequestSignatureError('request_signature_required', 0, `Operation ${operation} requires an RFC 9421 request signature when no other credentials are presented.`),
+                });
+            }
+        }
+        // Op not in requiredFor (or no resolver): rethrow the fallback's
+        // original error so the 401 carries the fallback's challenge
+        // (Bearer for bad-bearer, invalid_token for no-creds).
+        if (fallbackThrew)
+            throw fallbackError;
+        return null;
+    };
+    const anyChildNeedsRawBody = (0, auth_1.authenticatorNeedsRawBody)(signatureAuth) || (0, auth_1.authenticatorNeedsRawBody)(fallbackAuth);
+    // When `resolveOperation` is wired, it almost always reads
+    // `req.rawBody` to parse the JSON-RPC body — the SDK's documented
+    // pattern. If no child is tagged (test stubs, agents whose signature
+    // path is non-SDK), `serve()` won't buffer the body and
+    // `resolveOperation` silently sees `undefined`, bypassing
+    // `requiredFor`. Tag the combined authenticator whenever a resolver
+    // is present so buffering happens regardless of the child shapes.
+    if (anyChildNeedsRawBody || resolveOperation) {
+        (0, auth_1.tagAuthenticatorNeedsRawBody)(combined);
+    }
+    (0, auth_1.tagAuthenticatorPresenceGated)(combined);
+    return combined;
+}
+/**
+ * Bundled composition of {@link requireSignatureWhenPresent} with an
+ * operation resolver — one call produces an authenticator that:
+ *
+ *   1. Prefers the RFC 9421 signature path when a `Signature-Input`
+ *      header is present, with no bearer fall-through on invalid
+ *      signatures (matches the `signed-requests` specialism contract).
+ *   2. Accepts bearer / API key when no signature is present, including
+ *      on `requiredFor` operations — valid credentials bypass the
+ *      signature requirement.
+ *   3. Rejects unsigned calls with no credentials on `requiredFor`
+ *      operations with a `WWW-Authenticate: Signature` challenge whose
+ *      error is `request_signature_required`.
+ *
+ * ```ts
+ * import {
+ *   serve,
+ *   verifyApiKey,
+ *   verifyBearer,
+ *   anyOf,
+ *   verifySignatureAsAuthenticator,
+ *   requireAuthenticatedOrSigned,
+ *   mcpToolNameResolver,
+ *   MUTATING_TASKS,
+ * } from '@adcp/sdk/server';
+ *
+ * serve(createAgent, {
+ *   authenticate: requireAuthenticatedOrSigned({
+ *     signature: verifySignatureAsAuthenticator({
+ *       jwks, replayStore, revocationStore, capability,
+ *       resolveOperation: mcpToolNameResolver,
+ *     }),
+ *     fallback: anyOf(verifyApiKey({ keys }), verifyBearer({ jwksUri, issuer, audience })),
+ *     requiredFor: [...MUTATING_TASKS],
+ *     resolveOperation: mcpToolNameResolver,
+ *   }),
+ * });
+ * ```
+ */
+function requireAuthenticatedOrSigned(options) {
+    return requireSignatureWhenPresent(options.signature, options.fallback, {
+        requiredFor: options.requiredFor,
+        resolveOperation: options.resolveOperation,
+    });
+}
+/**
+ * Default `resolveOperation` for MCP agents. Parses the buffered JSON-RPC
+ * body on `req.rawBody` and returns `params.name` when `method === 'tools/call'`.
+ * Returns `undefined` for non-`tools/call` methods, a missing body, or
+ * malformed JSON — the same "skip the pre-check and let the handler produce
+ * a precise error" semantics every other `resolveOperation` in the SDK
+ * uses.
+ *
+ * Pass directly as `resolveOperation` on {@link verifySignatureAsAuthenticator},
+ * {@link requireSignatureWhenPresent}, {@link requireAuthenticatedOrSigned},
+ * or `createExpressVerifier` from `@adcp/sdk/signing`:
+ *
+ * ```ts
+ * serve(createAgent, {
+ *   authenticate: requireAuthenticatedOrSigned({
+ *     signature: verifySignatureAsAuthenticator({
+ *       jwks, replayStore, revocationStore, capability,
+ *       resolveOperation: mcpToolNameResolver,
+ *     }),
+ *     fallback: anyOf(verifyApiKey({ keys }), verifyBearer({ jwksUri, issuer, audience })),
+ *     requiredFor: [...MUTATING_TASKS],
+ *     resolveOperation: mcpToolNameResolver,
+ *   }),
+ * });
+ * ```
+ *
+ * A2A agents use a different envelope — write a bespoke resolver there.
+ */
+function mcpToolNameResolver(req) {
+    const raw = req.rawBody;
+    if (!raw)
+        return undefined;
+    try {
+        const body = JSON.parse(raw);
+        if (body?.method !== 'tools/call')
+            return undefined;
+        const params = body.params;
+        return typeof params?.name === 'string' ? params.name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const SAFE_KEYID = /^[A-Za-z0-9._-]{1,256}$/;
+function hasSignatureHeader(req) {
+    // RFC 9421 pairs `Signature-Input` with `Signature`. Either is sufficient
+    // "signed intent" — a request carrying only one is malformed, but routing
+    // it to the fallback would mean a half-formed signing attempt (e.g., client
+    // bug that dropped the Signature-Input header) silently auths via bearer.
+    // Fail closed: send it to the signature authenticator, which will throw.
+    return nonEmptyHeader(req.headers['signature-input']) || nonEmptyHeader(req.headers['signature']);
+}
+function nonEmptyHeader(v) {
+    if (typeof v === 'string')
+        return v.length > 0;
+    if (Array.isArray(v))
+        return v.length > 0;
+    return false;
+}
+function defaultUrl(req) {
+    const forwardedProto = firstHeader(req.headers['x-forwarded-proto']);
+    const encrypted = req.socket?.encrypted === true;
+    const proto = forwardedProto ?? (encrypted ? 'https' : 'http');
+    const host = firstHeader(req.headers['host']);
+    if (!host) {
+        throw new Error('verifySignatureAsAuthenticator: missing Host header. Pass `getUrl` to reconstruct the canonical URL explicitly.');
+    }
+    return `${proto}://${host}${req.url ?? '/'}`;
+}
+function firstHeader(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.length > 0)
+        return value[0];
+    return undefined;
+}
+//# sourceMappingURL=auth-signature.js.map

package/dist/lib/server/auth-signature.js.map

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

package/dist/lib/server/auth.d.ts

@@ -0,0 +1,303 @@
+/**
+ * Server-side authentication primitives for AdCP MCP agents.
+ *
+ * Wire one of these into {@link serve} via `ServeOptions.authenticate` to
+ * require credentials on every incoming request. The supported mechanisms
+ * match the storyboard security baseline:
+ *
+ * - `verifyApiKey({ verify })` — static or dynamic API-key lookup.
+ * - `verifyBearer({ jwksUri, issuer, audience })` — OAuth 2.0 bearer JWT
+ *   validation against a JWKS endpoint. Use this when your IdP issues
+ *   signed JWTs (WorkOS, Auth0, Clerk, Okta, etc.).
+ * - `anyOf(a, b, ...)` — pass if any sub-authenticator succeeds. The
+ *   canonical way to accept "API key OR OAuth".
+ *
+ * On failure, the {@link respondUnauthorized} helper produces an RFC 6750
+ * compliant 401 (or 403) with a `WWW-Authenticate` header — required for
+ * compliance and what the storyboard runner probes for.
+ *
+ * **Audience binding is not optional.** `verifyBearer` requires an `audience`
+ * and rejects tokens whose `aud` claim doesn't match — this is what stops
+ * same-tenant tokens from being replayed against any agent that shares the
+ * tenant. If you write a CUSTOM `authenticate` callback (instead of using
+ * `verifyBearer`), you MUST validate `aud` yourself against your canonical
+ * public URL. IdPs that don't include `aud` in user tokens (some WorkOS /
+ * Clerk defaults) break the model: either add `aud` at mint time via a
+ * custom claim, or pick a different IdP configuration. Signature + expiry
+ * + scope alone is not per-resource isolation.
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import { type JWTPayload, type JWTVerifyOptions } from 'jose';
+import type { RequestSignatureErrorCode } from '../signing/errors';
+/**
+ * Default JWT algorithm allowlist. Asymmetric only — HS-family is intentionally
+ * excluded to prevent algorithm-confusion attacks where a JWKS public key is
+ * used as an HMAC secret. Callers can override via {@link VerifyBearerOptions.jwtOptions}.
+ */
+export declare const DEFAULT_JWT_ALGORITHMS: readonly string[];
+/** Default `exp`/`nbf` tolerance to reduce flakes under minor clock drift. */
+export declare const DEFAULT_JWT_CLOCK_TOLERANCE_SECONDS = 30;
+/**
+ * Successful authentication result. Attach whatever claims you want —
+ * `principal` is recommended (an opaque identifier for who's calling).
+ */
+export interface AuthPrincipal {
+    principal: string;
+    /** Raw credential that authenticated the request. Propagated into `req.auth.token` for MCP tool handlers. */
+    token?: string;
+    scopes?: string[];
+    /**
+     * Parsed identity claims. Source depends on the authenticator:
+     * - {@link verifyBearer} populates the decoded JWT payload (RFC 7519).
+     * - {@link verifyIntrospection} populates the RFC 7662 introspection response
+     *   — same shape for the overlap fields (`iss`, `sub`, `aud`, `exp`, `iat`,
+     *   `nbf`, `jti`), plus introspection-only fields (`active`, `client_id`,
+     *   `username`, `scope`, `token_type`) typed as `unknown` via the index
+     *   signature. Narrow with a type guard before passing to an LLM context —
+     *   an upstream IdP that controls `sub`, `username`, `client_id`, or
+     *   `scope` can inject prompt content if those values reach a model
+     *   unvalidated (adapters often reflect granted scopes into UI / system
+     *   prompts, so the scope string is a real injection surface).
+     */
+    claims?: JWTPayload;
+    /** Token expiry (seconds since epoch) when known — propagated to MCP `AuthInfo.expiresAt`. */
+    expiresAt?: number;
+    [key: string]: unknown;
+}
+/**
+ * Outcome of a single authenticator. Return `null` for "did not match" so
+ * combinators like {@link anyOf} can move on to the next authenticator.
+ * Throw for "definitely unauthorized" (e.g., a valid JWT that failed
+ * audience validation) so callers can distinguish from "no credentials".
+ */
+export type AuthResult = AuthPrincipal | null;
+/**
+ * Authentication middleware applied before the MCP transport handles a request.
+ * Receives the raw Node request so it can read the Authorization header or
+ * a query parameter, as needed.
+ */
+export type Authenticator = (req: IncomingMessage) => AuthResult | Promise<AuthResult>;
+/**
+ * Error class signalling "credentials presented but rejected". Carries a
+ * sanitized public `message` safe to surface to clients and a `cause` with
+ * the underlying implementation error for server-side logs. `serve()` uses
+ * this to avoid leaking library-internal messages (e.g. expected `aud` values
+ * from `jose`) into `WWW-Authenticate` / response bodies.
+ */
+export declare class AuthError extends Error {
+    readonly publicMessage: string;
+    constructor(publicMessage: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Marker tag on an {@link Authenticator} that needs `req.rawBody` to be
+ * populated before it runs. `serve()` buffers the request body ahead of
+ * authentication when any wired authenticator carries this tag — RFC 9421
+ * signature verifiers need the raw bytes to recompute `Content-Digest`.
+ *
+ * Attach via {@link tagAuthenticatorNeedsRawBody}; {@link anyOf} propagates
+ * the tag when any wrapped authenticator carries it.
+ */
+export declare const AUTH_NEEDS_RAW_BODY: unique symbol;
+/**
+ * Marker tag on an {@link Authenticator} whose contract depends on being the
+ * sole path for some class of requests — wrapping it in {@link anyOf} would
+ * reintroduce an either-or fall-through that the gate was built to prevent.
+ *
+ * Currently carried by the authenticator returned from
+ * `requireSignatureWhenPresent`, which guarantees "if `Signature-Input` is
+ * present, the signature path is the ONLY outcome." Composing it under
+ * `anyOf` would let a valid bearer silently accept an invalid signature —
+ * the exact bug the helper closes. `anyOf` throws at composition time when
+ * any child is tagged.
+ */
+export declare const AUTH_PRESENCE_GATED: unique symbol;
+/**
+ * Request-scoped context that {@link serve} stamps on the incoming request
+ * before the authenticator runs. Authenticator callbacks read this via
+ * {@link getServeRequestContext} so they inherit `serve()`'s host
+ * resolution (which honors `trustForwardedHost`) instead of re-reading
+ * headers that may be attacker-controlled.
+ */
+export declare const ADCP_SERVE_REQUEST_CONTEXT: unique symbol;
+/**
+ * Per-request context exposed to the `verifyBearer` audience callback.
+ * Authoritative host + resolved publicUrl come from `serve()` — the
+ * callback MUST NOT reach past this object to read `X-Forwarded-Host`
+ * itself, or it will diverge from the advertised OAuth `resource` and
+ * let a spoofed header flip the audience check.
+ */
+export interface ServeRequestContext {
+    /** Canonical host for the request as resolved by `serve()`. Lowercased, port preserved. */
+    host: string;
+    /** Resolved `publicUrl` for this host (if configured). Undefined in single-host mode with no publicUrl. */
+    publicUrl?: string;
+}
+/** Read the serve()-populated context off a request. Returns `undefined` when the request didn't come through `serve()`. */
+export declare function getServeRequestContext(req: IncomingMessage): ServeRequestContext | undefined;
+/**
+ * Mark an authenticator as needing `req.rawBody`. Safe to call more than once.
+ */
+export declare function tagAuthenticatorNeedsRawBody(auth: Authenticator): Authenticator;
+/**
+ * Check whether an authenticator (possibly composed via {@link anyOf}) requires
+ * the raw request body to be buffered before invocation.
+ */
+export declare function authenticatorNeedsRawBody(auth: Authenticator | undefined): boolean;
+/**
+ * Mark an authenticator as presence-gated. {@link anyOf} refuses to wrap a
+ * tagged authenticator — wrapping would defeat the gate.
+ */
+export declare function tagAuthenticatorPresenceGated(auth: Authenticator): Authenticator;
+/**
+ * Check whether an authenticator is presence-gated (see {@link AUTH_PRESENCE_GATED}).
+ */
+export declare function isAuthenticatorPresenceGated(auth: Authenticator | undefined): boolean;
+/**
+ * Extract a bearer token from the request. Checks the `Authorization` header
+ * first (`Bearer <token>`), then the legacy `x-adcp-auth` header our older
+ * clients use.
+ */
+export declare function extractBearerToken(req: IncomingMessage): string | null;
+export interface VerifyApiKeyOptions {
+    /**
+     * Static map of API keys to the principal they represent. Handy for
+     * single-tenant agents or local development.
+     */
+    keys?: Record<string, AuthPrincipal>;
+    /**
+     * Dynamic verifier for keys that live in a database or secret store.
+     * Return `null` for "not my key" (falls through to other authenticators),
+     * or a principal to accept.
+     */
+    verify?: (token: string) => Promise<AuthResult> | AuthResult;
+}
+/**
+ * Build an API-key authenticator. Accepts a static map and/or a dynamic
+ * verifier; if both are provided, the static map is checked first.
+ *
+ * ```ts
+ * serve(createAgent, {
+ *   authenticate: verifyApiKey({
+ *     keys: { 'sk_live_abc': { principal: 'acct_42' } },
+ *     verify: async token => db.lookupKey(token),
+ *   }),
+ * });
+ * ```
+ */
+export declare function verifyApiKey(options: VerifyApiKeyOptions): Authenticator;
+export interface VerifyBearerOptions {
+    /** JWKS URI — usually `<issuer>/.well-known/jwks.json`. */
+    jwksUri: string;
+    /** Expected `iss` claim. */
+    issuer: string;
+    /**
+     * Expected `aud` claim — the canonical URL clients see for this MCP
+     * endpoint (e.g., `https://my-agent.example.com/mcp`). MUST match what
+     * the token was issued for. If you advertise via
+     * {@link ServeOptions.protectedResource}, set this to the same URL.
+     *
+     * For multi-host deployments pass a function. The two-argument form
+     * receives `(req, ctx)` where `ctx.host` and `ctx.publicUrl` come from
+     * `serve()`'s host resolution — inheriting the same
+     * `trustForwardedHost` policy that governs the advertised PRM. Prefer
+     * `(_req, { publicUrl }) => publicUrl!` so the JWT audience check and
+     * the RFC 9728 `resource` URL can never diverge; a callback that reads
+     * `X-Forwarded-Host` directly is a footgun when `trustForwardedHost`
+     * is off.
+     *
+     * The single-argument form `(req) => string` still works for agents
+     * mounting `verifyBearer` outside `serve()` (e.g., under
+     * `createExpressAdapter`), but inherits none of `serve()`'s header
+     * hardening — you MUST validate audience inputs yourself.
+     */
+    audience: string | ((req: IncomingMessage) => string) | ((req: IncomingMessage, ctx: ServeRequestContext) => string);
+    /** Optional: required scopes (all must be present in the `scope` / `scp` claim). */
+    requiredScopes?: string[];
+    /**
+     * Optional: JWT verification options passthrough. Defaults to the secure
+     * asymmetric-only algorithm allowlist and a 30s clock tolerance — override
+     * only if you know why. HS256/HS384/HS512 are rejected by default to prevent
+     * algorithm-confusion attacks against the JWKS.
+     */
+    jwtOptions?: Omit<JWTVerifyOptions, 'issuer' | 'audience'>;
+}
+/**
+ * Build a JWT bearer authenticator that validates tokens against a JWKS.
+ *
+ * Uses the `jose` library (already in the dependency tree). Audience and
+ * issuer are enforced strictly — a token minted for the wrong audience
+ * is rejected, which is the bug pattern we've seen in the wild when an
+ * agent advertises an incorrect `/.well-known/oauth-protected-resource`
+ * `resource` URL.
+ *
+ * ```ts
+ * serve(createAgent, {
+ *   authenticate: verifyBearer({
+ *     jwksUri: 'https://auth.example/.well-known/jwks.json',
+ *     issuer: 'https://auth.example',
+ *     audience: 'https://my-agent.example.com/mcp',
+ *   }),
+ * });
+ * ```
+ */
+export declare function verifyBearer(options: VerifyBearerOptions): Authenticator;
+/**
+ * Pass if any authenticator succeeds. A `null` from one falls through to the
+ * next; a thrown error short-circuits to 401 (credentials were presented but
+ * rejected — not a "no credentials" case). Errors are wrapped in an
+ * {@link AuthError} with a generic public message so the client can't tell
+ * which mechanism rejected them.
+ */
+export declare function anyOf(...authenticators: Authenticator[]): Authenticator;
+export interface RespondUnauthorizedOptions {
+    /**
+     * Bearer realm value. Defaults to `"mcp"` — a stable value that won't reflect
+     * an attacker-controlled `Host` header into the challenge.
+     */
+    realm?: string;
+    /** RFC 6750 error code. Defaults to `invalid_token`. */
+    error?: 'invalid_request' | 'invalid_token' | 'insufficient_scope';
+    /** Human-readable description. */
+    errorDescription?: string;
+    /**
+     * OAuth 2.0 resource URL (RFC 9728). If set, included in the challenge so
+     * clients can discover the auth server from the protected-resource metadata.
+     */
+    resourceMetadata?: string;
+    /** Set to 403 instead of 401 for valid-but-unauthorized scenarios. */
+    status?: 401 | 403;
+    /**
+     * RFC 9421 signature error code. When set, the challenge scheme switches
+     * from `Bearer` to `Signature` and the body's `error` field carries the
+     * signature code verbatim — what the `signed_requests` conformance grader
+     * reads from `WWW-Authenticate` to decide pass/fail on negative vectors.
+     *
+     * Set this whenever the rejection is a signature-layer failure (invalid
+     * signature, missing required signature, revoked key, replayed nonce,
+     * etc.). `serve()` auto-detects this from an {@link AuthError} whose
+     * `cause` is a {@link RequestSignatureError}; callers rarely set it
+     * directly.
+     */
+    signatureError?: RequestSignatureErrorCode;
+}
+/**
+ * Send an RFC 6750-compliant 401/403 response with the `WWW-Authenticate`
+ * header set. Called automatically by {@link serve} when `authenticate`
+ * returns `null` or throws.
+ *
+ * When {@link RespondUnauthorizedOptions.signatureError} is set, the
+ * challenge scheme becomes `Signature` (per the `signed-requests`
+ * specialism) and the body's `error` field carries the RFC 9421 error
+ * code — the `signed_requests` grader reads both from the challenge.
+ */
+export declare function respondUnauthorized(_req: IncomingMessage, res: ServerResponse, options?: RespondUnauthorizedOptions): void;
+/**
+ * Unwrap the first {@link RequestSignatureError} found walking the
+ * `cause` chain of an {@link AuthError} (or any error), so callers can
+ * switch the `WWW-Authenticate` challenge scheme on signature-layer
+ * failures. Returns `null` for non-signature errors.
+ */
+export declare function signatureErrorCodeFromCause(err: unknown): RequestSignatureErrorCode | null;
+//# sourceMappingURL=auth.d.ts.map

package/dist/lib/server/auth.d.ts.map

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