@adcp/sdk 15.9.1 → 16.0.0-beta.2

package/dist/lib/server/create-adcp-server.js

@@ -30,11 +30,18 @@ __export(create_adcp_server_exports, {
   requireSessionKey: () => requireSessionKey
 });
 module.exports = __toCommonJS(create_adcp_server_exports);
+var import_web_bot_auth = require('../signing/web-bot-auth.js');
+var import_schema_loader = require('../validation/schema-loader.js');
+var import_lifecycle = require('../identity-3.3/lifecycle.js');
+var import_server = require('../identity-3.3/server.js');
+var import_web_bot_auth2 = require('../signing/web-bot-auth.js');
+var import_validation = require('../identity-3.3/validation.js');
+var import_trust = require('../identity-3.3/trust.js');
 var import_zod = require("zod");
 var import_version = require('../version.js');
 var import_adcp_version_config = require('../utils/adcp-version-config.js');
 var import_errors = require('../errors/index.js');
-var import_schema_loader = require('../validation/schema-loader.js');
+var import_schema_loader2 = require('../validation/schema-loader.js');
 var import_schemas = require('../schemas/index.js');
 var import_enums = require('../types/enums.generated.js');
 var import_protocols = require('../protocols/index.js');
@@ -680,10 +687,12 @@ function restoreSyncAccountEnvelopeErrorIndices(response, acceptedIndices) {
   syncContentJsonText(restored, restored.structuredContent, mirrorsStructuredContent);
   return restored;
 }
-function validateFrameworkPayload(toolName, direction, payload, version, proposalCapabilities) {
+function validateFrameworkPayload(toolName, direction, payload, version, proposalCapabilities, identity33 = false) {
   if (toolName === "sync_reporting_status" && direction === "request") {
     return (0, import_sync_reporting_status_envelope.validateSyncReportingStatusEnvelope)(payload, version);
   }
+  if (identity33 && toolName !== "refine_proposals" && toolName !== "sync_reporting_status")
+    return (0, import_validation.validateIdentity33Payload)(toolName, direction, payload, version);
   if (toolName !== "refine_proposals") {
     return direction === "request" ? (0, import_schema_validator.validateRequest)(toolName, payload, version) : (0, import_schema_validator.validateResponse)(toolName, payload, version);
   }
@@ -947,7 +956,7 @@ function projectValueToCapabilitySchema(root, schema, value, depth = 0) {
   return projectedObject;
 }
 function projectCapabilitiesToVersion(data, version) {
-  const validator = (0, import_schema_loader.getValidator)("get_adcp_capabilities", "sync", version);
+  const validator = (0, import_schema_loader2.getValidator)("get_adcp_capabilities", "sync", version);
   const schema = asProjectionSchema(validator?.schema);
   if (!schema) return data;
   const projected = projectValueToCapabilitySchema(schema, schema, data);
@@ -1419,6 +1428,15 @@ function resolveEffectiveSignedRequestPolicy(signedRequests, capabilityRequestSi
   };
 }
 function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning, adcpVersion) {
+  const legacyOriginGate = signedRequests.assertLegacyOriginAllowed ?? (0, import_web_bot_auth.getWebBotAuthLegacyOriginGate)(signedRequests.webBotAuth?.resolvePrincipal);
+  if (signedRequests.webBotAuth && !legacyOriginGate)
+    throw new Error(
+      "Web Bot Auth requires an origin-binding migration fence; use createIdentity33PrincipalResolver or supply assertLegacyOriginAllowed"
+    );
+  if (signedRequests.webBotAuth && !signedRequests.webBotAuth.isRevoked && !(0, import_web_bot_auth2.isWebBotAuthRevocationChecked)(signedRequests.webBotAuth.resolvePrincipal))
+    throw new Error(
+      "Web Bot Auth requires origin revocation: use createIdentity33PrincipalResolver({ revocation }) or supply isRevoked"
+    );
   const requiredFor = effectiveRequestSigning.required_for ?? [];
   const verifier = (0, import_middleware.createExpressVerifier)({
     capability: {
@@ -1440,6 +1458,66 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
   return async function adcpPreTransport(req, res) {
     const serveContext = (0, import_auth.getServeRequestContext)(req);
     const canonicalPublicUrl = serveContext?.publicUrl ? new URL(serveContext.publicUrl) : void 0;
+    if ((0, import_web_bot_auth2.selectSignatureProfile)({ headers: req.headers }) === "web-bot-auth") {
+      try {
+        if (!signedRequests.webBotAuth || !canonicalPublicUrl) throw new import_web_bot_auth2.WebBotAuthError(403, "profile_disabled");
+        if (req.method !== "GET" && req.rawBody === void 0) throw new import_web_bot_auth2.WebBotAuthError(403, "raw_body_missing");
+        const requestTarget = canonicalPublicUrl.origin + (req.url?.startsWith("/") ? req.url : "/" + (req.url ?? ""));
+        const signers = await (0, import_web_bot_auth2.verifyWebBotAuth)(
+          { method: req.method ?? "POST", url: requestTarget, headers: req.headers, body: req.rawBody ?? "" },
+          {
+            // Identity verification needs only key discovery and replay state;
+            // revocation and binding belong to the principal resolver.
+            directory: signedRequests.webBotAuth.directory,
+            replayStore: signedRequests.replayStore,
+            ...signedRequests.webBotAuth.isRevoked && { isRevoked: signedRequests.webBotAuth.isRevoked }
+          }
+        );
+        const operation = (0, import_operation_resolution.resolveRequestOperation)({ rawBody: req.rawBody, method: req.method, url: req.url });
+        let principal;
+        let deferredFailure;
+        try {
+          principal = await signedRequests.webBotAuth.resolvePrincipal(signers, operation);
+        } catch (error) {
+          if (error instanceof import_web_bot_auth2.WebBotAuthError || error instanceof import_web_bot_auth2.WebBotAuthUnavailableError) throw error;
+          if (typeof operation !== "string") throw (0, import_web_bot_auth2.webBotAuthPrincipalFailureError)(error);
+          const deferred = (0, import_web_bot_auth2.deferWebBotAuthPrincipalFailure)(signers, error);
+          principal = { principal: deferred.principal };
+          deferredFailure = deferred.authorizationFailure;
+        }
+        const signer = signers[signers.length - 1];
+        const failed = signers.find((s) => s.authorizationFailure);
+        const guardedPrincipal = {
+          ...principal,
+          extra: {
+            ...principal.extra,
+            webBotAuthAuthorization: {
+              signer: failed ?? signer,
+              ...(failed?.authorizationFailure ?? deferredFailure) && {
+                authorizationFailure: failed?.authorizationFailure ?? deferredFailure
+              }
+            }
+          }
+        };
+        attachVerifiedSignerAuth(req, guardedPrincipal, {
+          keyid: signer.keyid,
+          agent_url: signer.origin,
+          verified_at: signer.verified_at
+        });
+        return false;
+      } catch (error) {
+        if (error instanceof import_web_bot_auth2.WebBotAuthUnavailableError) {
+          const outage = (0, import_web_bot_auth2.webBotAuthUnavailableResponse)();
+          res.writeHead(outage.status, { ...outage.headers, "Content-Type": "application/json" });
+          res.end(JSON.stringify(outage.body));
+          return true;
+        }
+        const rejected = error instanceof import_web_bot_auth2.WebBotAuthError ? error : new import_web_bot_auth2.WebBotAuthError(403, "identity_rejected");
+        res.writeHead(rejected.status, { ...rejected.headers, "Content-Type": "application/json" });
+        res.end(JSON.stringify(rejected.body));
+        return true;
+      }
+    }
     const reqShim = {
       method: req.method ?? "POST",
       url: req.url ?? "/mcp",
@@ -1483,6 +1561,7 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         resolve();
       };
       res.once("finish", () => {
+        verifierCompleted = true;
         if (res.writableEnded) handled = true;
         done();
       });
@@ -1490,8 +1569,7 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         if (!verifierCompleted) handled = true;
         done();
       });
-      verifier(reqShim, resShim, (err) => {
-        verifierCompleted = true;
+      verifier(reqShim, resShim, async (err) => {
         if (err) {
           const errName = err.name || "Error";
           const errCode = err.code ?? "unknown";
@@ -1506,6 +1584,11 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         const verifiedSigner = reqShim.verifiedSigner;
         if (!err && verifiedSigner) {
           try {
+            if (legacyOriginGate) {
+              if (!verifiedSigner.agent_url)
+                throw new import_auth.AuthError("Legacy signer origin is required for migration fencing");
+              await legacyOriginGate(verifiedSigner.agent_url);
+            }
             const principal = (0, import_auth_signature.principalForVerifiedSigner)(verifiedSigner, signedRequests.makePrincipal);
             attachVerifiedSignerAuth(req, principal, verifiedSigner);
           } catch (identityError) {
@@ -1525,6 +1608,7 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
             handled = true;
           }
         }
+        verifierCompleted = true;
         if (res.writableEnded) handled = true;
         done();
       });
@@ -1674,7 +1758,7 @@ function supportedVersionsForTool(toolName, ranges, capConfig, serverPin) {
 }
 const PUSH_OPERATION_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,255}$/;
 function releaseRequiresPushOperationId(release) {
-  return (0, import_adcp_version_config.isAdcpVersionAtLeast)((0, import_schema_loader.resolveBundleKey)(release), "3.2.0-beta.5");
+  return (0, import_adcp_version_config.isAdcpVersionAtLeast)((0, import_schema_loader2.resolveBundleKey)(release), "3.2.0-beta.5");
 }
 function pushOperationIdError(params, release) {
   const config = params.push_notification_config;
@@ -1744,7 +1828,7 @@ function bundledReleasesForMajors(majors, configured) {
   const acceptedMajors = new Set(majors);
   const releases = /* @__PURE__ */ new Map();
   bundledCompatibleReleases ??= import_version.COMPATIBLE_ADCP_VERSIONS.flatMap((version) => {
-    if (!(0, import_schema_loader.hasSchemaBundle)(version)) return [];
+    if (!(0, import_schema_loader2.hasSchemaBundle)(version)) return [];
     const parsed = parseAdcpRelease(version);
     return parsed ? [parsed] : [];
   });
@@ -1828,7 +1912,7 @@ function selectServedAdcpRelease(params, capConfig, serverPin, defaultPin) {
   return {
     validationVersion,
     advertisedVersion: selected.exactValue,
-    ...(0, import_protocols.bundleSupportsAdcpVersionField)((0, import_schema_loader.resolveBundleKey)(validationVersion)) && { wireVersion: validationVersion }
+    ...(0, import_protocols.bundleSupportsAdcpVersionField)((0, import_schema_loader2.resolveBundleKey)(validationVersion)) && { wireVersion: validationVersion }
   };
 }
 const ACCOUNT_VIA_RESOURCE_TOOLS = /* @__PURE__ */ new Set(["refine_proposals", "decline_proposals"]);
@@ -1857,6 +1941,11 @@ function isAuthDerivedAccountNotFound(err) {
   return err instanceof import_async_outcome.AdcpError && err.code === "ACCOUNT_NOT_FOUND";
 }
 function createAdcpServer(config) {
+  if (Boolean(config.identity33) !== (0, import_schema_loader.isIdentity33SchemaScope)())
+    return (0, import_schema_loader.withIdentity33SchemaScope)(() => {
+      const instance = createAdcpServer(config);
+      return config.identity33 ? (0, import_schema_loader.bindIdentity33SchemaScope)(instance) : instance;
+    }, Boolean(config.identity33));
   const {
     name,
     version,
@@ -1948,7 +2037,7 @@ function createAdcpServer(config) {
   }
   const credentialPolicyPatterns = credentialPolicy === void 0 || typeof credentialPolicy === "string" ? void 0 : credentialPolicy.patterns;
   const adcpVersion = (0, import_adcp_version_config.resolveAdcpVersion)(
-    configuredAdcpVersion ?? (config.proposalNegotiation ? import_version2.ADCP_VERSION : void 0)
+    configuredAdcpVersion ?? (config.identity33 ? "3.3" : config.proposalNegotiation ? import_version2.ADCP_VERSION : void 0)
   );
   const toolVersionRanges = parseToolVersionRanges(config.toolVersions);
   const toolAvailableForRelease = (toolName, release) => toolIsAvailableInRelease(toolVersionRanges, toolName, release);
@@ -2013,14 +2102,31 @@ function createAdcpServer(config) {
       "createAdcpServer: proposalNegotiation.capabilities.supported_dimensions is required when refineProposals is registered"
     );
   }
-  const protocolBundleKey = (0, import_schema_loader.resolveBundleKey)(adcpVersion);
+  const protocolBundleKey = (0, import_schema_loader2.resolveBundleKey)(adcpVersion);
   const frameworkToolMeta = { adcp_version: adcpVersion };
   const servedAdcpVersion = (() => {
-    const bundleKey = (0, import_schema_loader.resolveBundleKey)(defaultAdcpVersion);
+    const bundleKey = (0, import_schema_loader2.resolveBundleKey)(defaultAdcpVersion);
     return (0, import_protocols.bundleSupportsAdcpVersionField)(bundleKey) ? bundleKey : void 0;
   })();
   const protocolTaskRelease = parseAdcpRelease(protocolBundleKey);
   const supportsProtocolTaskTools = protocolTaskRelease !== void 0 && (protocolTaskRelease.major > 3 || protocolTaskRelease.major === 3 && protocolTaskRelease.minor >= 1);
+  const identityOnboarding = capConfig?.account?.agent_onboarding ?? capConfig?.account?.agentOnboarding;
+  if (identityOnboarding) {
+    if (!config.identity33) throw new Error("agent_onboarding requires the identity33 experiment");
+    (0, import_lifecycle.validateAgentOnboarding)(
+      identityOnboarding,
+      { sandbox: capConfig?.account?.sandbox, supported_billing: capConfig?.account?.supportedBilling },
+      capConfig?.overrides?.experimental_features ?? []
+    );
+  }
+  if (signedRequests?.webBotAuth && (!config.identity33 || !(capConfig?.overrides?.request_signing?.profiles ?? capConfig?.request_signing?.profiles)?.includes(
+    "web-bot-auth"
+  )))
+    throw new Error("Web Bot Auth verifier requires identity33 and request_signing.profiles advertisement");
+  if (config.webhooks?.signingProfile === "web-bot-auth")
+    throw new Error("Select Web Bot Auth on each trusted webhook registration, not as a server-wide default");
+  if (config.webhooks?.webBotAuth && !config.identity33)
+    throw new Error("Web Bot Auth webhook signing requires the identity33 experiment");
   const toolsWithErrorArm = (0, import_error_arm_tools.getToolsWithErrorArm)(adcpVersion);
   const isProduction = process.env.NODE_ENV === "production";
   const requestValidationMode = validationConfig?.requests ?? (isProduction ? "off" : "strict");
@@ -2226,7 +2332,7 @@ function createAdcpServer(config) {
   const releaseDefinesTool = (toolName, release) => {
     if (toolName === "refine_proposals") return true;
     try {
-      return (0, import_schema_loader.getValidator)(toolName, "request", release.validationVersion) !== void 0;
+      return (0, import_schema_loader2.getValidator)(toolName, "request", release.validationVersion) !== void 0;
     } catch {
       return false;
     }
@@ -2579,6 +2685,10 @@ function createAdcpServer(config) {
       const hasAccount = "account" in schema.shape;
       const wrap = meta?.wrap ?? ((data, summary) => genericResponse(toolName, data, summary));
       const toolHandler = async (params, extra) => {
+        const authorizationFailure = (0, import_web_bot_auth2.getWebBotAuthAuthorizationFailure)(extra?.authInfo?.extra);
+        if (authorizationFailure) return (0, import_web_bot_auth2.webBotAuthToolFailure)(authorizationFailure, servedAdcpVersion);
+        if (config.identity33 && !(0, import_schema_loader.isIdentity33SchemaScope)())
+          return (0, import_schema_loader.withIdentity33SchemaScope)(() => toolHandler(params, extra));
         const callRequestValidationMode = effectiveRequestValidationMode(extra);
         let notificationFailureRows = /* @__PURE__ */ new Map();
         const releaseSelection = selectServedAdcpRelease(params, capConfig, adcpVersion, defaultAdcpVersion);
@@ -2633,6 +2743,22 @@ function createAdcpServer(config) {
             })
           );
         }
+        for (const field of ["push_notification_config", "reporting_webhook", "artifact_webhook"]) {
+          const registration = params[field];
+          if (!registration || typeof registration !== "object" || Array.isArray(registration)) continue;
+          const selectedProfile = registration.signing_profile;
+          if (selectedProfile === void 0) continue;
+          const offered = capabilitiesData.webhook_signing?.profiles ?? [
+            "adcp/webhook-signing/v1"
+          ];
+          if (typeof selectedProfile !== "string" || !offered.includes(selectedProfile) || selectedProfile === "web-bot-auth" && (!config.identity33 || !(0, import_adcp_version_config.isAdcpVersionAtLeast)(requestRelease.wireVersion, "3.3")) || selectedProfile === "web-bot-auth" && registration.authentication !== void 0)
+            return finalize(
+              (0, import_errors2.adcpError)("INVALID_REQUEST", {
+                message: "Unsupported or ambiguous webhook signing profile",
+                field: `${field}.signing_profile`
+              })
+            );
+        }
         const operationIdError = pushOperationIdError(params, requestRelease);
         if (operationIdError) return finalize(operationIdError);
         if (toolName === "list_account_changes" && Object.hasOwn(params, "cursor") && Object.hasOwn(params, "starting_position")) {
@@ -2812,7 +2938,8 @@ function createAdcpServer(config) {
             "request",
             params,
             requestRelease.validationVersion,
-            proposalRefinementCapabilities
+            proposalRefinementCapabilities,
+            !!config.identity33 && (0, import_adcp_version_config.isAdcpVersionAtLeast)(requestRelease.wireVersion, "3.3")
           );
           if (!outcome.valid) {
             if ("refinementError" in outcome && outcome.refinementError?.code === "UNSUPPORTED_FEATURE") {
@@ -2867,6 +2994,23 @@ function createAdcpServer(config) {
             }
           }
         }
+        if (config.identity33) {
+          try {
+            await config.identity33.authorize(ctx, toolName, params);
+          } catch (error) {
+            if (error instanceof import_trust.TrustRecordUnavailableError)
+              return finalize((0, import_errors2.adcpError)("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" }));
+            if (error instanceof import_trust.IdentityAuthorizationError)
+              return finalize(
+                (0, import_errors2.adcpError)("PERMISSION_DENIED", {
+                  message: error.message,
+                  ...error.details && { details: { ...error.details } }
+                })
+              );
+            if (error instanceof import_async_outcome.AdcpError) return finalize(projectThrownAdcpError(error));
+            return finalize((0, import_errors2.adcpError)("PERMISSION_DENIED", { message: "Agent authorization failed" }));
+          }
+        }
         let unresolvedAccountPassThrough = false;
         const suppliedAccountRef = hasAccount && params.account != null && !(strictAccountReferences && toolName === "list_accounts");
         if (suppliedAccountRef && toolName === "list_accounts") {
@@ -3058,7 +3202,7 @@ function createAdcpServer(config) {
             );
           }
         }
-        const callerScopedResolver = toolName === "sync_agent_notification_configs" ? config.protocol?.resolveScope : toolName === "get_principal" || toolName === "sync_principal" ? config.protocol?.resolvePrincipalScope : void 0;
+        const callerScopedResolver = config.identity33 && (toolName === "get_principal" || toolName === "sync_principal" && params.dry_run === true) && (0, import_server.isIdentity33UnboundContext)(ctx) ? void 0 : toolName === "sync_agent_notification_configs" ? config.protocol?.resolveScope : toolName === "get_principal" || toolName === "sync_principal" ? config.protocol?.resolvePrincipalScope : void 0;
         if (callerScopedResolver || toolName === "report_plan_adjustment") {
           if (ctx.authInfo === void 0 && ctx.agent === void 0) {
             return finalize(
@@ -3262,7 +3406,18 @@ function createAdcpServer(config) {
           if (webhookEmitter) {
             const tenantScope = webhookTenantScopeForContext(ctx);
             const scopedEmitter = tenantScope === void 0 ? configuredWebhookEmitter : webhookEmitter.forTenantScope(tenantScope);
-            ctx.emitWebhook = scopedEmitter.emit.bind(scopedEmitter);
+            const profileBindings = ["push_notification_config", "reporting_webhook", "artifact_webhook"].flatMap(
+              (field) => {
+                const value = params[field];
+                return value?.url && value.signing_profile ? [{ url: value.url, profile: value.signing_profile }] : [];
+              }
+            );
+            ctx.emitWebhook = (delivery) => scopedEmitter.emit({
+              ...delivery,
+              ...delivery.signingProfile === void 0 && profileBindings.some((binding) => binding.url === delivery.url) && {
+                signingProfile: profileBindings.find((binding) => binding.url === delivery.url).profile
+              }
+            });
           }
           const handlerParams = notificationFailureRows.size === 0 ? params : {
             ...params,
@@ -3740,7 +3895,14 @@ function createAdcpServer(config) {
           }
           if (responseValidationMode !== "off" && !isErrorResponse(formatted)) {
             const payload = formatted.structuredContent;
-            const outcome = validateFrameworkPayload(toolName, "response", payload, requestRelease.validationVersion);
+            const outcome = validateFrameworkPayload(
+              toolName,
+              "response",
+              payload,
+              requestRelease.validationVersion,
+              void 0,
+              !!config.identity33 && (0, import_adcp_version_config.isAdcpVersionAtLeast)(requestRelease.wireVersion, "3.3")
+            );
             if (!outcome.valid) {
               logger.warn(
                 `Schema validation warning (response) for ${toolName}: ${(0, import_schema_validator.formatIssues)(outcome.issues, 3, { rootSchemaId: outcome.schemaId })}`,
@@ -4025,6 +4187,8 @@ function createAdcpServer(config) {
         _meta: frameworkToolMeta
       },
       (async (params, extra) => {
+        const identityError = await authorizeAuxiliaryIdentityTool("get_task_status", params, extra);
+        if (identityError) return finalizeProtocolTaskToolResponse("get_task_status", params ?? {}, identityError);
         const credentialError = taskToolCredentialPolicyError("get_task_status", params ?? {}, extra);
         if (credentialError) {
           return finalizeProtocolTaskToolResponse("get_task_status", params ?? {}, credentialError, {
@@ -4111,6 +4275,8 @@ function createAdcpServer(config) {
         _meta: frameworkToolMeta
       },
       (async (params, extra) => {
+        const identityError = await authorizeAuxiliaryIdentityTool("list_tasks", params, extra);
+        if (identityError) return finalizeProtocolTaskToolResponse("list_tasks", params ?? {}, identityError);
         const credentialError = taskToolCredentialPolicyError("list_tasks", params ?? {}, extra);
         if (credentialError) {
           return finalizeProtocolTaskToolResponse("list_tasks", params ?? {}, credentialError, { echoContext: false });
@@ -4227,6 +4393,8 @@ function createAdcpServer(config) {
         );
       };
       const wrappedHandler = (async (...args) => {
+        const identityError = await authorizeAuxiliaryIdentityTool(customName, args[0], args[args.length - 1]);
+        if (identityError) return finalizeCustomResponse(identityError);
         const params = isPlainObject(args[0]) ? args[0] : {};
         const selectedRelease = selectServedAdcpRelease(params, capConfig, adcpVersion, defaultAdcpVersion);
         if (isMcpToolResponse(selectedRelease)) return finalizeCustomResponse(selectedRelease);
@@ -4345,6 +4513,7 @@ function createAdcpServer(config) {
       ...capConfig.account.defaultBilling && { default_billing: capConfig.account.defaultBilling },
       required_for_products: capConfig.account.requiredForProducts ?? false,
       sandbox: capConfig.account.sandbox ?? false,
+      ...identityOnboarding && { agent_onboarding: identityOnboarding },
       ...capConfig.account.changeFeed !== void 0 && { change_feed: capConfig.account.changeFeed }
     };
   }
@@ -4386,7 +4555,15 @@ function createAdcpServer(config) {
       ...capabilitiesData.webhook_signing,
       supported: true,
       profile,
-      algorithms: [algorithm],
+      algorithms: [
+        .../* @__PURE__ */ new Set([
+          algorithm,
+          ...webhooks.webBotAuth ? [
+            ("privateKey" in webhooks.webBotAuth.key ? webhooks.webBotAuth.key.privateKey.crv : webhooks.webBotAuth.key.publicKey.crv) === "P-256" ? "ecdsa-p256-sha256" : "ed25519"
+          ] : []
+        ])
+      ],
+      ...webhooks.webBotAuth && { profiles: ["adcp/webhook-signing/v1", "web-bot-auth"] },
       legacy_hmac_fallback: capabilitiesData.webhook_signing?.legacy_hmac_fallback ?? false,
       delivery_retry_horizon_seconds: webhooks.deliveryRetryHorizonSeconds ?? 86400
     };
@@ -4432,6 +4609,36 @@ function createAdcpServer(config) {
     ];
   }
   capabilitiesData.library_version = `@adcp/client@${import_version2.LIBRARY_VERSION}`;
+  async function authorizeAuxiliaryIdentityTool(toolName, params, extra) {
+    const failure = (0, import_web_bot_auth2.getWebBotAuthAuthorizationFailure)(extra?.authInfo?.extra);
+    if (failure) return (0, import_web_bot_auth2.webBotAuthToolFailure)(failure, servedAdcpVersion);
+    if (!config.identity33) return void 0;
+    try {
+      await config.identity33.authorize(
+        withImmutableServedAdcpVersion(
+          { toolName, stateStore, authInfo: extra?.authInfo, logger },
+          adcpVersion
+        ),
+        toolName,
+        params
+      );
+    } catch (error) {
+      if (error instanceof import_trust.TrustRecordUnavailableError)
+        return (0, import_errors2.adcpError)("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" });
+      if (error instanceof import_trust.IdentityAuthorizationError)
+        return (0, import_errors2.adcpError)("PERMISSION_DENIED", {
+          message: error.message,
+          ...error.details && { details: { ...error.details } }
+        });
+      if (error instanceof import_async_outcome.AdcpError) return projectThrownAdcpError(error);
+      return (0, import_errors2.adcpError)("PERMISSION_DENIED", { message: "Agent authorization failed" });
+    }
+    return void 0;
+  }
+  for (const field of ["request_signing", "webhook_signing"]) {
+    const signing = capabilitiesData[field];
+    if (signing?.profiles?.includes("web-bot-auth")) signing.wba_draft_revision = import_web_bot_auth2.WEB_BOT_AUTH_DRAFT_REVISION;
+  }
   server.registerTool(
     "get_adcp_capabilities",
     {
@@ -4440,6 +4647,10 @@ function createAdcpServer(config) {
       _meta: frameworkToolMeta
     },
     (async (params, extra = {}) => {
+      const authorizationFailure = (0, import_web_bot_auth2.getWebBotAuthAuthorizationFailure)(extra.authInfo?.extra);
+      if (authorizationFailure) return (0, import_web_bot_auth2.webBotAuthToolFailure)(authorizationFailure, servedAdcpVersion);
+      const identityError = await authorizeAuxiliaryIdentityTool("get_adcp_capabilities", params, extra);
+      if (identityError) return identityError;
       const callRequestValidationMode = effectiveRequestValidationMode(extra);
       const requestParams = isPlainObject(params) ? params : {};
       const releaseSelection = selectServedAdcpRelease(requestParams, capConfig, adcpVersion, defaultAdcpVersion);
@@ -4574,7 +4785,12 @@ function createAdcpServer(config) {
           delete validationPayload.media_buy.proposal_refinement;
           delete validationPayload.media_buy.lifecycle_tools;
         }
-        const responseOutcome = (0, import_schema_validator.validateResponse)("get_adcp_capabilities", validationPayload, release.validationVersion);
+        const responseOutcome = config.identity33 && (0, import_adcp_version_config.isAdcpVersionAtLeast)(release.wireVersion, "3.3") ? (0, import_validation.validateIdentity33Payload)(
+          "get_adcp_capabilities",
+          "response",
+          validationPayload,
+          release.validationVersion
+        ) : (0, import_schema_validator.validateResponse)("get_adcp_capabilities", validationPayload, release.validationVersion);
         if (!responseOutcome.valid) {
           logger.warn(
             `Schema validation warning (response) for get_adcp_capabilities: ${(0, import_schema_validator.formatIssues)(responseOutcome.issues, 3, { rootSchemaId: responseOutcome.schemaId })}`,
@@ -4649,7 +4865,7 @@ function createAdcpServer(config) {
       if (listMcpToolProfile !== "media-buy") return tool;
       const toolName = tool?.name;
       if (typeof toolName !== "string") return tool;
-      const inputSchema = (0, import_schema_loader.getMcpProfileInputSchema)(toolName, "media-buy", listRelease.validationVersion);
+      const inputSchema = (0, import_schema_loader2.getMcpProfileInputSchema)(toolName, "media-buy", listRelease.validationVersion);
       return inputSchema ? { ...tool, inputSchema } : tool;
     });
     return {
@@ -4800,6 +5016,30 @@ function createAdcpServer(config) {
     protocols,
     signedRequests: signedRequestsState
   });
+  if (config.identity33) {
+    for (const method of [
+      "initialize",
+      "tools/list",
+      "tools/call",
+      "resources/list",
+      "resources/read",
+      "prompts/list",
+      "prompts/get",
+      "tasks/get",
+      "tasks/list",
+      "tasks/cancel",
+      "tasks/result"
+    ])
+      (0, import_adcp_server.wrapSdkRequestHandler)(
+        server,
+        method,
+        (original, request, extra) => (0, import_schema_loader.withIdentity33SchemaScope)(() => original(request, extra))
+      );
+  }
+  (0, import_adcp_server.wrapSdkRequestHandler)(server, "tools/call", (original, request, extra) => {
+    const failure = (0, import_web_bot_auth2.getWebBotAuthAuthorizationFailure)(extra?.authInfo?.extra);
+    return failure ? (0, import_web_bot_auth2.webBotAuthToolFailure)(failure, servedAdcpVersion) : original(request, extra);
+  });
   return wrapped;
 }
 // Annotate the CommonJS export names for ESM import in node: