@adcp/sdk 15.9.1 → 16.0.0-beta.2

package/dist/lib/core/SingleAgentClient.js

@@ -34,6 +34,8 @@ __export(SingleAgentClient_exports, {
   createSingleAgentClient: () => createSingleAgentClient
 });
 module.exports = __toCommonJS(SingleAgentClient_exports);
+var import_schema_loader = require('../validation/schema-loader.js');
+var import_canonicalize = require('../signing/agent-resolver/canonicalize.js');
 var import_products = require('../supply-path/products.js');
 var import_node_crypto = require("node:crypto");
 var import_adcp = require('../types/adcp.js');
@@ -41,7 +43,7 @@ var import_version = require('../version.js');
 var import_adcp_version_config = require('../utils/adcp-version-config.js');
 var import_reporting_version = require('../media-buy/reporting-version.js');
 var import_version2 = require('../adapters/version/index.js');
-var import_schema_loader = require('../validation/schema-loader.js');
+var import_schema_loader2 = require('../validation/schema-loader.js');
 var import_idempotency = require('../utils/idempotency.js');
 var import_a2a = require('../protocols/a2a.js');
 var import_TaskExecutor = require('./TaskExecutor.js');
@@ -88,6 +90,9 @@ var import_augment_response = require('../v2/projection/augment-response.js');
 var import_legacy_metadata = require('../v2/projection/legacy-metadata.js');
 var import_types = require('../v2/projection/types.js');
 var import_jcs = require('../utils/jcs.js');
+function loadWebBotAuth() {
+  return require('../signing/web-bot-auth.js');
+}
 const SKIP_PRODUCT_CACHE = /* @__PURE__ */ Symbol("adcp.skipProductCache");
 const SKIP_ACCOUNT_REGISTRY_OBSERVATION = /* @__PURE__ */ Symbol("adcp.skipAccountRegistryObservation");
 function presentedStaticTransportCredential(authToken, headers, authProvider) {
@@ -742,6 +747,11 @@ class SingleAgentClient {
   constructor(agent, config = {}) {
     this.agent = agent;
     this.config = config;
+    if (config.experimentalIdentity33 === true !== (0, import_schema_loader.isIdentity33SchemaScope)())
+      return (0, import_schema_loader.withIdentity33SchemaScope)(() => {
+        const instance = Reflect.construct(SingleAgentClient, [agent, config], new.target);
+        return config.experimentalIdentity33 ? (0, import_schema_loader.bindIdentity33SchemaScope)(instance) : instance;
+      }, config.experimentalIdentity33 === true);
     const configuredTransport = config.transport === void 0 ? void 0 : { ...config.transport };
     const configuredWebhookVerification = config.webhookVerification === void 0 ? void 0 : {
       ...config.webhookVerification,
@@ -756,7 +766,9 @@ class SingleAgentClient {
     };
     config = this.config;
     (0, import_agent_discovery_cache.validateAgentDiscoveryCacheConfig)(config.discoveryCache);
-    this.resolvedAdcpVersion = (0, import_adcp_version_config.resolveAdcpVersion)(config.adcpVersion);
+    this.resolvedAdcpVersion = (0, import_adcp_version_config.resolveAdcpVersion)(
+      config.adcpVersion ?? (config.experimentalIdentity33 ? "3.3" : void 0)
+    );
     this.webhookRegistrationStore = config.webhookRegistrationStore ?? new import_webhook_registration.InMemoryWebhookRegistrationStore();
     this.webhookReplayStore = config.webhookVerification?.replayStore ?? new import_server.InMemoryReplayStore();
     this.webhookRevocationStore = config.webhookVerification?.revocationStore ?? new import_server.InMemoryRevocationStore();
@@ -815,6 +827,10 @@ class SingleAgentClient {
       webhookUrlTemplate: config.webhookUrlTemplate,
       agentId: agent.id,
       webhookSecret: config.webhookSecret,
+      identity33SchemaExperiment: config.experimentalIdentity33,
+      experimentalIdentity33: () => this.config.experimentalIdentity33 === true && this.usesIdentity33Schemas(),
+      signedIdentity33Webhooks: () => this.usesSigned33Webhooks(),
+      webhookSigningProfile: () => this.selectedWebhookSigningProfile(),
       onWebhookRegistration: (registration) => this.persistWebhookRegistration(registration),
       onDurableSettlementRequired: (operationId) => this.markWebhookDurableSettlementRequired(operationId),
       externalTaskSettlementRetentionMs: registrationTtl * 1e3,
@@ -1050,7 +1066,7 @@ class SingleAgentClient {
       throw new import_errors3.AccountNotProvisionedError(ref, task);
     }
     const caps = await this.getCapabilities(options);
-    if (caps._synthetic || ["get_products", "list_products"].includes(task) && caps.account?.requiredForProducts || params.push_notification_config || !(0, import_schema_loader.schemaAllowsTopLevelField)(task, "brand")) {
+    if (caps._synthetic || ["get_products", "list_products"].includes(task) && caps.account?.requiredForProducts || params.push_notification_config || !(0, import_schema_loader2.schemaAllowsTopLevelField)(task, "brand")) {
       throw new import_errors3.AccountNotProvisionedError(ref, task);
     }
     if (!("brand" in ref)) throw new import_errors3.AccountNotProvisionedError(ref, task);
@@ -1070,6 +1086,7 @@ class SingleAgentClient {
   // Cache canonical base URL (from agent card or stripped /mcp)
   cachedCapabilities;
   // Cache detected server capabilities
+  runAgentInfo;
   cachedToolSchemas;
   // inputSchema.properties per tool name
   primedCapabilitiesExpiresAt;
@@ -1126,18 +1143,18 @@ class SingleAgentClient {
     persistedAgentUrl.username = "";
     persistedAgentUrl.password = "";
     persistedAgentUrl.hash = "";
-    const delegatedOperatorAuthorization = this.effectiveDelegatedOperatorAuthorization(
-      args.delegatedOperatorAuthorization
-    );
+    const delegatedOperatorAuthorization = args.deliveryKind ? void 0 : this.effectiveDelegatedOperatorAuthorization(args.delegatedOperatorAuthorization);
     const registration = {
       agentId: args.agent.id,
       agentUrl: persistedAgentUrl.toString(),
       protocol: args.agent.protocol,
       operationId: args.operationId,
       taskType: args.taskType,
-      callbackUrl: args.callbackUrl,
+      callbackUrl: args.deliveryKind ? (0, import_server.canonicalTargetUri)(args.callbackUrl, "3.2") : args.callbackUrl,
       method: "POST",
       mode: args.mode,
+      ...args.signingProfile && { signingProfile: args.signingProfile },
+      ...args.deliveryKind && { deliveryKind: args.deliveryKind },
       authorizationContextVersion: 1,
       ...delegatedOperatorAuthorization !== void 0 && { delegatedOperatorAuthorization },
       ...previewMode && { previewMode },
@@ -1146,6 +1163,14 @@ class SingleAgentClient {
     };
     (0, import_webhook_registration.validateWebhookRegistrationAuthorization)(registration);
     try {
+      if (args.deliveryKind) {
+        const previous = await this.webhookRegistrationStore.get(args.agent.id, args.operationId);
+        if (previous && previous.expiresAt > nowMs && (previous.signingProfile ?? "adcp/webhook-signing/v1") !== (registration.signingProfile ?? "adcp/webhook-signing/v1"))
+          throw new import_errors.ConfigurationError(
+            `${args.deliveryKind} callback is already registered with ${previous.signingProfile ?? "adcp/webhook-signing/v1"}. Use a new callback URL or delete its old registration after outstanding deliveries finish.`,
+            `${args.deliveryKind}_webhook.signing_profile`
+          );
+      }
       await this.webhookRegistrationStore.putIfAbsent(registration);
       const persisted = await this.webhookRegistrationStore.get(args.agent.id, args.operationId);
       if (!persisted || !(0, import_webhook_registration.sameWebhookRegistration)(
@@ -1157,6 +1182,8 @@ class SingleAgentClient {
         );
       }
     } catch (cause) {
+      if (args.deliveryKind && cause instanceof import_errors.ConfigurationError && cause.configField === `${args.deliveryKind}_webhook.signing_profile`)
+        throw cause;
       if (args.mode === "rfc9421" || !RECORDLESS_HMAC_READ_ONLY_TASKS.has(args.taskType)) {
         const error = new import_errors.ConfigurationError("Could not persist trusted webhook registration for this operation.");
         Object.defineProperty(error, "cause", { value: cause, configurable: true });
@@ -1318,7 +1345,7 @@ class SingleAgentClient {
     return (0, import_jcs.canonicalize)([this.canonicalAccountScope(account), "package", packageId]);
   }
   sameCanonicalOptionRef(left, right) {
-    return left.scope === right.scope && left.format_option_id === right.format_option_id && (left.scope !== "publisher" || right.scope === "publisher" && left.publisher_domain.toLowerCase() === right.publisher_domain.toLowerCase());
+    return (0, import_legacy_routes.sameFormatOptionRef)(left, right);
   }
   rememberCanonicalLegacyRoute(key, route) {
     this.canonicalLegacyRoutes.delete(key);
@@ -1389,20 +1416,7 @@ class SingleAgentClient {
       if (!value || typeof value !== "object" || Array.isArray(value)) continue;
       const product = value;
       if (typeof product.product_id !== "string") continue;
-      const refs = [];
-      for (const optionValue of Array.isArray(product.format_options) ? product.format_options : []) {
-        if (!optionValue || typeof optionValue !== "object" || Array.isArray(optionValue)) continue;
-        const option = optionValue;
-        if (typeof option.format_option_id !== "string") continue;
-        refs.push(
-          typeof option.publisher_domain === "string" ? {
-            scope: "publisher",
-            publisher_domain: option.publisher_domain,
-            format_option_id: option.format_option_id
-          } : { scope: "product", format_option_id: option.format_option_id }
-        );
-      }
-      declared.set(product.product_id, refs);
+      declared.set(product.product_id, (0, import_legacy_routes.sellerDeclaredFormatOptionRefs)(product));
     }
     return declared;
   }
@@ -1822,9 +1836,10 @@ class SingleAgentClient {
    */
   async ensureEndpointDiscovered(options) {
     (0, import_abort2.throwIfAborted)(options?.signal);
+    if (this.config._reuseConfiguredDiscovery?.()) this.synchronizeCapabilityEvidenceAuthorizationScope();
     const needsDiscovery = this.normalizedAgent._needsDiscovery;
     const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
-    const usesScopedFetch = transport?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     if (!needsDiscovery) {
       return this.normalizedAgent;
     }
@@ -1930,7 +1945,7 @@ class SingleAgentClient {
     (0, import_abort2.throwIfAborted)(options?.signal);
     const needsCanonicalUrl = this.normalizedAgent._needsCanonicalUrl;
     const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
-    const usesScopedFetch = transport?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     if (!needsCanonicalUrl) {
       return this.normalizedAgent;
     }
@@ -1949,8 +1964,11 @@ class SingleAgentClient {
         signal: options?.signal
       });
     }
+    const canonicalEpoch = this.discoveryEpochSnapshot(options);
     const canonicalUrl = await this.fetchA2ACanonicalUrl(this.normalizedAgent.agent_uri, options);
-    if (!usesScopedFetch) this.canonicalBaseUrl = canonicalUrl;
+    if (!usesScopedFetch && (!canonicalEpoch || this.discoveryEpochIs(canonicalEpoch))) {
+      this.canonicalBaseUrl = canonicalUrl;
+    }
     return {
       ...this.normalizedAgent,
       agent_uri: canonicalUrl
@@ -2075,7 +2093,9 @@ class SingleAgentClient {
     const { connectMCPWithFallback } = await import("../protocols/mcp.js");
     const { probeModernMCPConnection } = await import("../protocols/mcp-modern.js");
     const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
-    const usesScopedFetch = transport?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
+    const endpointEpoch = this.discoveryEpochSnapshot(options);
+    const mayRetain = () => !usesScopedFetch && (!endpointEpoch || this.discoveryEpochIs(endpointEpoch));
     const authToken = this.normalizedAgent.oauth_client_credentials ? this.normalizedAgent.oauth_tokens?.access_token : this.agent.auth_token;
     const agentHeaders = this.agent.headers;
     const authHeaders = (0, import_auth.createMCPRequestHeaders)(agentHeaders, authToken);
@@ -2095,7 +2115,7 @@ class SingleAgentClient {
           allowPrivateIp: transport?.allowPrivateIp
         });
         if (modern.connected) {
-          if (!usesScopedFetch) {
+          if (mayRetain()) {
             this.discoveredMcpEra = modern.era;
             this.discoveredMcpEraAt = Date.now();
           }
@@ -2114,7 +2134,7 @@ class SingleAgentClient {
           }
         );
         await client.close();
-        if (!usesScopedFetch) {
+        if (mayRetain()) {
           this.discoveredMcpEra = "legacy";
           this.discoveredMcpEraAt = Date.now();
         }
@@ -2291,7 +2311,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   async verifyAndParseWebhook(options) {
     const rawBody = options.rawBody ?? rawBodyFromUnknown(options.body);
     const authHeaders = inspectWebhookAuthenticationHeaders(options.headers, options.signature, options.timestamp);
-    const trustedOperationId = options.operationId && options.operationId !== "unknown" ? options.operationId : void 0;
+    let trustedOperationId = options.operationId && options.operationId !== "unknown" ? options.operationId : void 0;
     let registration;
     if (trustedOperationId) {
       let stored;
@@ -2332,6 +2352,24 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         }
       }
     }
+    if (!registration && options.requestUrl && ["media_buy_delivery", "artifact_delivery"].includes(options.taskType ?? "")) {
+      const kind = options.taskType === "artifact_delivery" ? "artifact" : "reporting";
+      const routeId = (0, import_webhook_registration.deliveryWebhookRegistrationId)(kind, options.requestUrl);
+      try {
+        const stored = await this.webhookRegistrationStore.get(this.agent.id, routeId);
+        if (stored) {
+          registration = (0, import_webhook_registration.parseWebhookRegistration)(stored, { agentId: this.agent.id, operationId: routeId });
+          trustedOperationId = routeId;
+        }
+      } catch (cause) {
+        return {
+          ok: false,
+          code: "webhook_registration_store_unavailable",
+          message: "Delivery registration state is unavailable",
+          cause
+        };
+      }
+    }
     if (registration) {
       const nowMs = this.config.webhookVerification?.now ? Math.floor(this.config.webhookVerification.now() * 1e3) : Date.now();
       if (registration.expiresAt <= nowMs) registration = void 0;
@@ -2412,6 +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, WebBotAuthUnavailableError } = loadWebBotAuth();
       const requestMethod = options.requestMethod;
       const requestUrl = options.requestUrl;
       if (rawBody === void 0 || !options.headers || !trustedOperationId || !requestMethod || !requestUrl) {
@@ -2424,28 +2463,81 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       const normalizedHeaders = normalizeRfc9421WebhookHeaders(options.headers);
       if (!normalizedHeaders.ok) return normalizedHeaders.failure;
       try {
-        const delegatedOperatorAuthorization = this.delegatedOperatorAuthorizationForRegistration(registration);
-        await (0, import_server.verifyWebhookSignature)(
-          {
-            method: requestMethod,
-            url: requestUrl,
-            headers: normalizedHeaders.headers,
-            body: rawBody
-          },
-          {
-            jwks: this.webhookJwksFor(registration),
-            publisherPins: await this.config.webhookVerification?.publisherPins?.(registration),
-            onKeyResolutionError: this.config.webhookVerification?.onKeyResolutionError,
-            replayStore: this.webhookReplayStore,
-            revocationStore: this.webhookRevocationStore,
-            ...this.config.webhookVerification?.now && { now: this.config.webhookVerification.now },
-            agentUrlForKeyid: () => registration.agentUrl,
-            ...registration.authorizationContextVersion === 1 && {
-              replayScopeBinding: `delegated-operator:v1:${crypto.createHash("sha256").update((0, import_webhook_registration.canonicalDelegatedOperatorAuthorization)(delegatedOperatorAuthorization)).digest("base64url")}`
+        const actualProfile = selectSignatureProfile({ headers: normalizedHeaders.headers });
+        if (registration.signingProfile === "web-bot-auth") {
+          if (registration.delegatedOperatorAuthorization || await this.config.webhookVerification?.publisherPins?.(registration))
+            throw new WebBotAuthError(403, "legacy_webhook_authorization_requires_rfc_profile");
+          const config = this.config.webhookVerification?.webBotAuth;
+          if (!config) throw new WebBotAuthError(403, "webhook_profile_not_configured");
+          const signers = await verifyWebBotAuth(
+            {
+              method: requestMethod,
+              url: requestUrl,
+              headers: normalizedHeaders.headers,
+              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,
+              ...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);
+          await (0, import_server.verifyWebhookSignature)(
+            {
+              method: requestMethod,
+              url: requestUrl,
+              headers: normalizedHeaders.headers,
+              body: rawBody
+            },
+            {
+              jwks: this.webhookJwksFor(registration),
+              publisherPins: await this.config.webhookVerification?.publisherPins?.(registration),
+              onKeyResolutionError: this.config.webhookVerification?.onKeyResolutionError,
+              replayStore: this.webhookReplayStore,
+              revocationStore: this.webhookRevocationStore,
+              ...this.config.webhookVerification?.now && { now: this.config.webhookVerification.now },
+              agentUrlForKeyid: () => registration.agentUrl,
+              ...registration.authorizationContextVersion === 1 && {
+                replayScopeBinding: `delegated-operator:v1:${crypto.createHash("sha256").update((0, import_webhook_registration.canonicalDelegatedOperatorAuthorization)(delegatedOperatorAuthorization)).digest("base64url")}`
+              }
+            }
+          );
+        }
       } 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",
+              "directory_fetch_limit",
+              "directory_expired",
+              "identity_unverified",
+              "verification_unavailable"
+            ].includes(cause.reason) ? "webhook_verification_unavailable" : "webhook_signature_invalid",
+            message: cause.message,
+            cause
+          };
         if (cause instanceof import_server.WebhookSignatureError) {
           if (cause.retryable)
             return {
@@ -2525,6 +2617,45 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if (!parsedPayload.ok) {
       return parsedPayload;
     }
+    if (registration?.deliveryKind) {
+      const loader = require('../validation/schema-loader.js');
+      const body = parsedPayload.payload;
+      const isReport = registration.deliveryKind === "reporting";
+      const payload = isReport ? body.result : body;
+      const schemaRef = isReport ? "media-buy/media-buy-delivery-webhook-result.json" : "content-standards/artifact-webhook-payload.json";
+      const validator = loader.getSchemaValidatorByRef(schemaRef, this.resolvedAdcpVersion);
+      const envelopeValidator = isReport ? loader.getSchemaValidatorByRef("core/mcp-webhook-payload.json", this.resolvedAdcpVersion) : void 0;
+      if (!validator || !validator(payload) || isReport && (!envelopeValidator || !envelopeValidator(body) || body.task_type !== "media_buy_delivery"))
+        return {
+          ok: false,
+          code: "webhook_envelope_invalid",
+          message: "Authenticated delivery does not match its registered payload kind"
+        };
+      const taskId = isReport && typeof body.task_id === "string" ? body.task_id : typeof body.media_buy_id === "string" ? body.media_buy_id : registration.operationId;
+      const operationId = isReport && typeof body.operation_id === "string" ? body.operation_id : registration.operationId;
+      const status = isReport && (0, import_task_status.isAdcpStatus)(body.status) ? body.status : "completed";
+      return {
+        ok: true,
+        protocol: registration.protocol,
+        envelope: isReport ? body : {
+          ...body,
+          task_type: registration.taskType,
+          operation_id: operationId,
+          task_id: taskId,
+          status,
+          result: payload
+        },
+        result: payload,
+        metadata: {
+          taskId,
+          taskType: registration.taskType,
+          operationId,
+          status,
+          ...typeof body.timestamp === "string" && { timestamp: body.timestamp },
+          ...typeof body.idempotency_key === "string" && { idempotencyKey: body.idempotency_key }
+        }
+      };
+    }
     const topLevelTaskType = isObjectRecord(parsedPayload.payload) && typeof parsedPayload.payload.task_type === "string" ? parsedPayload.payload.task_type : void 0;
     const payloadRecord = isObjectRecord(parsedPayload.payload) ? parsedPayload.payload : void 0;
     const signedRoute = extractSignedWebhookRoute(parsedPayload.payload);
@@ -3286,7 +3417,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if (!options?.skipIdempotencyAutoInject && !options?.preserveGovernedPayload && (0, import_idempotency.requestUsesIdempotency)(taskType, normalizedParams) && normalizedParams && typeof normalizedParams === "object" && !normalizedParams.idempotency_key) {
       normalizedParams = { ...normalizedParams, idempotency_key: (0, import_idempotency.generateIdempotencyKey)() };
     }
-    if (!options?.skipIdempotencyAutoInject && !options?.skipAccountValidation && !options?.skipRequestValidation && !options?.preserveGovernedPayload && !(0, import_schema_loader.isExternalSchemaRootActive)(this.resolvedAdcpVersion)) {
+    if (!options?.skipIdempotencyAutoInject && !options?.skipAccountValidation && !options?.skipRequestValidation && !options?.preserveGovernedPayload && !(0, import_schema_loader2.isExternalSchemaRootActive)(this.resolvedAdcpVersion)) {
       this.validateRequest(taskType, normalizedParams);
     }
     await this.validateTaskFeatures(taskType, options);
@@ -4379,7 +4510,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       const filtered = {};
       const schemaStripped = [];
       for (const [key, value] of Object.entries(adapted)) {
-        if (declaredFields.has(key) || envelopeFields.has(key) || (0, import_schema_loader.schemaAllowsTopLevelField)(taskType, key, this.resolvedAdcpVersion)) {
+        if (declaredFields.has(key) || envelopeFields.has(key) || (0, import_schema_loader2.schemaAllowsTopLevelField)(taskType, key, this.resolvedAdcpVersion)) {
           filtered[key] = value;
         } else {
           schemaStripped.push(key);
@@ -4714,6 +4845,8 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       params.account
     );
     const hasCreativeFormatData = hasMediaBuyCreativeFormatData(params);
+    if (this.config.experimentalIdentity33) await this.getCapabilities(taskOptions);
+    const signed33Webhooks = this.usesSigned33Webhooks();
     if (this.config.webhookUrlTemplate && !options?.disableWebhook) {
       const now = /* @__PURE__ */ new Date();
       const year = now.getUTCFullYear();
@@ -4734,12 +4867,17 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           const consumerAuth = consumerReportingWebhook?.authentication;
           const consumerUrl = consumerReportingWebhook?.url;
           const consumerFrequency = consumerReportingWebhook?.reporting_frequency;
-          const defaultAuth = this.config.webhookSecret ? { schemes: ["HMAC-SHA256"], credentials: this.config.webhookSecret } : void 0;
+          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 (resolvedAuth === void 0 || resolvedAuth === null) {
+          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 for all of AdCP 3.x, 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."
+                "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."
               );
             }
             warnReportingWebhookNeedsSecret();
@@ -4755,9 +4893,20 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
                 ...consumerReportingWebhook,
                 url: consumerUrl !== void 0 ? consumerUrl : deliveryWebhookUrl,
                 reporting_frequency: consumerFrequency !== void 0 ? consumerFrequency : libraryDefaults.reporting_frequency,
-                authentication: resolvedAuth
+                ...resolvedAuth !== void 0 && { authentication: resolvedAuth },
+                ...resolvedAuth === void 0 && this.selectedWebhookSigningProfile() && { signing_profile: this.selectedWebhookSigningProfile() }
               }
             };
+            if (signed33Webhooks && resolvedAuth === void 0 && consumerUrl === void 0) {
+              await this.persistWebhookRegistration({
+                agent: this.normalizedAgent,
+                taskType: "media_buy_delivery",
+                operationId,
+                callbackUrl: deliveryWebhookUrl,
+                mode: "rfc9421",
+                signingProfile: this.selectedWebhookSigningProfile()
+              });
+            }
           }
         }
       }
@@ -5012,7 +5161,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       ...options,
       [CAPABILITY_DISCOVERY_CONTEXT]: discoveryContext
     });
-    const usesScopedFetch = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport)?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     const toolSchemas = discoveryContext.toolSchemas ?? (usesScopedFetch ? void 0 : this.cachedToolSchemas);
     const wireRelease = this.config.wireAdcpVersion ?? this.resolvedAdcpVersion;
     const declared = (0, import_creative_delivery.resolveCreativeFormatWireMode)(capabilities, wireRelease);
@@ -5046,7 +5195,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if ((0, import_idempotency.requestUsesIdempotency)(taskType, normalizedParams) && normalizedParams && typeof normalizedParams === "object" && !normalizedParams.idempotency_key) {
       normalizedParams = { ...normalizedParams, idempotency_key: (0, import_idempotency.generateIdempotencyKey)() };
     }
-    if (!(0, import_schema_loader.isExternalSchemaRootActive)(this.resolvedAdcpVersion)) {
+    if (!(0, import_schema_loader2.isExternalSchemaRootActive)(this.resolvedAdcpVersion)) {
       this.validateRequest(taskType, normalizedParams);
     }
   }
@@ -5327,15 +5476,23 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     );
   }
   async getAdcpCapabilitiesWithinDeadline(params, inputHandler, options) {
+    const scopeKey = this.config._reuseConfiguredDiscovery?.() ? this.getCapabilityEvidenceScope().scopeKey : void 0;
     const agent = await this.ensureEndpointDiscovered(options);
     this.executor.validateRequest("get_adcp_capabilities", params);
-    return this.executor.executeTask(
+    const result = await this.executor.executeTask(
       agent,
       "get_adcp_capabilities",
       params,
       inputHandler,
       options
     );
+    if (this.config._reuseConfiguredDiscovery?.() && !this.usesScopedDiscoveryTransport(options) && scopeKey === this.getCapabilityEvidenceScope().scopeKey && Object.keys(params).length === 0 && this.runAgentInfo !== void 0 && result.success && result.data && (0, import_capabilities.looksLikeV3Capabilities)(result.data)) {
+      const capabilities = (0, import_capabilities.parseCapabilitiesResponse)(structuredClone(result.data));
+      if (!capabilities._synthetic) {
+        this.cachedCapabilities = (0, import_capabilities.augmentCapabilitiesFromTools)(capabilities, this.runAgentInfo.tools);
+      }
+    }
+    return result;
   }
   // ====== CREATIVE BUILD TASKS ======
   /**
@@ -6433,6 +6590,25 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getAgentInfo(options) {
+    (0, import_abort2.throwIfAborted)(options?.signal);
+    const reuse = this.config._reuseConfiguredDiscovery?.() && !this.usesScopedDiscoveryTransport(options);
+    if (!reuse) return this.getAgentInfoLive(options);
+    const scopeKey = this.getCapabilityEvidenceScope().scopeKey;
+    if (this.runAgentInfo) return structuredClone(this.runAgentInfo);
+    const info = await this.getAgentInfoLive(options);
+    if (reuse && scopeKey === this.getCapabilityEvidenceScope().scopeKey) {
+      this.runAgentInfo = structuredClone(info);
+      const documents = new Map(
+        this.runAgentInfo.tools.filter((tool) => tool.inputSchema).map((tool) => [tool.name, tool.inputSchema])
+      );
+      this.cachedToolSchemas = new Map(
+        [...documents].map(([name, schema]) => [name, schema.properties ?? {}])
+      );
+      toolInputSchemasByProperties.set(this.cachedToolSchemas, documents);
+    }
+    return info;
+  }
+  async getAgentInfoLive(options) {
     const { withResponseSizeLimit } = await import("../protocols/responseSizeLimit.js");
     (0, import_abort2.throwIfAborted)(options?.signal);
     const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
@@ -6666,7 +6842,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     this.synchronizeCapabilityEvidenceAuthorizationScope();
     const discoveryContext = options?.[CAPABILITY_DISCOVERY_CONTEXT];
     const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
-    const usesScopedFetch = transport?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     if (this.primedCapabilitiesExpiresAt !== void 0 && this.primedCapabilitiesExpiresAt <= Date.now()) {
       this.cachedCapabilities = void 0;
       this.cachedToolSchemas = void 0;
@@ -6945,10 +7121,25 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     }
     if (current === this.capabilityEvidenceAuthMaterial) return;
     this.capabilityEvidenceAuthMaterial = current;
+    this.discoveryEpoch++;
+    this.runAgentInfo = void 0;
     this.cachedCapabilities = void 0;
     this.cachedToolSchemas = void 0;
     this.primedCapabilitiesExpiresAt = void 0;
     this.capabilityEvidenceScopeKey = (0, import_node_crypto.randomUUID)();
+    if (this.config._reuseConfiguredDiscovery?.()) {
+      this.discoveredEndpoint = void 0;
+      this.discoveredAgent = void 0;
+      this.canonicalBaseUrl = void 0;
+      this.discoveredMcpEra = void 0;
+    }
+  }
+  /** A comply() run owns its configured fetch; per-call transport changes still discover separately. */
+  usesScopedDiscoveryTransport(options) {
+    const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
+    if (!this.config._reuseConfiguredDiscovery?.()) return transport?.trustedFetchFn !== void 0;
+    const configured = (0, import_protocols.normalizeTransportOptions)(this.config.transport);
+    return transport?.trustedFetchFn !== configured?.trustedFetchFn || transport?.allowPrivateIp !== configured?.allowPrivateIp || transport?.maxResponseBytes !== configured?.maxResponseBytes || transport?.requestTimeoutMs !== configured?.requestTimeoutMs || transport?.legacyCompat?.enabled !== configured?.legacyCompat?.enabled;
   }
   /**
    * Reuse a fresh capability observation made by the embedding application.
@@ -6971,7 +7162,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     const hasValidToolSchemas = snapshot?.toolSchemas === void 0 || typeof snapshot.toolSchemas === "object" && snapshot.toolSchemas !== null && Object.values(snapshot.toolSchemas).every(
       (properties) => typeof properties === "object" && properties !== null && !Array.isArray(properties)
     );
-    const configuredScopedFetch = (0, import_protocols.normalizeTransportOptions)(this.config.transport)?.trustedFetchFn !== void 0;
+    const configuredScopedFetch = this.usesScopedDiscoveryTransport();
     const hasToolEvidence = snapshot?.toolSchemas !== void 0 || Array.isArray(capabilities?.discoveredTools);
     if (!matchesScope || !isFresh || !hasCapabilities || !hasValidToolSchemas || !hasToolEvidence || configuredScopedFetch) {
       this.cachedCapabilities = void 0;
@@ -7014,11 +7205,13 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   /** Epoch of this client's evidence for the call's effective shared key; `undefined` without a shared cache. */
   discoveryEpochSnapshot(options) {
     const key = this.sharedDiscoveryKey(options);
-    if (!key || !this.config.discoveryCache) return void 0;
+    if (!key || !this.config.discoveryCache) {
+      return this.config._reuseConfiguredDiscovery?.() ? { local: this.discoveryEpoch, shared: 0, key: "" } : void 0;
+    }
     return { local: this.discoveryEpoch, shared: this.sharedInvalidationEpoch(key), key };
   }
   discoveryEpochIs(epoch) {
-    return epoch.local === this.discoveryEpoch && epoch.shared === this.sharedInvalidationEpoch(epoch.key);
+    return epoch.local === this.discoveryEpoch && (!epoch.key || epoch.shared === this.sharedInvalidationEpoch(epoch.key));
   }
   /** The latest invalidation that applies to `key`: its own, combined with the cache's floor of forgotten ones. */
   sharedInvalidationRecord(key) {
@@ -7327,6 +7520,8 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * seller answers with a version or capability error.
    */
   async invalidateDiscoveryCache(options) {
+    this.runAgentInfo = void 0;
+    if (this.config._reuseConfiguredDiscovery?.()) this.canonicalBaseUrl = void 0;
     this.cachedCapabilities = void 0;
     this.cachedToolSchemas = void 0;
     this.primedCapabilitiesExpiresAt = void 0;
@@ -7874,7 +8069,29 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * injected fields before the adapter gets a chance to clean them up, so
    * the two passes have to agree on "extra keys are fine."
    */
+  usesIdentity33Schemas() {
+    return this.config.experimentalIdentity33 === true && this.cachedCapabilities?._synthetic === false && (0, import_adcp_version_config.isAdcpVersionAtLeast)(this.cachedCapabilities.servedVersion, "3.3.0");
+  }
+  usesSigned33Webhooks() {
+    const capabilities = this.cachedCapabilities;
+    return this.config.experimentalIdentity33 === true && capabilities?._synthetic === false && (0, import_adcp_version_config.isAdcpVersionAtLeast)(capabilities.servedVersion, "3.3.0") && capabilities._raw?.webhook_signing?.supported === true;
+  }
+  selectedWebhookSigningProfile() {
+    if (!this.usesSigned33Webhooks()) return void 0;
+    const advertisement = this.cachedCapabilities?._raw?.webhook_signing;
+    const profile = this.config.webhookSigningProfile ?? (advertisement?.profile === "web-bot-auth" || advertisement?.profiles?.length === 1 && advertisement.profiles[0] === "web-bot-auth" ? "web-bot-auth" : "adcp/webhook-signing/v1");
+    if (profile === "web-bot-auth" && !advertisement?.profiles?.includes(profile))
+      throw new import_errors.ConfigurationError(
+        "Seller did not advertise the selected Web Bot Auth webhook profile",
+        "webhookSigningProfile"
+      );
+    return profile;
+  }
   validateRequest(taskType, params) {
+    if (this.config.experimentalIdentity33 && this.usesIdentity33Schemas()) {
+      this.executor.validateRequest(taskType, params);
+      return;
+    }
     const schema = this.getRequestSchema(taskType);
     if (!schema) {
       return;
@@ -7991,6 +8208,7 @@ function normalizeRfc9421WebhookHeaders(headers) {
   const singletonHeaders = /* @__PURE__ */ new Set([
     "signature",
     "signature-input",
+    "signature-agent",
     "content-digest",
     "content-type",
     "x-adcp-signature",