@adcp/sdk 16.0.0-beta.1 → 16.0.0-beta.3

package/README.md

@@ -602,6 +602,60 @@ app.post(
 
 Full guide covering key generation, JWKS publication, brand.json setup, webhook signing, capability declaration, key rotation, and conformance testing: **[docs/guides/SIGNING-GUIDE.md](./docs/guides/SIGNING-GUIDE.md)**.
 
+### Response Size Cap
+
+Agent responses are untrusted input, so the SDK caps every response body it
+reads. **The default is 4 MiB** (`DEFAULT_MAX_RESPONSE_BYTES`), applied on
+every MCP and A2A call path: tool calls, endpoint discovery, `tools/list`,
+A2A agent-card lookup, and OAuth token exchange. (OAuth metadata discovery
+has its own, tighter 64 KiB cap and does not use this mechanism.)
+
+Bytes are counted as they stream in, a declared `Content-Length` over the cap
+is refused before the body is read, and an oversized response fails with a
+typed `ResponseTooLargeError`. Nothing is silently truncated.
+
+```typescript
+import { ResponseTooLargeError } from '@adcp/sdk';
+
+// Raise the cap for an agent that legitimately publishes a large catalog.
+const client = new ADCPMultiAgentClient(agents, {
+  transport: { maxResponseBytes: 32 * 1024 * 1024 },
+});
+
+// …or per call.
+await client.agent('agent_x').getProducts(params, {
+  transport: { maxResponseBytes: 32 * 1024 * 1024 },
+});
+
+// Opt out entirely — explicit, never the default. Only `0` opts out;
+// `Infinity` and negative values fall back to the 4 MiB default.
+await client.agent('agent_x').getProducts(params, { transport: { maxResponseBytes: 0 } });
+
+try {
+  await client.agent('agent_x').getProducts(params);
+} catch (err) {
+  if (err instanceof ResponseTooLargeError) {
+    console.warn(`agent returned > ${err.limit} bytes from ${err.url}`);
+  }
+}
+```
+
+`text/event-stream` responses are covered too, with two bounds: no single
+event frame may exceed `maxResponseBytes`, and the cumulative event-stream
+octets read during one call may not exceed `maxResponseBytes * 2` (8 MiB by
+default). A peer cannot escape the cap by replying with
+`Content-Type: text/event-stream`.
+
+The counter runs downstream of the runtime's content-decoder, so it measures
+**decompressed** octets: a small gzip blob that inflates to gigabytes still
+trips the cap after `maxResponseBytes` of output. The `Content-Length`
+pre-check sees the compressed length, so it is a fast path rather than the
+guarantee.
+
+A per-call `transport` object **replaces** the client's `transport` rather
+than merging into it — repeat `maxResponseBytes` when you override the object
+for some other reason.
+
 ### Authentication
 
 ```typescript

package/dist/lib/core/ConversationTypes.d.mts

@@ -184,10 +184,15 @@ export interface TaskOptions {
     /** Additional metadata to include */
     metadata?: Record<string, any>;
     /**
-     * Transport-level safeguards for this call. Overrides the matching field
-     * on the client constructor's `transport` option. Use to lift or tighten
+     * Transport-level safeguards for this call. Use to lift or tighten
      * `maxResponseBytes` per call when an agent legitimately publishes large
-     * catalogs (e.g., `list_creative_formats` on a generative seller).
+     * catalogs (e.g., `list_creative_formats` on a generative seller) — the
+     * default is 4 MiB.
+     *
+     * This object **replaces** the client constructor's `transport` rather than
+     * merging into it. A per-call object that sets only `requestTimeoutMs`
+     * drops the constructor's `maxResponseBytes` back to the default; repeat
+     * every field you still want.
      */
     transport?: import('../protocols/index.mjs').TransportOptions;
 }

package/dist/lib/core/ConversationTypes.d.ts

@@ -184,10 +184,15 @@ export interface TaskOptions {
     /** Additional metadata to include */
     metadata?: Record<string, any>;
     /**
-     * Transport-level safeguards for this call. Overrides the matching field
-     * on the client constructor's `transport` option. Use to lift or tighten
+     * Transport-level safeguards for this call. Use to lift or tighten
      * `maxResponseBytes` per call when an agent legitimately publishes large
-     * catalogs (e.g., `list_creative_formats` on a generative seller).
+     * catalogs (e.g., `list_creative_formats` on a generative seller) — the
+     * default is 4 MiB.
+     *
+     * This object **replaces** the client constructor's `transport` rather than
+     * merging into it. A per-call object that sets only `requestTimeoutMs`
+     * drops the constructor's `maxResponseBytes` back to the default; repeat
+     * every field you still want.
      */
     transport?: import('../protocols').TransportOptions;
 }

package/dist/lib/core/SingleAgentClient.d.mts

@@ -98,7 +98,16 @@ export type WebhookParseErrorCode = WebhookSignatureErrorCode | 'webhook_signatu
 export interface WebhookVerificationConfig {
     webBotAuth?: {
         directory: import('../signing/web-bot-auth.mjs').SignatureDirectoryResolver;
-        isRevoked: (origin: string, keyid: string) => Promise<boolean>;
+        /**
+         * Seller origin revocation, checked after verification. A revoked key is
+         * refused; unknown status is retryable; a seller that serves no list is
+         * accepted (webhooks do not spend). Usually an `OriginRevocationResolver`.
+         */
+        revocation?: {
+            status(origin: string, keyid: string): Promise<import('../identity-3.3/revocation.mjs').OriginRevocationStatus>;
+        };
+        /** @deprecated Use `revocation`. Conservative: a seller that serves no list is refused. */
+        isRevoked?: (origin: string, keyid: string) => Promise<boolean>;
     };
     /** Applicable pins from persisted media-buy records. Reuse refresh callbacks bound to the seller/publisher/tenant across deliveries to share their cooldown. Never use webhook payload fields. */
     publisherPins?: (registration: Readonly<WebhookRegistration>) => Promise<readonly import('../signing/publisher-pins.mjs').PublisherSigningKeyPin[]>;
@@ -486,9 +495,11 @@ export interface SingleAgentClientConfig extends ConversationConfig {
      * Transport-level safeguards. Applies to every call this client dispatches
      * unless overridden at call time.
      *
-     * Set `maxResponseBytes` when crawling untrusted agents (registries,
-     * federated discovery layers) to prevent a hostile vendor from buffering
-     * a large reply before any application-layer schema validation runs. Set
+     * `maxResponseBytes` defaults to 4 MiB on every call; raise it for an agent
+     * that legitimately publishes a large catalog, lower it when crawling
+     * untrusted agents (registries, federated discovery layers), or set it to
+     * exactly `0` to opt out of the cap entirely. A per-call `transport`
+     * replaces this object wholesale rather than merging into it. Set
      * `requestTimeoutMs` to override the default 60s cap on A2A agent-card
      * discovery; use `0` to disable the SDK-imposed discovery timeout.
      */

package/dist/lib/core/SingleAgentClient.d.ts

@@ -98,7 +98,16 @@ export type WebhookParseErrorCode = WebhookSignatureErrorCode | 'webhook_signatu
 export interface WebhookVerificationConfig {
     webBotAuth?: {
         directory: import('../signing/web-bot-auth').SignatureDirectoryResolver;
-        isRevoked: (origin: string, keyid: string) => Promise<boolean>;
+        /**
+         * Seller origin revocation, checked after verification. A revoked key is
+         * refused; unknown status is retryable; a seller that serves no list is
+         * accepted (webhooks do not spend). Usually an `OriginRevocationResolver`.
+         */
+        revocation?: {
+            status(origin: string, keyid: string): Promise<import('../identity-3.3/revocation').OriginRevocationStatus>;
+        };
+        /** @deprecated Use `revocation`. Conservative: a seller that serves no list is refused. */
+        isRevoked?: (origin: string, keyid: string) => Promise<boolean>;
     };
     /** Applicable pins from persisted media-buy records. Reuse refresh callbacks bound to the seller/publisher/tenant across deliveries to share their cooldown. Never use webhook payload fields. */
     publisherPins?: (registration: Readonly<WebhookRegistration>) => Promise<readonly import('../signing/publisher-pins').PublisherSigningKeyPin[]>;
@@ -486,9 +495,11 @@ export interface SingleAgentClientConfig extends ConversationConfig {
      * Transport-level safeguards. Applies to every call this client dispatches
      * unless overridden at call time.
      *
-     * Set `maxResponseBytes` when crawling untrusted agents (registries,
-     * federated discovery layers) to prevent a hostile vendor from buffering
-     * a large reply before any application-layer schema validation runs. Set
+     * `maxResponseBytes` defaults to 4 MiB on every call; raise it for an agent
+     * that legitimately publishes a large catalog, lower it when crawling
+     * untrusted agents (registries, federated discovery layers), or set it to
+     * exactly `0` to opt out of the cap entirely. A per-call `transport`
+     * replaces this object wholesale rather than merging into it. Set
      * `requestTimeoutMs` to override the default 60s cap on A2A agent-card
      * discovery; use `0` to disable the SDK-imposed discovery timeout.
      */

package/dist/lib/core/SingleAgentClient.js

@@ -2450,7 +2450,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       }
     }
     if (registration?.mode === "rfc9421") {
-      const { verifyWebBotAuth, selectSignatureProfile, WebBotAuthError } = loadWebBotAuth();
+      const { verifyWebBotAuth, selectSignatureProfile, WebBotAuthError, WebBotAuthUnavailableError } = loadWebBotAuth();
       const requestMethod = options.requestMethod;
       const requestUrl = options.requestUrl;
       if (rawBody === void 0 || !options.headers || !trustedOperationId || !requestMethod || !requestUrl) {
@@ -2474,17 +2474,30 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
               method: requestMethod,
               url: requestUrl,
               headers: normalizedHeaders.headers,
-              body: typeof rawBody === "string" ? rawBody : new TextDecoder("utf-8", { fatal: true }).decode(rawBody)
+              body: typeof rawBody === "string" ? rawBody : (
+                // ignoreBOM: Content-Digest covers the exact received bytes.
+                new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(rawBody)
+              )
             },
             {
               directory: config.directory,
               replayStore: this.webhookReplayStore,
-              isRevoked: config.isRevoked,
+              ...config.isRevoked && !config.revocation && { isRevoked: config.isRevoked },
               now: this.config.webhookVerification?.now
             }
           );
           if (signers.length !== 1 || signers[0].origin !== (0, import_canonicalize.canonicalAgentOrigin)(registration.agentUrl))
             throw new WebBotAuthError(403, "webhook_signer_mismatch");
+          if (config.revocation) {
+            let status;
+            try {
+              status = await config.revocation.status(signers[0].origin, signers[0].keyid);
+            } catch (error) {
+              throw new WebBotAuthUnavailableError("revocation_persistence_failed", error);
+            }
+            if (status === "revoked") throw new WebBotAuthError(403, "key_revoked");
+            if (status === "unknown") throw new WebBotAuthError(403, "identity_unverified");
+          } else if (!config.isRevoked) throw new WebBotAuthError(403, "webhook_revocation_not_configured");
         } else {
           if (actualProfile === "web-bot-auth") throw new WebBotAuthError(403, "webhook_profile_mismatch");
           const delegatedOperatorAuthorization = this.delegatedOperatorAuthorizationForRegistration(registration);
@@ -2510,14 +2523,17 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           );
         }
       } catch (cause) {
+        if (cause instanceof WebBotAuthUnavailableError)
+          return { ok: false, code: "webhook_verification_unavailable", message: cause.message, cause };
         if (cause instanceof WebBotAuthError)
           return {
             ok: false,
             code: [
               "directory_unavailable",
-              "revocation_unavailable",
-              "verification_unavailable",
-              "directory_fetch_limit"
+              "directory_fetch_limit",
+              "directory_expired",
+              "identity_unverified",
+              "verification_unavailable"
             ].includes(cause.reason) ? "webhook_verification_unavailable" : "webhook_signature_invalid",
             message: cause.message,
             cause
@@ -4854,6 +4870,11 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           const defaultAuth = !signed33Webhooks && this.config.webhookSecret ? { schemes: ["HMAC-SHA256"], credentials: this.config.webhookSecret } : void 0;
           const resolvedAuth = consumerAuth !== void 0 ? consumerAuth : consumerUrl === void 0 ? defaultAuth : void 0;
           if (!signed33Webhooks && resolvedAuth === void 0 || resolvedAuth === null) {
+            if (consumerReportingWebhook && consumerUrl !== void 0 && consumerAuth === void 0) {
+              throw new Error(
+                "reporting_webhook requires an `authentication` block without positively negotiated 3.3 signed webhooks: a caller-supplied `reporting_webhook.url` must bring its own `reporting_webhook.authentication` (the client never pairs `webhookSecret` with a caller-controlled URL). Omit `url` to use the client's webhookUrlTemplate callback, or remove `reporting_webhook` if you do not need automated delivery reports."
+              );
+            }
             if (consumerReportingWebhook) {
               throw new Error(
                 "reporting_webhook requires an `authentication` block without positively negotiated 3.3 signed webhooks, and no credential is available: set `webhookSecret` on the client, or pass `reporting_webhook.authentication` explicitly. Remove `reporting_webhook` from the request if you do not need automated delivery reports \u2014 the media buy itself does not require it."
@@ -4876,12 +4897,12 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
                 ...resolvedAuth === void 0 && this.selectedWebhookSigningProfile() && { signing_profile: this.selectedWebhookSigningProfile() }
               }
             };
-            if (signed33Webhooks && resolvedAuth === void 0) {
+            if (signed33Webhooks && resolvedAuth === void 0 && consumerUrl === void 0) {
               await this.persistWebhookRegistration({
                 agent: this.normalizedAgent,
                 taskType: "media_buy_delivery",
                 operationId,
-                callbackUrl: consumerUrl ?? deliveryWebhookUrl,
+                callbackUrl: deliveryWebhookUrl,
                 mode: "rfc9421",
                 signingProfile: this.selectedWebhookSigningProfile()
               });

package/dist/lib/core/SingleAgentClient.mjs

@@ -2541,7 +2541,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       }
     }
     if (registration?.mode === "rfc9421") {
-      const { verifyWebBotAuth, selectSignatureProfile, WebBotAuthError } = loadWebBotAuth();
+      const { verifyWebBotAuth, selectSignatureProfile, WebBotAuthError, WebBotAuthUnavailableError } = loadWebBotAuth();
       const requestMethod = options.requestMethod;
       const requestUrl = options.requestUrl;
       if (rawBody === void 0 || !options.headers || !trustedOperationId || !requestMethod || !requestUrl) {
@@ -2565,17 +2565,30 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
               method: requestMethod,
               url: requestUrl,
               headers: normalizedHeaders.headers,
-              body: typeof rawBody === "string" ? rawBody : new TextDecoder("utf-8", { fatal: true }).decode(rawBody)
+              body: typeof rawBody === "string" ? rawBody : (
+                // ignoreBOM: Content-Digest covers the exact received bytes.
+                new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(rawBody)
+              )
             },
             {
               directory: config.directory,
               replayStore: this.webhookReplayStore,
-              isRevoked: config.isRevoked,
+              ...config.isRevoked && !config.revocation && { isRevoked: config.isRevoked },
               now: this.config.webhookVerification?.now
             }
           );
           if (signers.length !== 1 || signers[0].origin !== canonicalAgentOrigin(registration.agentUrl))
             throw new WebBotAuthError(403, "webhook_signer_mismatch");
+          if (config.revocation) {
+            let status;
+            try {
+              status = await config.revocation.status(signers[0].origin, signers[0].keyid);
+            } catch (error) {
+              throw new WebBotAuthUnavailableError("revocation_persistence_failed", error);
+            }
+            if (status === "revoked") throw new WebBotAuthError(403, "key_revoked");
+            if (status === "unknown") throw new WebBotAuthError(403, "identity_unverified");
+          } else if (!config.isRevoked) throw new WebBotAuthError(403, "webhook_revocation_not_configured");
         } else {
           if (actualProfile === "web-bot-auth") throw new WebBotAuthError(403, "webhook_profile_mismatch");
           const delegatedOperatorAuthorization = this.delegatedOperatorAuthorizationForRegistration(registration);
@@ -2601,14 +2614,17 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           );
         }
       } catch (cause) {
+        if (cause instanceof WebBotAuthUnavailableError)
+          return { ok: false, code: "webhook_verification_unavailable", message: cause.message, cause };
         if (cause instanceof WebBotAuthError)
           return {
             ok: false,
             code: [
               "directory_unavailable",
-              "revocation_unavailable",
-              "verification_unavailable",
-              "directory_fetch_limit"
+              "directory_fetch_limit",
+              "directory_expired",
+              "identity_unverified",
+              "verification_unavailable"
             ].includes(cause.reason) ? "webhook_verification_unavailable" : "webhook_signature_invalid",
             message: cause.message,
             cause
@@ -4945,6 +4961,11 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           const defaultAuth = !signed33Webhooks && this.config.webhookSecret ? { schemes: ["HMAC-SHA256"], credentials: this.config.webhookSecret } : void 0;
           const resolvedAuth = consumerAuth !== void 0 ? consumerAuth : consumerUrl === void 0 ? defaultAuth : void 0;
           if (!signed33Webhooks && resolvedAuth === void 0 || resolvedAuth === null) {
+            if (consumerReportingWebhook && consumerUrl !== void 0 && consumerAuth === void 0) {
+              throw new Error(
+                "reporting_webhook requires an `authentication` block without positively negotiated 3.3 signed webhooks: a caller-supplied `reporting_webhook.url` must bring its own `reporting_webhook.authentication` (the client never pairs `webhookSecret` with a caller-controlled URL). Omit `url` to use the client's webhookUrlTemplate callback, or remove `reporting_webhook` if you do not need automated delivery reports."
+              );
+            }
             if (consumerReportingWebhook) {
               throw new Error(
                 "reporting_webhook requires an `authentication` block without positively negotiated 3.3 signed webhooks, and no credential is available: set `webhookSecret` on the client, or pass `reporting_webhook.authentication` explicitly. Remove `reporting_webhook` from the request if you do not need automated delivery reports \u2014 the media buy itself does not require it."
@@ -4967,12 +4988,12 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
                 ...resolvedAuth === void 0 && this.selectedWebhookSigningProfile() && { signing_profile: this.selectedWebhookSigningProfile() }
               }
             };
-            if (signed33Webhooks && resolvedAuth === void 0) {
+            if (signed33Webhooks && resolvedAuth === void 0 && consumerUrl === void 0) {
               await this.persistWebhookRegistration({
                 agent: this.normalizedAgent,
                 taskType: "media_buy_delivery",
                 operationId,
-                callbackUrl: consumerUrl ?? deliveryWebhookUrl,
+                callbackUrl: deliveryWebhookUrl,
                 mode: "rfc9421",
                 signingProfile: this.selectedWebhookSigningProfile()
               });

package/dist/lib/core/TaskExecutor.js

@@ -50,6 +50,7 @@ var import_signedRequestRejection = require('../protocols/signedRequestRejection
 var import_errors = require('../errors/index.js');
 var import_client_hooks = require('../validation/client-hooks.js');
 var import_schema_validator = require('../validation/schema-validator.js');
+var import_schema_loader = require('../validation/schema-loader.js');
 var import_version = require('../version.js');
 var import_response_unwrapper = require('../utils/response-unwrapper.js');
 var import_error_extraction = require('../utils/error-extraction.js');
@@ -4458,7 +4459,10 @@ class TaskExecutor {
     const mode = this.responseValidationMode;
     const logViolations = this.config.logSchemaViolations !== false;
     try {
-      const validationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? import_version.ADCP_VERSION;
+      let validationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? import_version.ADCP_VERSION;
+      if (taskName === "get_adcp_capabilities" && validationVersion !== "v2.5") {
+        validationVersion = (0, import_schema_loader.resolveServedValidationVersion)(response, validationVersion);
+      }
       const normalizedResponse = this.normalizeResponseForValidation(response, taskName, validationVersion === "v2.5");
       const outcome = (this.config.experimentalIdentity33?.() || this.config.identity33SchemaExperiment && normalizedResponse && typeof normalizedResponse === "object" && (0, import_adcp_version_config.isAdcpVersionAtLeast)(normalizedResponse.adcp_version, "3.3")) && mode !== "off" ? validateIdentity33Payload(taskName, "response", normalizedResponse, validationVersion) : (0, import_client_hooks.validateIncomingResponse)(taskName, normalizedResponse, mode, void 0, validationVersion);
       if (outcome.valid) return { valid: true, errors: [] };

package/dist/lib/core/TaskExecutor.mjs

@@ -26,6 +26,7 @@ import {
   resolveValidationModes
 } from "../validation/client-hooks.mjs";
 import { formatIssues } from "../validation/schema-validator.mjs";
+import { resolveServedValidationVersion } from "../validation/schema-loader.mjs";
 import { ADCP_VERSION } from "../version.mjs";
 import { unwrapProtocolResponse, isAdcpOperationSuccess } from "../utils/response-unwrapper.mjs";
 import { extractAdcpErrorInfo, extractCorrelationId } from "../utils/error-extraction.mjs";
@@ -4436,7 +4437,10 @@ class TaskExecutor {
     const mode = this.responseValidationMode;
     const logViolations = this.config.logSchemaViolations !== false;
     try {
-      const validationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? ADCP_VERSION;
+      let validationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? ADCP_VERSION;
+      if (taskName === "get_adcp_capabilities" && validationVersion !== "v2.5") {
+        validationVersion = resolveServedValidationVersion(response, validationVersion);
+      }
       const normalizedResponse = this.normalizeResponseForValidation(response, taskName, validationVersion === "v2.5");
       const outcome = (this.config.experimentalIdentity33?.() || this.config.identity33SchemaExperiment && normalizedResponse && typeof normalizedResponse === "object" && isAdcpVersionAtLeast(normalizedResponse.adcp_version, "3.3")) && mode !== "off" ? validateIdentity33Payload(taskName, "response", normalizedResponse, validationVersion) : validateIncomingResponse(taskName, normalizedResponse, mode, void 0, validationVersion);
       if (outcome.valid) return { valid: true, errors: [] };

package/dist/lib/errors/index.d.mts

@@ -374,10 +374,15 @@ export declare class ProtocolFeatureUnsupportedError extends FeatureUnsupportedE
 }
 export declare function getClientPreflightAdcpError(error: unknown): ClientPreflightAdcpErrorInfo | undefined;
 /**
- * Error thrown when a response body exceeds the configured `maxResponseBytes`
- * cap on the transport. Surfaced when crawling untrusted agents (registries,
- * federated discovery layers) to prevent a hostile vendor from buffering a
- * large reply before schema validation runs.
+ * Error thrown when a response body exceeds the `maxResponseBytes` cap on the
+ * transport — 4 MiB by default on every MCP and A2A call path. It prevents a
+ * hostile or merely careless agent from buffering a large reply before schema
+ * validation runs.
+ *
+ * Raised on three paths: a declared `Content-Length` over the cap, a one-shot
+ * body that crosses the cap mid-stream, and a `text/event-stream` response
+ * whose single event exceeds the cap or whose cumulative octets exceed the
+ * call's stream budget. Nothing is truncated — the read fails.
  *
  * Recovery: `terminal` from the SDK's view — repeating the call against the
  * same agent will hit the same cap. The buyer's options are to widen the

package/dist/lib/errors/index.d.ts

@@ -374,10 +374,15 @@ export declare class ProtocolFeatureUnsupportedError extends FeatureUnsupportedE
 }
 export declare function getClientPreflightAdcpError(error: unknown): ClientPreflightAdcpErrorInfo | undefined;
 /**
- * Error thrown when a response body exceeds the configured `maxResponseBytes`
- * cap on the transport. Surfaced when crawling untrusted agents (registries,
- * federated discovery layers) to prevent a hostile vendor from buffering a
- * large reply before schema validation runs.
+ * Error thrown when a response body exceeds the `maxResponseBytes` cap on the
+ * transport — 4 MiB by default on every MCP and A2A call path. It prevents a
+ * hostile or merely careless agent from buffering a large reply before schema
+ * validation runs.
+ *
+ * Raised on three paths: a declared `Content-Length` over the cap, a one-shot
+ * body that crosses the cap mid-stream, and a `text/event-stream` response
+ * whose single event exceeds the cap or whose cumulative octets exceed the
+ * call's stream budget. Nothing is truncated — the read fails.
  *
  * Recovery: `terminal` from the SDK's view — repeating the call against the
  * same agent will hit the same cap. The buyer's options are to widen the

package/dist/lib/identity-3.3/generated-compat.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Bridges the experimental AdCP 3.3 preview types to the generated wire types.
+ *
+ * The released SDK pins an AdCP schema version that predates the 3.3 identity
+ * drafts, so the preview types in `./types` start from hand-written drafts. Once
+ * the pinned schemas (or a candidate spec bundle built by the spec repo's
+ * "Generate TypeScript SDK" check) define a shape, the generated type wins: the
+ * preview type becomes an alias of it, so the two cannot drift apart and a
+ * server that accepts the preview shape always emits a generated-valid payload.
+ *
+ * Internal: not re-exported from `@adcp/sdk/identity-3.3`.
+ */
+import type { GetAdCPCapabilitiesResponse } from '../types/tools.generated.mjs';
+/**
+ * The value type of an optional property `K` on `T`, or `unknown` when `T`
+ * does not declare it. An object type without `K` is assignable to
+ * `{ K?: V }`, so the absent case infers `unknown` rather than failing.
+ * Non-distributive, so a union `T` resolves to the property's union rather
+ * than silently falling back when one member lacks it.
+ */
+export type OptionalPropertyOf<T, K extends PropertyKey> = [T] extends [{
+    [P in K]?: infer V;
+}] ? V : unknown;
+/** `Generated` when the pinned schemas define it, otherwise `Draft`. */
+export type PreferGenerated<Generated, Draft> = unknown extends Generated ? Draft : [NonNullable<Generated>] extends [never] ? Draft : NonNullable<Generated>;
+/**
+ * Resolves `account.agent_onboarding` from a `get_adcp_capabilities` account
+ * shape, falling back to the draft when that shape does not declare it.
+ * Parameterised so type tests can exercise it against fixtures of newer
+ * generated shapes without regenerating the SDK.
+ */
+export type ResolveAgentOnboarding<Account, Draft> = PreferGenerated<OptionalPropertyOf<NonNullable<Account>, 'agent_onboarding'>, Draft>;
+/** `account` in the pinned `get_adcp_capabilities` response. */
+export type GeneratedAccountCapabilities = NonNullable<GetAdCPCapabilitiesResponse['account']>;

package/dist/lib/identity-3.3/generated-compat.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bridges the experimental AdCP 3.3 preview types to the generated wire types.
+ *
+ * The released SDK pins an AdCP schema version that predates the 3.3 identity
+ * drafts, so the preview types in `./types` start from hand-written drafts. Once
+ * the pinned schemas (or a candidate spec bundle built by the spec repo's
+ * "Generate TypeScript SDK" check) define a shape, the generated type wins: the
+ * preview type becomes an alias of it, so the two cannot drift apart and a
+ * server that accepts the preview shape always emits a generated-valid payload.
+ *
+ * Internal: not re-exported from `@adcp/sdk/identity-3.3`.
+ */
+import type { GetAdCPCapabilitiesResponse } from '../types/tools.generated';
+/**
+ * The value type of an optional property `K` on `T`, or `unknown` when `T`
+ * does not declare it. An object type without `K` is assignable to
+ * `{ K?: V }`, so the absent case infers `unknown` rather than failing.
+ * Non-distributive, so a union `T` resolves to the property's union rather
+ * than silently falling back when one member lacks it.
+ */
+export type OptionalPropertyOf<T, K extends PropertyKey> = [T] extends [{
+    [P in K]?: infer V;
+}] ? V : unknown;
+/** `Generated` when the pinned schemas define it, otherwise `Draft`. */
+export type PreferGenerated<Generated, Draft> = unknown extends Generated ? Draft : [NonNullable<Generated>] extends [never] ? Draft : NonNullable<Generated>;
+/**
+ * Resolves `account.agent_onboarding` from a `get_adcp_capabilities` account
+ * shape, falling back to the draft when that shape does not declare it.
+ * Parameterised so type tests can exercise it against fixtures of newer
+ * generated shapes without regenerating the SDK.
+ */
+export type ResolveAgentOnboarding<Account, Draft> = PreferGenerated<OptionalPropertyOf<NonNullable<Account>, 'agent_onboarding'>, Draft>;
+/** `account` in the pinned `get_adcp_capabilities` response. */
+export type GeneratedAccountCapabilities = NonNullable<GetAdCPCapabilitiesResponse['account']>;

package/dist/lib/identity-3.3/generated-compat.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generated_compat_exports = {};
+module.exports = __toCommonJS(generated_compat_exports);

package/dist/lib/identity-3.3/index.d.mts

@@ -2,8 +2,8 @@ export * from './types.mjs';
 export * from './trust.mjs';
 export * from './lifecycle.mjs';
 export * from './revocation.mjs';
-export { WEB_BOT_AUTH_DRAFT_REVISION, verifyWebBotAuth, signWebBotAuth, createWebBotAuthFetch, createSignedSignatureDirectory, SignatureDirectoryResolver, verifySignatureDirectory, selectSignatureProfile, jwkThumbprint, WebBotAuthError, } from '../signing/web-bot-auth.mjs';
-export type { WebBotSigningKey, WebBotSigningOptions, VerifiedWebBotSigner, VerifyWebBotAuthOptions, } from '../signing/web-bot-auth.mjs';
+export { WEB_BOT_AUTH_DRAFT_REVISION, verifyWebBotAuth, signWebBotAuth, createWebBotAuthFetch, createSignedSignatureDirectory, SignatureDirectoryResolver, verifySignatureDirectory, verifyKeyDirectory, selectSignatureProfile, jwkThumbprint, WebBotAuthError, WebBotAuthUnavailableError, } from '../signing/web-bot-auth.mjs';
+export type { WebBotSigningKey, WebBotSigningOptions, VerifiedWebBotSigner, VerifyWebBotAuthOptions, VerifiedSignatureDirectory, SignatureDirectoryResolverOptions, } from '../signing/web-bot-auth.mjs';
 export { validateIdentity33Payload } from './validation.mjs';
 export { createIdentity33PrincipalResolver, createIdentity33PrincipalScopeResolver, createIdentity33Authorization, withIdentity33PrincipalHandlers, isIdentity33UnboundContext, } from './server.mjs';
 export { createIdentity33StateStores } from './store.mjs';

package/dist/lib/identity-3.3/index.d.ts

@@ -2,8 +2,8 @@ export * from './types';
 export * from './trust';
 export * from './lifecycle';
 export * from './revocation';
-export { WEB_BOT_AUTH_DRAFT_REVISION, verifyWebBotAuth, signWebBotAuth, createWebBotAuthFetch, createSignedSignatureDirectory, SignatureDirectoryResolver, verifySignatureDirectory, selectSignatureProfile, jwkThumbprint, WebBotAuthError, } from '../signing/web-bot-auth';
-export type { WebBotSigningKey, WebBotSigningOptions, VerifiedWebBotSigner, VerifyWebBotAuthOptions, } from '../signing/web-bot-auth';
+export { WEB_BOT_AUTH_DRAFT_REVISION, verifyWebBotAuth, signWebBotAuth, createWebBotAuthFetch, createSignedSignatureDirectory, SignatureDirectoryResolver, verifySignatureDirectory, verifyKeyDirectory, selectSignatureProfile, jwkThumbprint, WebBotAuthError, WebBotAuthUnavailableError, } from '../signing/web-bot-auth';
+export type { WebBotSigningKey, WebBotSigningOptions, VerifiedWebBotSigner, VerifyWebBotAuthOptions, VerifiedSignatureDirectory, SignatureDirectoryResolverOptions, } from '../signing/web-bot-auth';
 export { validateIdentity33Payload } from './validation';
 export { createIdentity33PrincipalResolver, createIdentity33PrincipalScopeResolver, createIdentity33Authorization, withIdentity33PrincipalHandlers, isIdentity33UnboundContext, } from './server';
 export { createIdentity33StateStores } from './store';

package/dist/lib/identity-3.3/index.js

@@ -22,6 +22,7 @@ __export(identity_3_exports, {
   SignatureDirectoryResolver: () => import_web_bot_auth.SignatureDirectoryResolver,
   WEB_BOT_AUTH_DRAFT_REVISION: () => import_web_bot_auth.WEB_BOT_AUTH_DRAFT_REVISION,
   WebBotAuthError: () => import_web_bot_auth.WebBotAuthError,
+  WebBotAuthUnavailableError: () => import_web_bot_auth.WebBotAuthUnavailableError,
   createIdentity33Authorization: () => import_server.createIdentity33Authorization,
   createIdentity33PrincipalResolver: () => import_server.createIdentity33PrincipalResolver,
   createIdentity33PrincipalScopeResolver: () => import_server.createIdentity33PrincipalScopeResolver,
@@ -34,6 +35,7 @@ __export(identity_3_exports, {
   selectSignatureProfile: () => import_web_bot_auth.selectSignatureProfile,
   signWebBotAuth: () => import_web_bot_auth.signWebBotAuth,
   validateIdentity33Payload: () => import_validation.validateIdentity33Payload,
+  verifyKeyDirectory: () => import_web_bot_auth.verifyKeyDirectory,
   verifySignatureDirectory: () => import_web_bot_auth.verifySignatureDirectory,
   verifyWebBotAuth: () => import_web_bot_auth.verifyWebBotAuth,
   withIdentity33PrincipalHandlers: () => import_server.withIdentity33PrincipalHandlers
@@ -53,6 +55,7 @@ var import_webhook_registration = require('../core/webhook-registration.js');
   SignatureDirectoryResolver,
   WEB_BOT_AUTH_DRAFT_REVISION,
   WebBotAuthError,
+  WebBotAuthUnavailableError,
   createIdentity33Authorization,
   createIdentity33PrincipalResolver,
   createIdentity33PrincipalScopeResolver,
@@ -65,6 +68,7 @@ var import_webhook_registration = require('../core/webhook-registration.js');
   selectSignatureProfile,
   signWebBotAuth,
   validateIdentity33Payload,
+  verifyKeyDirectory,
   verifySignatureDirectory,
   verifyWebBotAuth,
   withIdentity33PrincipalHandlers,

package/dist/lib/identity-3.3/index.mjs

@@ -10,9 +10,11 @@ import {
   createSignedSignatureDirectory,
   SignatureDirectoryResolver,
   verifySignatureDirectory,
+  verifyKeyDirectory,
   selectSignatureProfile,
   jwkThumbprint,
-  WebBotAuthError
+  WebBotAuthError,
+  WebBotAuthUnavailableError
 } from "../signing/web-bot-auth.mjs";
 import { validateIdentity33Payload } from "./validation.mjs";
 import {
@@ -28,6 +30,7 @@ export {
   SignatureDirectoryResolver,
   WEB_BOT_AUTH_DRAFT_REVISION,
   WebBotAuthError,
+  WebBotAuthUnavailableError,
   createIdentity33Authorization,
   createIdentity33PrincipalResolver,
   createIdentity33PrincipalScopeResolver,
@@ -40,6 +43,7 @@ export {
   selectSignatureProfile,
   signWebBotAuth,
   validateIdentity33Payload,
+  verifyKeyDirectory,
   verifySignatureDirectory,
   verifyWebBotAuth,
   withIdentity33PrincipalHandlers