@adcp/sdk 15.9.1 → 16.0.0-beta.2

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

@@ -1,3 +1,26 @@
+import { getWebBotAuthLegacyOriginGate } from "../signing/web-bot-auth.mjs";
+import {
+  isIdentity33SchemaScope,
+  withIdentity33SchemaScope,
+  bindIdentity33SchemaScope
+} from "../validation/schema-loader.mjs";
+import { validateAgentOnboarding } from "../identity-3.3/lifecycle.mjs";
+import { isIdentity33UnboundContext } from "../identity-3.3/server.mjs";
+import {
+  WEB_BOT_AUTH_DRAFT_REVISION,
+  getWebBotAuthAuthorizationFailure,
+  webBotAuthToolFailure,
+  selectSignatureProfile,
+  verifyWebBotAuth,
+  isWebBotAuthRevocationChecked,
+  webBotAuthUnavailableResponse,
+  WebBotAuthUnavailableError,
+  deferWebBotAuthPrincipalFailure,
+  webBotAuthPrincipalFailureError,
+  WebBotAuthError
+} from "../signing/web-bot-auth.mjs";
+import { validateIdentity33Payload } from "../identity-3.3/validation.mjs";
+import { IdentityAuthorizationError, TrustRecordUnavailableError } from "../identity-3.3/trust.mjs";
 import { z } from "zod";
 import {
   COMPATIBLE_ADCP_VERSIONS,
@@ -752,10 +775,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 validateSyncReportingStatusEnvelope(payload, version);
   }
+  if (identity33 && toolName !== "refine_proposals" && toolName !== "sync_reporting_status")
+    return validateIdentity33Payload(toolName, direction, payload, version);
   if (toolName !== "refine_proposals") {
     return direction === "request" ? validateRequest(toolName, payload, version) : validateResponse(toolName, payload, version);
   }
@@ -1491,6 +1516,15 @@ function resolveEffectiveSignedRequestPolicy(signedRequests, capabilityRequestSi
   };
 }
 function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning, adcpVersion) {
+  const legacyOriginGate = signedRequests.assertLegacyOriginAllowed ?? 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 && !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 = createExpressVerifier({
     capability: {
@@ -1512,6 +1546,66 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
   return async function adcpPreTransport(req, res) {
     const serveContext = getServeRequestContext(req);
     const canonicalPublicUrl = serveContext?.publicUrl ? new URL(serveContext.publicUrl) : void 0;
+    if (selectSignatureProfile({ headers: req.headers }) === "web-bot-auth") {
+      try {
+        if (!signedRequests.webBotAuth || !canonicalPublicUrl) throw new WebBotAuthError(403, "profile_disabled");
+        if (req.method !== "GET" && req.rawBody === void 0) throw new WebBotAuthError(403, "raw_body_missing");
+        const requestTarget = canonicalPublicUrl.origin + (req.url?.startsWith("/") ? req.url : "/" + (req.url ?? ""));
+        const signers = await 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 = 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 WebBotAuthError || error instanceof WebBotAuthUnavailableError) throw error;
+          if (typeof operation !== "string") throw webBotAuthPrincipalFailureError(error);
+          const deferred = 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 WebBotAuthUnavailableError) {
+          const outage = webBotAuthUnavailableResponse();
+          res.writeHead(outage.status, { ...outage.headers, "Content-Type": "application/json" });
+          res.end(JSON.stringify(outage.body));
+          return true;
+        }
+        const rejected = error instanceof WebBotAuthError ? error : new 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",
@@ -1555,6 +1649,7 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         resolve();
       };
       res.once("finish", () => {
+        verifierCompleted = true;
         if (res.writableEnded) handled = true;
         done();
       });
@@ -1562,8 +1657,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";
@@ -1578,6 +1672,11 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         const verifiedSigner = reqShim.verifiedSigner;
         if (!err && verifiedSigner) {
           try {
+            if (legacyOriginGate) {
+              if (!verifiedSigner.agent_url)
+                throw new AuthError("Legacy signer origin is required for migration fencing");
+              await legacyOriginGate(verifiedSigner.agent_url);
+            }
             const principal = principalForVerifiedSigner(verifiedSigner, signedRequests.makePrincipal);
             attachVerifiedSignerAuth(req, principal, verifiedSigner);
           } catch (identityError) {
@@ -1597,6 +1696,7 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
             handled = true;
           }
         }
+        verifierCompleted = true;
         if (res.writableEnded) handled = true;
         done();
       });
@@ -1929,6 +2029,11 @@ function isAuthDerivedAccountNotFound(err) {
   return err instanceof AdcpError && err.code === "ACCOUNT_NOT_FOUND";
 }
 function createAdcpServer(config) {
+  if (Boolean(config.identity33) !== isIdentity33SchemaScope())
+    return withIdentity33SchemaScope(() => {
+      const instance = createAdcpServer(config);
+      return config.identity33 ? bindIdentity33SchemaScope(instance) : instance;
+    }, Boolean(config.identity33));
   const {
     name,
     version,
@@ -2020,7 +2125,7 @@ function createAdcpServer(config) {
   }
   const credentialPolicyPatterns = credentialPolicy === void 0 || typeof credentialPolicy === "string" ? void 0 : credentialPolicy.patterns;
   const adcpVersion = resolveAdcpVersion(
-    configuredAdcpVersion ?? (config.proposalNegotiation ? ADCP_VERSION : void 0)
+    configuredAdcpVersion ?? (config.identity33 ? "3.3" : config.proposalNegotiation ? ADCP_VERSION : void 0)
   );
   const toolVersionRanges = parseToolVersionRanges(config.toolVersions);
   const toolAvailableForRelease = (toolName, release) => toolIsAvailableInRelease(toolVersionRanges, toolName, release);
@@ -2093,6 +2198,23 @@ function createAdcpServer(config) {
   })();
   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");
+    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 = getToolsWithErrorArm(adcpVersion);
   const isProduction = process.env.NODE_ENV === "production";
   const requestValidationMode = validationConfig?.requests ?? (isProduction ? "off" : "strict");
@@ -2651,6 +2773,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 = getWebBotAuthAuthorizationFailure(extra?.authInfo?.extra);
+        if (authorizationFailure) return webBotAuthToolFailure(authorizationFailure, servedAdcpVersion);
+        if (config.identity33 && !isIdentity33SchemaScope())
+          return withIdentity33SchemaScope(() => toolHandler(params, extra));
         const callRequestValidationMode = effectiveRequestValidationMode(extra);
         let notificationFailureRows = /* @__PURE__ */ new Map();
         const releaseSelection = selectServedAdcpRelease(params, capConfig, adcpVersion, defaultAdcpVersion);
@@ -2705,6 +2831,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 || !isAdcpVersionAtLeast(requestRelease.wireVersion, "3.3")) || selectedProfile === "web-bot-auth" && registration.authentication !== void 0)
+            return finalize(
+              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")) {
@@ -2884,7 +3026,8 @@ function createAdcpServer(config) {
             "request",
             params,
             requestRelease.validationVersion,
-            proposalRefinementCapabilities
+            proposalRefinementCapabilities,
+            !!config.identity33 && isAdcpVersionAtLeast(requestRelease.wireVersion, "3.3")
           );
           if (!outcome.valid) {
             if ("refinementError" in outcome && outcome.refinementError?.code === "UNSUPPORTED_FEATURE") {
@@ -2939,6 +3082,23 @@ function createAdcpServer(config) {
             }
           }
         }
+        if (config.identity33) {
+          try {
+            await config.identity33.authorize(ctx, toolName, params);
+          } catch (error) {
+            if (error instanceof TrustRecordUnavailableError)
+              return finalize(adcpError("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" }));
+            if (error instanceof IdentityAuthorizationError)
+              return finalize(
+                adcpError("PERMISSION_DENIED", {
+                  message: error.message,
+                  ...error.details && { details: { ...error.details } }
+                })
+              );
+            if (error instanceof AdcpError) return finalize(projectThrownAdcpError(error));
+            return finalize(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") {
@@ -3130,7 +3290,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) && 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(
@@ -3334,7 +3494,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,
@@ -3812,7 +3983,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 && isAdcpVersionAtLeast(requestRelease.wireVersion, "3.3")
+            );
             if (!outcome.valid) {
               logger.warn(
                 `Schema validation warning (response) for ${toolName}: ${formatIssues(outcome.issues, 3, { rootSchemaId: outcome.schemaId })}`,
@@ -4097,6 +4275,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, {
@@ -4183,6 +4363,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 });
@@ -4299,6 +4481,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);
@@ -4417,6 +4601,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 }
     };
   }
@@ -4458,7 +4643,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
     };
@@ -4504,6 +4697,36 @@ function createAdcpServer(config) {
     ];
   }
   capabilitiesData.library_version = `@adcp/client@${LIBRARY_VERSION}`;
+  async function authorizeAuxiliaryIdentityTool(toolName, params, extra) {
+    const failure = getWebBotAuthAuthorizationFailure(extra?.authInfo?.extra);
+    if (failure) return 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 TrustRecordUnavailableError)
+        return adcpError("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" });
+      if (error instanceof IdentityAuthorizationError)
+        return adcpError("PERMISSION_DENIED", {
+          message: error.message,
+          ...error.details && { details: { ...error.details } }
+        });
+      if (error instanceof AdcpError) return projectThrownAdcpError(error);
+      return 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 = WEB_BOT_AUTH_DRAFT_REVISION;
+  }
   server.registerTool(
     "get_adcp_capabilities",
     {
@@ -4512,6 +4735,10 @@ function createAdcpServer(config) {
       _meta: frameworkToolMeta
     },
     (async (params, extra = {}) => {
+      const authorizationFailure = getWebBotAuthAuthorizationFailure(extra.authInfo?.extra);
+      if (authorizationFailure) return 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);
@@ -4646,7 +4873,12 @@ function createAdcpServer(config) {
           delete validationPayload.media_buy.proposal_refinement;
           delete validationPayload.media_buy.lifecycle_tools;
         }
-        const responseOutcome = validateResponse("get_adcp_capabilities", validationPayload, release.validationVersion);
+        const responseOutcome = config.identity33 && isAdcpVersionAtLeast(release.wireVersion, "3.3") ? validateIdentity33Payload(
+          "get_adcp_capabilities",
+          "response",
+          validationPayload,
+          release.validationVersion
+        ) : validateResponse("get_adcp_capabilities", validationPayload, release.validationVersion);
         if (!responseOutcome.valid) {
           logger.warn(
             `Schema validation warning (response) for get_adcp_capabilities: ${formatIssues(responseOutcome.issues, 3, { rootSchemaId: responseOutcome.schemaId })}`,
@@ -4872,6 +5104,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"
+    ])
+      wrapSdkRequestHandler(
+        server,
+        method,
+        (original, request, extra) => withIdentity33SchemaScope(() => original(request, extra))
+      );
+  }
+  wrapSdkRequestHandler(server, "tools/call", (original, request, extra) => {
+    const failure = getWebBotAuthAuthorizationFailure(extra?.authInfo?.extra);
+    return failure ? webBotAuthToolFailure(failure, servedAdcpVersion) : original(request, extra);
+  });
   return wrapped;
 }
 export {

package/dist/lib/server/decisioning/account.d.mts

@@ -340,6 +340,8 @@ export interface ResolveContext {
      *   before the platform method runs; treat fields the buyer sent as
      *   authoritative, but expect framework-injected entities (e.g.
      *   hydrated product / media-buy refs) to be visible here too.
+     *   Account-sync guard lookups and upsert receive independent input
+     *   copies so callback normalization cannot rewrite framework checks.
      * - **Buyer-controlled untrusted data.** Free-text fields (`brief`,
      *   `message`, creative snippets, etc.) are attacker-controlled.
      *   Don't log `ctx.input` wholesale — secret fields like
@@ -374,6 +376,18 @@ export interface AccountToolContext<TCtxMeta = Record<string, unknown>> extends
     /** Resolved Account from `accounts.resolve()`. Populated by the framework before dispatch. */
     account: Account<TCtxMeta>;
 }
+/** Pre-write snapshots aligned with the accepted entries passed to `upsert`. */
+export interface AccountUpsertContext<TCtxMeta = Record<string, unknown>> extends ResolveContext {
+    /** Null for an unresolved or ID-keyed entry. Lookup uses `provisioning: false`. */
+    readonly existing?: readonly (Account<TCtxMeta> | null)[];
+}
+/** A sync/list contract violation, delivered only to the seller. */
+export interface AccountSyncDiagnostic {
+    readonly code: 'ACCOUNT_SYNC_IDEMPOTENCY_VIOLATION' | 'ACCOUNT_SYNC_PAYMENT_TERMS_MISMATCH' | 'ACCOUNT_SYNC_BILLING_MISMATCH' | 'ACCOUNT_SYNC_LOOKUP_UNSUPPORTED' | 'ACCOUNT_BILLING_FIELDS_MISSING';
+    readonly toolName: 'sync_accounts' | 'list_accounts';
+    /** Original request index for sync; page index for list. */
+    readonly index: number;
+}
 /**
  * Request context for tools that can omit an `account` field —
  * `preview_creative`, `list_creative_formats` (optional since rc.7), and
@@ -469,6 +483,15 @@ export declare function normalizeAccountResolution(resolution: AccountResolution
  */
 export declare function isAccountResolutionMode(value: unknown): value is AccountResolutionMode;
 export interface AccountStore<TCtxMeta = Record<string, unknown>> {
+    /**
+     * Convert sync contract violations to per-row failures. Default: diagnostics only.
+     * This is post-write response validation, not a transaction or rollback.
+     * For accept-or-reject guarantees, upsert must check these contracts before
+     * committing too (createKeyedAccountStore does so for its own backend).
+     */
+    readonly strictIdempotency?: boolean;
+    /** Server-side diagnostics; never includes credentials or account metadata. Async hooks are fire-and-forget, with failures isolated from dispatch. */
+    readonly onDiagnostic?: (diagnostic: AccountSyncDiagnostic) => void;
     /**
      * How buyers reference accounts on this platform. Three onboarding models,
      * aligned with the account-reference taxonomy clarified upstream in
@@ -640,7 +663,7 @@ export interface AccountStore<TCtxMeta = Record<string, unknown>> {
      * verified `agent_url` from `credential.kind === 'http_sig'` when
      * `agentRegistry` is not configured).
      */
-    upsert?(refs: AccountReference[], ctx?: ResolveContext): Promise<SyncAccountsHandlerResult>;
+    upsert?(refs: AccountReference[], ctx?: AccountUpsertContext<TCtxMeta>): Promise<SyncAccountsHandlerResult>;
     /**
      * sync_governance API surface. Buyers register governance agent endpoints
      * per-account; the seller persists the binding and consults the agents

package/dist/lib/server/decisioning/account.d.ts

@@ -340,6 +340,8 @@ export interface ResolveContext {
      *   before the platform method runs; treat fields the buyer sent as
      *   authoritative, but expect framework-injected entities (e.g.
      *   hydrated product / media-buy refs) to be visible here too.
+     *   Account-sync guard lookups and upsert receive independent input
+     *   copies so callback normalization cannot rewrite framework checks.
      * - **Buyer-controlled untrusted data.** Free-text fields (`brief`,
      *   `message`, creative snippets, etc.) are attacker-controlled.
      *   Don't log `ctx.input` wholesale — secret fields like
@@ -374,6 +376,18 @@ export interface AccountToolContext<TCtxMeta = Record<string, unknown>> extends
     /** Resolved Account from `accounts.resolve()`. Populated by the framework before dispatch. */
     account: Account<TCtxMeta>;
 }
+/** Pre-write snapshots aligned with the accepted entries passed to `upsert`. */
+export interface AccountUpsertContext<TCtxMeta = Record<string, unknown>> extends ResolveContext {
+    /** Null for an unresolved or ID-keyed entry. Lookup uses `provisioning: false`. */
+    readonly existing?: readonly (Account<TCtxMeta> | null)[];
+}
+/** A sync/list contract violation, delivered only to the seller. */
+export interface AccountSyncDiagnostic {
+    readonly code: 'ACCOUNT_SYNC_IDEMPOTENCY_VIOLATION' | 'ACCOUNT_SYNC_PAYMENT_TERMS_MISMATCH' | 'ACCOUNT_SYNC_BILLING_MISMATCH' | 'ACCOUNT_SYNC_LOOKUP_UNSUPPORTED' | 'ACCOUNT_BILLING_FIELDS_MISSING';
+    readonly toolName: 'sync_accounts' | 'list_accounts';
+    /** Original request index for sync; page index for list. */
+    readonly index: number;
+}
 /**
  * Request context for tools that can omit an `account` field —
  * `preview_creative`, `list_creative_formats` (optional since rc.7), and
@@ -469,6 +483,15 @@ export declare function normalizeAccountResolution(resolution: AccountResolution
  */
 export declare function isAccountResolutionMode(value: unknown): value is AccountResolutionMode;
 export interface AccountStore<TCtxMeta = Record<string, unknown>> {
+    /**
+     * Convert sync contract violations to per-row failures. Default: diagnostics only.
+     * This is post-write response validation, not a transaction or rollback.
+     * For accept-or-reject guarantees, upsert must check these contracts before
+     * committing too (createKeyedAccountStore does so for its own backend).
+     */
+    readonly strictIdempotency?: boolean;
+    /** Server-side diagnostics; never includes credentials or account metadata. Async hooks are fire-and-forget, with failures isolated from dispatch. */
+    readonly onDiagnostic?: (diagnostic: AccountSyncDiagnostic) => void;
     /**
      * How buyers reference accounts on this platform. Three onboarding models,
      * aligned with the account-reference taxonomy clarified upstream in
@@ -640,7 +663,7 @@ export interface AccountStore<TCtxMeta = Record<string, unknown>> {
      * verified `agent_url` from `credential.kind === 'http_sig'` when
      * `agentRegistry` is not configured).
      */
-    upsert?(refs: AccountReference[], ctx?: ResolveContext): Promise<SyncAccountsHandlerResult>;
+    upsert?(refs: AccountReference[], ctx?: AccountUpsertContext<TCtxMeta>): Promise<SyncAccountsHandlerResult>;
     /**
      * sync_governance API surface. Buyers register governance agent endpoints
      * per-account; the seller persists the binding and consults the agents

package/dist/lib/server/decisioning/index.d.mts

@@ -19,7 +19,7 @@ export type { CursorPage, CursorRequest } from './pagination.mjs';
 export { publishStatusChange, setStatusChangeBus, getStatusChangeBus, createInMemoryStatusChangeBus, type StatusChange, type StatusChangeBus, type StatusChangeResourceType, type StatusChangeListener, type PublishStatusChangeOpts, } from './status-changes.mjs';
 export type { DecisioningCapabilities, ComplianceTestingCapabilities, CreativeAgentRef, TargetingCapabilities, TargetingPostalAreaSupport, ReportingCapabilities, } from './capabilities.mjs';
 export { normalizePostalAreaSupport, normalizeTargetingCapabilities } from './capabilities.mjs';
-export type { Account, AccountResolutionMode, CanonicalAccountResolutionMode, AuthPrincipal, AccountStore, AccountFilter, ListAccountsPayload, ListAccountChangesPayload, SyncAccountsPayload, SyncAccountsSuccessPayload, SyncAccountsRow, SyncAccountsResultRow, SyncGovernancePayload, SyncGovernanceSuccessPayload, SyncGovernanceRow, ReportUsagePayload, GetAccountFinancialsPayload, GetAccountFinancialsSuccessPayload, ListAccountsHandlerResult, ListAccountChangesHandlerResult, SyncAccountsHandlerResult, SyncGovernanceHandlerResult, ReportUsageHandlerResult, GetAccountFinancialsHandlerResult, AdcpAccountStatus, ResolveContext, AccountToolContext, ResolvedAuthInfo, } from './account.mjs';
+export type { Account, AccountResolutionMode, CanonicalAccountResolutionMode, AuthPrincipal, AccountStore, AccountFilter, ListAccountsPayload, ListAccountChangesPayload, SyncAccountsPayload, SyncAccountsSuccessPayload, SyncAccountsRow, SyncAccountsResultRow, SyncGovernancePayload, SyncGovernanceSuccessPayload, SyncGovernanceRow, ReportUsagePayload, GetAccountFinancialsPayload, GetAccountFinancialsSuccessPayload, ListAccountsHandlerResult, ListAccountChangesHandlerResult, SyncAccountsHandlerResult, SyncGovernanceHandlerResult, ReportUsageHandlerResult, GetAccountFinancialsHandlerResult, AdcpAccountStatus, ResolveContext, AccountUpsertContext, AccountSyncDiagnostic, AccountToolContext, ResolvedAuthInfo, } from './account.mjs';
 export { AccountNotFoundError, isAccountResolutionMode, normalizeAccountResolution, refAccountId, refHasNaturalKey, } from './account.mjs';
 export { createTenantStore, narrowAccountRef } from './tenant-store.mjs';
 export type { TenantStoreConfig } from './tenant-store.mjs';

package/dist/lib/server/decisioning/index.d.ts

@@ -19,7 +19,7 @@ export type { CursorPage, CursorRequest } from './pagination';
 export { publishStatusChange, setStatusChangeBus, getStatusChangeBus, createInMemoryStatusChangeBus, type StatusChange, type StatusChangeBus, type StatusChangeResourceType, type StatusChangeListener, type PublishStatusChangeOpts, } from './status-changes';
 export type { DecisioningCapabilities, ComplianceTestingCapabilities, CreativeAgentRef, TargetingCapabilities, TargetingPostalAreaSupport, ReportingCapabilities, } from './capabilities';
 export { normalizePostalAreaSupport, normalizeTargetingCapabilities } from './capabilities';
-export type { Account, AccountResolutionMode, CanonicalAccountResolutionMode, AuthPrincipal, AccountStore, AccountFilter, ListAccountsPayload, ListAccountChangesPayload, SyncAccountsPayload, SyncAccountsSuccessPayload, SyncAccountsRow, SyncAccountsResultRow, SyncGovernancePayload, SyncGovernanceSuccessPayload, SyncGovernanceRow, ReportUsagePayload, GetAccountFinancialsPayload, GetAccountFinancialsSuccessPayload, ListAccountsHandlerResult, ListAccountChangesHandlerResult, SyncAccountsHandlerResult, SyncGovernanceHandlerResult, ReportUsageHandlerResult, GetAccountFinancialsHandlerResult, AdcpAccountStatus, ResolveContext, AccountToolContext, ResolvedAuthInfo, } from './account';
+export type { Account, AccountResolutionMode, CanonicalAccountResolutionMode, AuthPrincipal, AccountStore, AccountFilter, ListAccountsPayload, ListAccountChangesPayload, SyncAccountsPayload, SyncAccountsSuccessPayload, SyncAccountsRow, SyncAccountsResultRow, SyncGovernancePayload, SyncGovernanceSuccessPayload, SyncGovernanceRow, ReportUsagePayload, GetAccountFinancialsPayload, GetAccountFinancialsSuccessPayload, ListAccountsHandlerResult, ListAccountChangesHandlerResult, SyncAccountsHandlerResult, SyncGovernanceHandlerResult, ReportUsageHandlerResult, GetAccountFinancialsHandlerResult, AdcpAccountStatus, ResolveContext, AccountUpsertContext, AccountSyncDiagnostic, AccountToolContext, ResolvedAuthInfo, } from './account';
 export { AccountNotFoundError, isAccountResolutionMode, normalizeAccountResolution, refAccountId, refHasNaturalKey, } from './account';
 export { createTenantStore, narrowAccountRef } from './tenant-store';
 export type { TenantStoreConfig } from './tenant-store';

package/dist/lib/server/decisioning/runtime/from-platform.d.mts

@@ -1,53 +1,3 @@
-/**
- * Build an `AdcpServer` from a `DecisioningPlatform` impl.
- *
- * v6.0 alpha entry point. Translates the per-specialism platform interface
- * into the framework's existing handler-style config and delegates to
- * `createAdcpServer()`. This means every framework primitive — idempotency,
- * RFC 9421 signing, governance, schema validation, state store, MCP/A2A
- * wire mapping, sandbox boundary — applies unchanged. The new code is the
- * adapter shim, not a forked runtime.
- *
- * **Adopter shape (unified hybrid):** each HITL-eligible tool is a single
- * method. The method returns the wire success arm (sync fast path) OR
- * `ctx.handoffToTask(fn)` to promote the call to a background task (HITL
- * slow path). Adopters branch per-call; framework detects the `TaskHandoff`
- * marker and dispatches accordingly:
- *
- *   - Sync path: framework awaits the return value in foreground; projects
- *     it to the wire success arm. `throw new AdcpError(...)` projects to
- *     the wire `adcp_error` envelope.
- *   - HITL path: framework detects the `TaskHandoff` marker, allocates
- *     `taskId`, returns the submitted envelope to the buyer immediately,
- *     then runs the handoff function in background. The function's return
- *     value becomes the task's terminal `result`; `taskCtx.reject(...)`
- *     becomes a business `rejected` result, and thrown `AdcpError` becomes
- *     the terminal `error`.
- *
- * Generic thrown errors (`Error`, `TypeError`) fall through to the
- * framework's `SERVICE_UNAVAILABLE` mapping.
- *
- * **Wired surface (6.0):** `SalesPlatform` (14 tools — 3 required core +
- * 11 optional; unified hybrid on `create_media_buy` / `sync_creatives`),
- * `CreativeBuilderPlatform` (build_creative / sync_creatives unified
- * hybrid, optional preview_creative sync-only, optional refineCreative),
- * `AudiencePlatform.syncAudiences`, `SignalsPlatform` (get_signals /
- * activate_signal), `AccountStore` (reportUsage, getAccountFinancials),
- * `ContentStandardsPlatform`, `CampaignGovernancePlatform`,
- * `TenantRegistry` (multi-tenant health), `createPostgresTaskRegistry`,
- * `tasks/get` wire handler, per-server + module-level `publishStatusChange`.
- *
- * **Still deferred (rc.1+):** MCP Resources subscription projection for
- * `publishStatusChange`. The no-account tool surface (`preview_creative`,
- * `list_creative_formats`, `provide_performance_feedback`) is now typed
- * via `NoAccountCtx<TCtxMeta>` — handlers receive `ctx.account: Account |
- * undefined` and must narrow before reading `ctx_metadata`.
- *
- * Status: Preview / 6.0. Exported from the canonical `@adcp/sdk/server`
- * entry point; the decisioning implementation remains preview until GA.
- *
- * @public
- */
 import type { AdcpServer } from '../../adcp-server.mjs';
 import { type AdcpServerConfig, type HandlerContext } from '../../create-adcp-server.mjs';
 import type { DecisioningPlatform, RequiredPlatformsFor, RequiredCapabilitiesFor } from '../platform.mjs';