@adcp/sdk 15.9.1 → 16.0.0-beta.2

package/dist/lib/core/SingleAgentClient.mjs

@@ -3,6 +3,15 @@ import { dirname as __adcpDirname } from "node:path";
 import { createRequire as __adcpCreateRequire } from "node:module";
 const __dirname = __adcpDirname(__adcpFileURLToPath(import.meta.url));
 const require2 = __adcpCreateRequire(import.meta.url);
+import {
+  isIdentity33SchemaScope,
+  withIdentity33SchemaScope,
+  bindIdentity33SchemaScope
+} from "../validation/schema-loader.mjs";
+function loadWebBotAuth() {
+  return require2("../signing/web-bot-auth");
+}
+import { canonicalAgentOrigin } from "../signing/agent-resolver/canonicalize.mjs";
 import {
   annotateProductsSupplyPaths
 } from "../supply-path/products.mjs";
@@ -74,6 +83,7 @@ import {
   canonicalDelegatedOperatorAuthorization,
   InMemoryWebhookRegistrationStore,
   parseWebhookRegistration,
+  deliveryWebhookRegistrationId,
   sameWebhookRegistration,
   WebhookRegistrationIntegrityError,
   validateWebhookRegistrationAuthorization
@@ -168,6 +178,8 @@ import {
 } from "../v2/projection/creative-delivery.mjs";
 import {
   formatOptionOriginFromRoutes,
+  sameFormatOptionRef,
+  sellerDeclaredFormatOptionRefs,
   undeclaredFormatOptionSelector
 } from "../v2/projection/legacy-routes.mjs";
 import {
@@ -826,6 +838,11 @@ class SingleAgentClient {
   constructor(agent, config = {}) {
     this.agent = agent;
     this.config = config;
+    if (config.experimentalIdentity33 === true !== isIdentity33SchemaScope())
+      return withIdentity33SchemaScope(() => {
+        const instance = Reflect.construct(SingleAgentClient, [agent, config], new.target);
+        return config.experimentalIdentity33 ? 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,
@@ -840,7 +857,9 @@ class SingleAgentClient {
     };
     config = this.config;
     validateAgentDiscoveryCacheConfig(config.discoveryCache);
-    this.resolvedAdcpVersion = resolveAdcpVersion(config.adcpVersion);
+    this.resolvedAdcpVersion = resolveAdcpVersion(
+      config.adcpVersion ?? (config.experimentalIdentity33 ? "3.3" : void 0)
+    );
     this.webhookRegistrationStore = config.webhookRegistrationStore ?? new InMemoryWebhookRegistrationStore();
     this.webhookReplayStore = config.webhookVerification?.replayStore ?? new InMemoryReplayStore();
     this.webhookRevocationStore = config.webhookVerification?.revocationStore ?? new InMemoryRevocationStore();
@@ -899,6 +918,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,
@@ -1154,6 +1177,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;
@@ -1210,18 +1234,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 ? 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 },
@@ -1230,6 +1254,14 @@ class SingleAgentClient {
     };
     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 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 || !sameWebhookRegistration(
@@ -1241,6 +1273,8 @@ class SingleAgentClient {
         );
       }
     } catch (cause) {
+      if (args.deliveryKind && cause instanceof 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 ConfigurationError("Could not persist trusted webhook registration for this operation.");
         Object.defineProperty(error, "cause", { value: cause, configurable: true });
@@ -1402,7 +1436,7 @@ class SingleAgentClient {
     return canonicalizeJson([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 sameFormatOptionRef(left, right);
   }
   rememberCanonicalLegacyRoute(key, route) {
     this.canonicalLegacyRoutes.delete(key);
@@ -1473,20 +1507,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, sellerDeclaredFormatOptionRefs(product));
     }
     return declared;
   }
@@ -1906,9 +1927,10 @@ class SingleAgentClient {
    */
   async ensureEndpointDiscovered(options) {
     throwIfAborted(options?.signal);
+    if (this.config._reuseConfiguredDiscovery?.()) this.synchronizeCapabilityEvidenceAuthorizationScope();
     const needsDiscovery = this.normalizedAgent._needsDiscovery;
     const transport = normalizeTransportOptions(options?.transport ?? this.config.transport);
-    const usesScopedFetch = transport?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     if (!needsDiscovery) {
       return this.normalizedAgent;
     }
@@ -2014,7 +2036,7 @@ class SingleAgentClient {
     throwIfAborted(options?.signal);
     const needsCanonicalUrl = this.normalizedAgent._needsCanonicalUrl;
     const transport = normalizeTransportOptions(options?.transport ?? this.config.transport);
-    const usesScopedFetch = transport?.trustedFetchFn !== void 0;
+    const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     if (!needsCanonicalUrl) {
       return this.normalizedAgent;
     }
@@ -2033,8 +2055,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
@@ -2159,7 +2184,9 @@ class SingleAgentClient {
     const { connectMCPWithFallback } = await import("../protocols/mcp.mjs");
     const { probeModernMCPConnection } = await import("../protocols/mcp-modern.mjs");
     const transport = 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 = createMCPRequestHeaders(agentHeaders, authToken);
@@ -2179,7 +2206,7 @@ class SingleAgentClient {
           allowPrivateIp: transport?.allowPrivateIp
         });
         if (modern.connected) {
-          if (!usesScopedFetch) {
+          if (mayRetain()) {
             this.discoveredMcpEra = modern.era;
             this.discoveredMcpEraAt = Date.now();
           }
@@ -2198,7 +2225,7 @@ class SingleAgentClient {
           }
         );
         await client.close();
-        if (!usesScopedFetch) {
+        if (mayRetain()) {
           this.discoveredMcpEra = "legacy";
           this.discoveredMcpEraAt = Date.now();
         }
@@ -2375,7 +2402,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;
@@ -2416,6 +2443,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 = deliveryWebhookRegistrationId(kind, options.requestUrl);
+      try {
+        const stored = await this.webhookRegistrationStore.get(this.agent.id, routeId);
+        if (stored) {
+          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;
@@ -2496,6 +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, WebBotAuthUnavailableError } = loadWebBotAuth();
       const requestMethod = options.requestMethod;
       const requestUrl = options.requestUrl;
       if (rawBody === void 0 || !options.headers || !trustedOperationId || !requestMethod || !requestUrl) {
@@ -2508,28 +2554,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 verifyRfc9421WebhookSignature(
-          {
-            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(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 !== 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 verifyRfc9421WebhookSignature(
+            {
+              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(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 WebhookSignatureError) {
           if (cause.retryable)
             return {
@@ -2609,6 +2708,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 = require2("../validation/schema-loader");
+      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 && 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);
@@ -4798,6 +4936,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();
@@ -4818,12 +4958,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();
@@ -4839,9 +4984,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()
+              });
+            }
           }
         }
       }
@@ -5096,7 +5252,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       ...options,
       [CAPABILITY_DISCOVERY_CONTEXT]: discoveryContext
     });
-    const usesScopedFetch = 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 = resolveCreativeFormatWireMode(capabilities, wireRelease);
@@ -5411,15 +5567,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 && looksLikeV3Capabilities(result.data)) {
+      const capabilities = parseCapabilitiesResponse(structuredClone(result.data));
+      if (!capabilities._synthetic) {
+        this.cachedCapabilities = augmentCapabilitiesFromTools(capabilities, this.runAgentInfo.tools);
+      }
+    }
+    return result;
   }
   // ====== CREATIVE BUILD TASKS ======
   /**
@@ -6517,6 +6681,25 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getAgentInfo(options) {
+    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.mjs");
     throwIfAborted(options?.signal);
     const transport = normalizeTransportOptions(options?.transport ?? this.config.transport);
@@ -6750,7 +6933,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 = 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;
@@ -7029,10 +7212,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 = 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 = normalizeTransportOptions(options?.transport ?? this.config.transport);
+    if (!this.config._reuseConfiguredDiscovery?.()) return transport?.trustedFetchFn !== void 0;
+    const configured = 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.
@@ -7055,7 +7253,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 = 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;
@@ -7098,11 +7296,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) {
@@ -7411,6 +7611,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;
@@ -7958,7 +8160,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 && isAdcpVersionAtLeast(this.cachedCapabilities.servedVersion, "3.3.0");
+  }
+  usesSigned33Webhooks() {
+    const capabilities = this.cachedCapabilities;
+    return this.config.experimentalIdentity33 === true && capabilities?._synthetic === false && 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 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;
@@ -8075,6 +8299,7 @@ function normalizeRfc9421WebhookHeaders(headers) {
   const singletonHeaders = /* @__PURE__ */ new Set([
     "signature",
     "signature-input",
+    "signature-agent",
     "content-digest",
     "content-type",
     "x-adcp-signature",

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

@@ -154,6 +154,10 @@ export declare class TaskExecutor {
         agentId?: string;
         /** Webhook secret for legacy HMAC authentication. */
         webhookSecret?: string;
+        experimentalIdentity33?: () => boolean;
+        signedIdentity33Webhooks?: () => boolean;
+        identity33SchemaExperiment?: boolean;
+        webhookSigningProfile?: () => 'adcp/webhook-signing/v1' | 'web-bot-auth' | undefined;
         /** Persist sanitized callback mode provenance before dispatch. */
         onWebhookRegistration?: (registration: {
             agent: AgentConfig;
@@ -161,6 +165,8 @@ export declare class TaskExecutor {
             operationId: string;
             callbackUrl: string;
             mode: 'rfc9421' | 'hmac-sha256';
+            signingProfile?: 'adcp/webhook-signing/v1' | 'web-bot-auth';
+            deliveryKind?: 'reporting' | 'artifact';
             delegatedOperatorAuthorization?: TaskOptions['delegatedOperatorAuthorization'];
         }) => void | Promise<void>;
         /** Persist fail-closed routing provenance before a durable mutation claim can run. */

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

@@ -154,6 +154,10 @@ export declare class TaskExecutor {
         agentId?: string;
         /** Webhook secret for legacy HMAC authentication. */
         webhookSecret?: string;
+        experimentalIdentity33?: () => boolean;
+        signedIdentity33Webhooks?: () => boolean;
+        identity33SchemaExperiment?: boolean;
+        webhookSigningProfile?: () => 'adcp/webhook-signing/v1' | 'web-bot-auth' | undefined;
         /** Persist sanitized callback mode provenance before dispatch. */
         onWebhookRegistration?: (registration: {
             agent: AgentConfig;
@@ -161,6 +165,8 @@ export declare class TaskExecutor {
             operationId: string;
             callbackUrl: string;
             mode: 'rfc9421' | 'hmac-sha256';
+            signingProfile?: 'adcp/webhook-signing/v1' | 'web-bot-auth';
+            deliveryKind?: 'reporting' | 'artifact';
             delegatedOperatorAuthorization?: TaskOptions['delegatedOperatorAuthorization'];
         }) => void | Promise<void>;
         /** Persist fail-closed routing provenance before a durable mutation claim can run. */