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

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[]>;

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[]>;

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/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

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

@@ -1,6 +1,6 @@
 import type { PrincipalKind } from '../server/principal/types.mjs';
 import { TrustEvaluator } from './trust.mjs';
-import type { AgentOnboarding, AgentOnboardingRequirement, BillingParty, PrincipalRelationship, IdentityPrincipalChangedReason } from './types.mjs';
+import type { AgentOnboarding, AgentOnboardingRequirement, ObservedAgentOnboardingRequirement, BillingParty, PrincipalRelationship, IdentityPrincipalChangedReason } from './types.mjs';
 export interface OriginBinding {
     origin: string;
     operator: string;
@@ -47,10 +47,13 @@ export declare class InMemoryOriginIdentityStore implements OriginIdentityStore
     getApplication(origin: string): Promise<IdentityApplication | undefined>;
     compareAndSetApplication(origin: string, expectedRevision: number | undefined, application: IdentityApplication): Promise<boolean>;
 }
-/** Wrong-direction gates are ignored; unknown gates remain unsatisfied. */
-export declare function evaluateOnboardingRequirements(requirements: readonly AgentOnboardingRequirement[], direction: 'seller' | 'buyer', check: (requirement: AgentOnboardingRequirement) => Promise<boolean>): Promise<{
+/**
+ * Wrong-direction gates are ignored; unknown gates remain unsatisfied. Accepts
+ * requirements read off the wire, whose `kind` may be one this SDK does not know.
+ */
+export declare function evaluateOnboardingRequirements<R extends ObservedAgentOnboardingRequirement = AgentOnboardingRequirement>(requirements: readonly R[], direction: 'seller' | 'buyer', check: (requirement: R) => Promise<boolean>): Promise<{
     satisfied: boolean;
-    unsatisfied: AgentOnboardingRequirement[];
+    unsatisfied: R[];
 }>;
 export declare function validateAgentOnboarding(posture: AgentOnboarding, account: {
     sandbox?: boolean;
@@ -93,7 +96,16 @@ export declare class OriginIdentityLifecycle {
         migrationApproved?: boolean;
         sharedOrigin?: boolean;
     }): Promise<OriginBinding>;
-    /** Cryptographic verification does not call this. Authorization revalidates delisting. */
+    /**
+     * Cryptographic verification does not call this. Authorization revalidates
+     * delisting: the last record read does not list the origin (an empty
+     * `agents[]` retires it; a known delisting stays delisted through a failed
+     * refresh) and throws {@link TrustMembershipError}. An unreadable record
+     * (404/410 included) throws {@link TrustRecordUnavailableError} for spend;
+     * read-only and identity-configuration calls continue under the binding only
+     * while the last record read listed the origin and is within the evaluator's
+     * `maxOutageContinuationSeconds`.
+     */
     authorizeBound(originUrl: string, access?: {
         readOnly?: true;
         identityConfiguration?: true;

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

@@ -1,6 +1,6 @@
 import type { PrincipalKind } from '../server/principal/types';
 import { TrustEvaluator } from './trust';
-import type { AgentOnboarding, AgentOnboardingRequirement, BillingParty, PrincipalRelationship, IdentityPrincipalChangedReason } from './types';
+import type { AgentOnboarding, AgentOnboardingRequirement, ObservedAgentOnboardingRequirement, BillingParty, PrincipalRelationship, IdentityPrincipalChangedReason } from './types';
 export interface OriginBinding {
     origin: string;
     operator: string;
@@ -47,10 +47,13 @@ export declare class InMemoryOriginIdentityStore implements OriginIdentityStore
     getApplication(origin: string): Promise<IdentityApplication | undefined>;
     compareAndSetApplication(origin: string, expectedRevision: number | undefined, application: IdentityApplication): Promise<boolean>;
 }
-/** Wrong-direction gates are ignored; unknown gates remain unsatisfied. */
-export declare function evaluateOnboardingRequirements(requirements: readonly AgentOnboardingRequirement[], direction: 'seller' | 'buyer', check: (requirement: AgentOnboardingRequirement) => Promise<boolean>): Promise<{
+/**
+ * Wrong-direction gates are ignored; unknown gates remain unsatisfied. Accepts
+ * requirements read off the wire, whose `kind` may be one this SDK does not know.
+ */
+export declare function evaluateOnboardingRequirements<R extends ObservedAgentOnboardingRequirement = AgentOnboardingRequirement>(requirements: readonly R[], direction: 'seller' | 'buyer', check: (requirement: R) => Promise<boolean>): Promise<{
     satisfied: boolean;
-    unsatisfied: AgentOnboardingRequirement[];
+    unsatisfied: R[];
 }>;
 export declare function validateAgentOnboarding(posture: AgentOnboarding, account: {
     sandbox?: boolean;
@@ -93,7 +96,16 @@ export declare class OriginIdentityLifecycle {
         migrationApproved?: boolean;
         sharedOrigin?: boolean;
     }): Promise<OriginBinding>;
-    /** Cryptographic verification does not call this. Authorization revalidates delisting. */
+    /**
+     * Cryptographic verification does not call this. Authorization revalidates
+     * delisting: the last record read does not list the origin (an empty
+     * `agents[]` retires it; a known delisting stays delisted through a failed
+     * refresh) and throws {@link TrustMembershipError}. An unreadable record
+     * (404/410 included) throws {@link TrustRecordUnavailableError} for spend;
+     * read-only and identity-configuration calls continue under the binding only
+     * while the last record read listed the origin and is within the evaluator's
+     * `maxOutageContinuationSeconds`.
+     */
     authorizeBound(originUrl: string, access?: {
         readOnly?: true;
         identityConfiguration?: true;

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

@@ -66,14 +66,20 @@ class InMemoryOriginIdentityStore {
   }
 }
 const BUYER_GATES = /* @__PURE__ */ new Set(["aao_verified", "storyboard", "sandbox", "experimental_feature"]);
-const SELLER_GATES = /* @__PURE__ */ new Set(["agent_identity", "grant", "billing_entity", "contract", "credit_application"]);
+const SELLER_GATES = /* @__PURE__ */ new Set([
+  "agent_identity",
+  "grant",
+  "billing_entity",
+  "contract",
+  "credit_application"
+]);
 async function evaluateOnboardingRequirements(requirements, direction, check) {
   const relevant = direction === "seller" ? SELLER_GATES : BUYER_GATES;
   const wrong = direction === "seller" ? BUYER_GATES : SELLER_GATES;
   const unsatisfied = [];
   for (const requirement of requirements) {
     if (wrong.has(requirement.kind)) continue;
-    const wellFormed = requirement.kind !== "aao_verified" || !!requirement.role && !!requirement.verification_modes?.length && !!requirement.specialisms?.length && !!requirement.adcp_version;
+    const wellFormed = requirement.kind !== "aao_verified" || !!requirement.role && !!requirement.verification_modes?.length && !!(requirement.verified_specialisms ?? requirement.specialisms)?.length && !!requirement.adcp_version;
     const hasId = !["storyboard", "experimental_feature"].includes(requirement.kind) || !!requirement.id;
     if (!relevant.has(requirement.kind) || !wellFormed || !hasId || !await check(requirement))
       unsatisfied.push(requirement);
@@ -126,13 +132,34 @@ class OriginIdentityLifecycle {
     await this.options.store.bind(binding);
     return binding;
   }
-  /** Cryptographic verification does not call this. Authorization revalidates delisting. */
+  /**
+   * Cryptographic verification does not call this. Authorization revalidates
+   * delisting: the last record read does not list the origin (an empty
+   * `agents[]` retires it; a known delisting stays delisted through a failed
+   * refresh) and throws {@link TrustMembershipError}. An unreadable record
+   * (404/410 included) throws {@link TrustRecordUnavailableError} for spend;
+   * read-only and identity-configuration calls continue under the binding only
+   * while the last record read listed the origin and is within the evaluator's
+   * `maxOutageContinuationSeconds`.
+   */
   async authorizeBound(originUrl, access) {
     const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
     const binding = await this.options.store.getBinding(origin);
     if (!binding) throw new import_trust.IdentityAuthorizationError();
-    const trust = await this.options.trust.match(origin, "adcp:buying");
-    if (binding.operator !== trust.operator) throw new import_trust.IdentityAuthorizationError();
+    try {
+      let trust;
+      try {
+        trust = await this.options.trust.match(origin, "adcp:buying");
+      } catch (error) {
+        if (error instanceof import_trust.TrustMembershipError && error.membership === "absent")
+          throw Object.assign(new import_trust.TrustRecordUnavailableError(), { cause: error });
+        throw error;
+      }
+      if (binding.operator !== trust.operator) throw new import_trust.TrustMembershipError();
+    } catch (error) {
+      if (!(error instanceof import_trust.TrustRecordUnavailableError) || !error.lastKnownListed || !(access?.readOnly || access?.identityConfiguration))
+        throw error;
+    }
     const relationship = (await this.options.store.getApplication(origin))?.relationship;
     if (!access?.readOnly && relationship && (relationship.status !== "active" || relationship.expires_at && Date.parse(relationship.expires_at) <= this.now() * 1e3))
       throw new import_trust.IdentityAuthorizationError();

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

@@ -2,7 +2,12 @@ import { randomUUID } from "crypto";
 import { parse as parseTld } from "tldts";
 import { canonicalAgentOrigin } from "../signing/agent-resolver/canonicalize.mjs";
 import { eTldPlusOne } from "../signing/agent-resolver/etld.mjs";
-import { IdentityAuthorizationError, validateIdentity33Schema } from "./trust.mjs";
+import {
+  IdentityAuthorizationError,
+  TrustMembershipError,
+  TrustRecordUnavailableError,
+  validateIdentity33Schema
+} from "./trust.mjs";
 class InMemoryOriginIdentityStore {
   durability = "process-local";
   bindings = /* @__PURE__ */ new Map();
@@ -40,14 +45,20 @@ class InMemoryOriginIdentityStore {
   }
 }
 const BUYER_GATES = /* @__PURE__ */ new Set(["aao_verified", "storyboard", "sandbox", "experimental_feature"]);
-const SELLER_GATES = /* @__PURE__ */ new Set(["agent_identity", "grant", "billing_entity", "contract", "credit_application"]);
+const SELLER_GATES = /* @__PURE__ */ new Set([
+  "agent_identity",
+  "grant",
+  "billing_entity",
+  "contract",
+  "credit_application"
+]);
 async function evaluateOnboardingRequirements(requirements, direction, check) {
   const relevant = direction === "seller" ? SELLER_GATES : BUYER_GATES;
   const wrong = direction === "seller" ? BUYER_GATES : SELLER_GATES;
   const unsatisfied = [];
   for (const requirement of requirements) {
     if (wrong.has(requirement.kind)) continue;
-    const wellFormed = requirement.kind !== "aao_verified" || !!requirement.role && !!requirement.verification_modes?.length && !!requirement.specialisms?.length && !!requirement.adcp_version;
+    const wellFormed = requirement.kind !== "aao_verified" || !!requirement.role && !!requirement.verification_modes?.length && !!(requirement.verified_specialisms ?? requirement.specialisms)?.length && !!requirement.adcp_version;
     const hasId = !["storyboard", "experimental_feature"].includes(requirement.kind) || !!requirement.id;
     if (!relevant.has(requirement.kind) || !wellFormed || !hasId || !await check(requirement))
       unsatisfied.push(requirement);
@@ -100,13 +111,34 @@ class OriginIdentityLifecycle {
     await this.options.store.bind(binding);
     return binding;
   }
-  /** Cryptographic verification does not call this. Authorization revalidates delisting. */
+  /**
+   * Cryptographic verification does not call this. Authorization revalidates
+   * delisting: the last record read does not list the origin (an empty
+   * `agents[]` retires it; a known delisting stays delisted through a failed
+   * refresh) and throws {@link TrustMembershipError}. An unreadable record
+   * (404/410 included) throws {@link TrustRecordUnavailableError} for spend;
+   * read-only and identity-configuration calls continue under the binding only
+   * while the last record read listed the origin and is within the evaluator's
+   * `maxOutageContinuationSeconds`.
+   */
   async authorizeBound(originUrl, access) {
     const origin = canonicalAgentOrigin(originUrl);
     const binding = await this.options.store.getBinding(origin);
     if (!binding) throw new IdentityAuthorizationError();
-    const trust = await this.options.trust.match(origin, "adcp:buying");
-    if (binding.operator !== trust.operator) throw new IdentityAuthorizationError();
+    try {
+      let trust;
+      try {
+        trust = await this.options.trust.match(origin, "adcp:buying");
+      } catch (error) {
+        if (error instanceof TrustMembershipError && error.membership === "absent")
+          throw Object.assign(new TrustRecordUnavailableError(), { cause: error });
+        throw error;
+      }
+      if (binding.operator !== trust.operator) throw new TrustMembershipError();
+    } catch (error) {
+      if (!(error instanceof TrustRecordUnavailableError) || !error.lastKnownListed || !(access?.readOnly || access?.identityConfiguration))
+        throw error;
+    }
     const relationship = (await this.options.store.getApplication(origin))?.relationship;
     if (!access?.readOnly && relationship && (relationship.status !== "active" || relationship.expires_at && Date.parse(relationship.expires_at) <= this.now() * 1e3))
       throw new IdentityAuthorizationError();