@adcp/sdk 14.0.0 → 14.1.0

package/dist/lib/adapters/implicit-account-store.d.mts

@@ -83,6 +83,8 @@ export interface ImplicitAccountStoreOptions<TCtxMeta = Record<string, unknown>>
      * itself is valid before a fresh `sync_accounts` is required.
      */
     ttlMs?: number;
+    /** Additive sync batches. Default false preserves historical replace-as-revocation behavior. */
+    mergeOnUpsert?: boolean;
 }
 /**
  * In-memory `AccountStore` for `resolution: 'implicit'` platforms.
@@ -125,8 +127,10 @@ export interface ImplicitAccountStoreOptions<TCtxMeta = Record<string, unknown>>
 export declare class InMemoryImplicitAccountStore<TCtxMeta = Record<string, unknown>> implements AccountStore<TCtxMeta> {
     readonly resolution: "implicit";
     private _store;
+    private _writes;
     private _keyFn;
     private _ttlMs;
+    private _mergeOnUpsert;
     private _buildAccount;
     constructor(options?: ImplicitAccountStoreOptions<TCtxMeta>);
     /**
@@ -139,14 +143,10 @@ export declare class InMemoryImplicitAccountStore<TCtxMeta = Record<string, unkn
      * - The stored entry has exceeded `ttlMs`
      * - `ctx.authInfo` is absent or carries no extractable key
      *
-     * **Multi-account note.** When a buyer synced multiple refs in one
-     * `sync_accounts` call, this implementation returns the _first_ stored
-     * account. If your platform requires per-request account disambiguation
-     * (e.g., different brands on the same buyer), switch to `'explicit'` mode
-     * so buyers pass `ext.account_ref` on each request, or override `keyFn`
-     * to encode the brand into the key.
+     * Supplied references match the complete stored natural key. An omitted
+     * reference retains the historical first-account selection.
      */
-    resolve(_ref: AccountReference | undefined, ctx?: ResolveContext): Promise<Account<TCtxMeta> | null>;
+    resolve(ref: AccountReference | undefined, ctx?: ResolveContext): Promise<Account<TCtxMeta> | null>;
     /**
      * Process a `sync_accounts` payload: build accounts from refs and store
      * them under the caller's auth key.
@@ -163,6 +163,11 @@ export declare class InMemoryImplicitAccountStore<TCtxMeta = Record<string, unkn
      * reaching this method.
      */
     upsert(refs: AccountReference[], ctx?: ResolveContext): Promise<SyncAccountsResultRow[]>;
+    private withPrincipalLock;
+    private upsertUnlocked;
+    /** Revoke a single reference for this principal without clearing other brands. */
+    remove(ref: AccountReference, ctx?: ResolveContext): Promise<void>;
+    private removeUnlocked;
     /** Remove all stored sync linkages. */
     clear(): void;
     /**

package/dist/lib/adapters/implicit-account-store.d.ts

@@ -83,6 +83,8 @@ export interface ImplicitAccountStoreOptions<TCtxMeta = Record<string, unknown>>
      * itself is valid before a fresh `sync_accounts` is required.
      */
     ttlMs?: number;
+    /** Additive sync batches. Default false preserves historical replace-as-revocation behavior. */
+    mergeOnUpsert?: boolean;
 }
 /**
  * In-memory `AccountStore` for `resolution: 'implicit'` platforms.
@@ -125,8 +127,10 @@ export interface ImplicitAccountStoreOptions<TCtxMeta = Record<string, unknown>>
 export declare class InMemoryImplicitAccountStore<TCtxMeta = Record<string, unknown>> implements AccountStore<TCtxMeta> {
     readonly resolution: "implicit";
     private _store;
+    private _writes;
     private _keyFn;
     private _ttlMs;
+    private _mergeOnUpsert;
     private _buildAccount;
     constructor(options?: ImplicitAccountStoreOptions<TCtxMeta>);
     /**
@@ -139,14 +143,10 @@ export declare class InMemoryImplicitAccountStore<TCtxMeta = Record<string, unkn
      * - The stored entry has exceeded `ttlMs`
      * - `ctx.authInfo` is absent or carries no extractable key
      *
-     * **Multi-account note.** When a buyer synced multiple refs in one
-     * `sync_accounts` call, this implementation returns the _first_ stored
-     * account. If your platform requires per-request account disambiguation
-     * (e.g., different brands on the same buyer), switch to `'explicit'` mode
-     * so buyers pass `ext.account_ref` on each request, or override `keyFn`
-     * to encode the brand into the key.
+     * Supplied references match the complete stored natural key. An omitted
+     * reference retains the historical first-account selection.
      */
-    resolve(_ref: AccountReference | undefined, ctx?: ResolveContext): Promise<Account<TCtxMeta> | null>;
+    resolve(ref: AccountReference | undefined, ctx?: ResolveContext): Promise<Account<TCtxMeta> | null>;
     /**
      * Process a `sync_accounts` payload: build accounts from refs and store
      * them under the caller's auth key.
@@ -163,6 +163,11 @@ export declare class InMemoryImplicitAccountStore<TCtxMeta = Record<string, unkn
      * reaching this method.
      */
     upsert(refs: AccountReference[], ctx?: ResolveContext): Promise<SyncAccountsResultRow[]>;
+    private withPrincipalLock;
+    private upsertUnlocked;
+    /** Revoke a single reference for this principal without clearing other brands. */
+    remove(ref: AccountReference, ctx?: ResolveContext): Promise<void>;
+    private removeUnlocked;
     /** Remove all stored sync linkages. */
     clear(): void;
     /**

package/dist/lib/adapters/implicit-account-store.js

@@ -22,6 +22,7 @@ __export(implicit_account_store_exports, {
   defaultImplicitKeyFn: () => defaultImplicitKeyFn
 });
 module.exports = __toCommonJS(implicit_account_store_exports);
+var import_account_key = require('../core/account-key.js');
 function defaultImplicitKeyFn(authInfo) {
   const cred = authInfo.credential;
   if (!cred) return void 0;
@@ -35,11 +36,7 @@ function defaultImplicitKeyFn(authInfo) {
   }
 }
 function refNaturalKey(ref) {
-  const r = ref;
-  const domain = r["brand"]?.["domain"];
-  const operator = r["operator"];
-  const sandbox = Boolean(r["sandbox"]);
-  return `${domain ?? ""}|${operator ?? ""}|${sandbox ? "1" : "0"}`;
+  return (0, import_account_key.accountReferenceKey)(ref);
 }
 function defaultBuildAccount(ref, _ctx) {
   const r = ref;
@@ -55,19 +52,25 @@ function defaultBuildAccount(ref, _ctx) {
     ...brand !== void 0 && { brand },
     ...operator !== "" && { operator },
     ...sandbox && { sandbox: true },
+    ..."operator_unit" in ref && { operator_unit: ref.operator_unit },
+    ..."currency" in ref && { currency: ref.currency },
+    ..."timezone" in ref && { timezone: ref.timezone },
     ctx_metadata: {}
   };
 }
 class InMemoryImplicitAccountStore {
   resolution = "implicit";
   _store = /* @__PURE__ */ new Map();
+  _writes = /* @__PURE__ */ new Map();
   _keyFn;
   _ttlMs;
+  _mergeOnUpsert;
   _buildAccount;
   constructor(options) {
     this._buildAccount = options?.buildAccount ?? defaultBuildAccount;
     this._keyFn = options?.keyFn ?? defaultImplicitKeyFn;
     this._ttlMs = options?.ttlMs ?? 864e5;
+    this._mergeOnUpsert = options?.mergeOnUpsert ?? false;
   }
   /**
    * Resolve the caller's account from the auth-principal→account mapping
@@ -79,14 +82,10 @@ class InMemoryImplicitAccountStore {
    * - The stored entry has exceeded `ttlMs`
    * - `ctx.authInfo` is absent or carries no extractable key
    *
-   * **Multi-account note.** When a buyer synced multiple refs in one
-   * `sync_accounts` call, this implementation returns the _first_ stored
-   * account. If your platform requires per-request account disambiguation
-   * (e.g., different brands on the same buyer), switch to `'explicit'` mode
-   * so buyers pass `ext.account_ref` on each request, or override `keyFn`
-   * to encode the brand into the key.
+   * Supplied references match the complete stored natural key. An omitted
+   * reference retains the historical first-account selection.
    */
-  async resolve(_ref, ctx) {
+  async resolve(ref, ctx) {
     const authInfo = ctx?.authInfo;
     if (!authInfo) return null;
     const key = this._keyFn(authInfo);
@@ -97,7 +96,13 @@ class InMemoryImplicitAccountStore {
       this._store.delete(key);
       return null;
     }
-    return entry.accounts[0] ?? null;
+    if (ref === void 0)
+      return entry.accounts.find(
+        (_account, index2) => Date.now() - (entry.storedAtByKey.get(refNaturalKey(entry.refs[index2])) ?? entry.storedAt) <= this._ttlMs
+      ) ?? null;
+    const index = entry.refs.findIndex((stored) => refNaturalKey(stored) === refNaturalKey(ref));
+    if (Date.now() - (entry.storedAtByKey.get(refNaturalKey(ref)) ?? entry.storedAt) > this._ttlMs) return null;
+    return index < 0 ? null : entry.accounts[index] ?? null;
   }
   /**
    * Process a `sync_accounts` payload: build accounts from refs and store
@@ -115,6 +120,25 @@ class InMemoryImplicitAccountStore {
    * reaching this method.
    */
   async upsert(refs, ctx) {
+    const snapshot = structuredClone(refs);
+    return this.withPrincipalLock(ctx, () => this.upsertUnlocked(snapshot, ctx));
+  }
+  withPrincipalLock(ctx, run) {
+    const key = ctx?.authInfo ? this._keyFn(ctx.authInfo) : void 0;
+    if (key === void 0) return run();
+    const next = (this._writes.get(key) ?? Promise.resolve()).then(run);
+    const tail = next.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this._writes.set(key, tail);
+    return next.finally(() => {
+      if (this._writes.get(key) === tail) this._writes.delete(key);
+    });
+  }
+  async upsertUnlocked(refs, ctx) {
     const authInfo = ctx?.authInfo;
     const key = authInfo !== void 0 ? this._keyFn(authInfo) : void 0;
     if (key === void 0) {
@@ -136,8 +160,10 @@ class InMemoryImplicitAccountStore {
     }
     const existing = this._store.get(key);
     const existingByNk = /* @__PURE__ */ new Map();
-    if (existing) {
+    if (existing && Date.now() - existing.storedAt <= this._ttlMs) {
       for (let i = 0; i < existing.refs.length; i++) {
+        if (Date.now() - (existing.storedAtByKey.get(refNaturalKey(existing.refs[i])) ?? existing.storedAt) > this._ttlMs)
+          continue;
         existingByNk.set(refNaturalKey(existing.refs[i]), {
           account: existing.accounts[i],
           ref: existing.refs[i]
@@ -194,13 +220,41 @@ class InMemoryImplicitAccountStore {
       }
     }
     if (newAccounts.length > 0) {
-      this._store.set(key, { accounts: newAccounts, refs: newRefs, storedAt: Date.now() });
+      const storedAt = Date.now();
+      const storedAtByKey = new Map(newRefs.map((ref) => [refNaturalKey(ref), storedAt]));
+      if (this._mergeOnUpsert && ctx?.input?.delete_missing !== true) {
+        const syncedKeys = new Set(newRefs.map(refNaturalKey));
+        for (const [nk, hit] of existingByNk) {
+          if (!syncedKeys.has(nk)) {
+            newAccounts.push(hit.account);
+            newRefs.push(hit.ref);
+            storedAtByKey.set(nk, existing.storedAtByKey.get(nk) ?? existing.storedAt);
+          }
+        }
+      }
+      this._store.set(key, { accounts: newAccounts, refs: newRefs, storedAt, storedAtByKey });
     }
     return rows;
   }
   // ---------------------------------------------------------------------------
   // Test helpers
   // ---------------------------------------------------------------------------
+  /** Revoke a single reference for this principal without clearing other brands. */
+  async remove(ref, ctx) {
+    return this.withPrincipalLock(ctx, () => this.removeUnlocked(ref, ctx));
+  }
+  async removeUnlocked(ref, ctx) {
+    const key = ctx?.authInfo ? this._keyFn(ctx.authInfo) : void 0;
+    if (key === void 0) return;
+    const entry = this._store.get(key);
+    if (!entry) return;
+    const index = entry.refs.findIndex((stored) => refNaturalKey(stored) === refNaturalKey(ref));
+    if (index < 0) return;
+    entry.refs.splice(index, 1);
+    entry.accounts.splice(index, 1);
+    entry.storedAtByKey.delete(refNaturalKey(ref));
+    if (!entry.accounts.length) this._store.delete(key);
+  }
   /** Remove all stored sync linkages. */
   clear() {
     this._store.clear();

package/dist/lib/adapters/implicit-account-store.mjs

@@ -1,3 +1,4 @@
+import { accountReferenceKey } from "../core/account-key.mjs";
 function defaultImplicitKeyFn(authInfo) {
   const cred = authInfo.credential;
   if (!cred) return void 0;
@@ -11,11 +12,7 @@ function defaultImplicitKeyFn(authInfo) {
   }
 }
 function refNaturalKey(ref) {
-  const r = ref;
-  const domain = r["brand"]?.["domain"];
-  const operator = r["operator"];
-  const sandbox = Boolean(r["sandbox"]);
-  return `${domain ?? ""}|${operator ?? ""}|${sandbox ? "1" : "0"}`;
+  return accountReferenceKey(ref);
 }
 function defaultBuildAccount(ref, _ctx) {
   const r = ref;
@@ -31,19 +28,25 @@ function defaultBuildAccount(ref, _ctx) {
     ...brand !== void 0 && { brand },
     ...operator !== "" && { operator },
     ...sandbox && { sandbox: true },
+    ..."operator_unit" in ref && { operator_unit: ref.operator_unit },
+    ..."currency" in ref && { currency: ref.currency },
+    ..."timezone" in ref && { timezone: ref.timezone },
     ctx_metadata: {}
   };
 }
 class InMemoryImplicitAccountStore {
   resolution = "implicit";
   _store = /* @__PURE__ */ new Map();
+  _writes = /* @__PURE__ */ new Map();
   _keyFn;
   _ttlMs;
+  _mergeOnUpsert;
   _buildAccount;
   constructor(options) {
     this._buildAccount = options?.buildAccount ?? defaultBuildAccount;
     this._keyFn = options?.keyFn ?? defaultImplicitKeyFn;
     this._ttlMs = options?.ttlMs ?? 864e5;
+    this._mergeOnUpsert = options?.mergeOnUpsert ?? false;
   }
   /**
    * Resolve the caller's account from the auth-principal→account mapping
@@ -55,14 +58,10 @@ class InMemoryImplicitAccountStore {
    * - The stored entry has exceeded `ttlMs`
    * - `ctx.authInfo` is absent or carries no extractable key
    *
-   * **Multi-account note.** When a buyer synced multiple refs in one
-   * `sync_accounts` call, this implementation returns the _first_ stored
-   * account. If your platform requires per-request account disambiguation
-   * (e.g., different brands on the same buyer), switch to `'explicit'` mode
-   * so buyers pass `ext.account_ref` on each request, or override `keyFn`
-   * to encode the brand into the key.
+   * Supplied references match the complete stored natural key. An omitted
+   * reference retains the historical first-account selection.
    */
-  async resolve(_ref, ctx) {
+  async resolve(ref, ctx) {
     const authInfo = ctx?.authInfo;
     if (!authInfo) return null;
     const key = this._keyFn(authInfo);
@@ -73,7 +72,13 @@ class InMemoryImplicitAccountStore {
       this._store.delete(key);
       return null;
     }
-    return entry.accounts[0] ?? null;
+    if (ref === void 0)
+      return entry.accounts.find(
+        (_account, index2) => Date.now() - (entry.storedAtByKey.get(refNaturalKey(entry.refs[index2])) ?? entry.storedAt) <= this._ttlMs
+      ) ?? null;
+    const index = entry.refs.findIndex((stored) => refNaturalKey(stored) === refNaturalKey(ref));
+    if (Date.now() - (entry.storedAtByKey.get(refNaturalKey(ref)) ?? entry.storedAt) > this._ttlMs) return null;
+    return index < 0 ? null : entry.accounts[index] ?? null;
   }
   /**
    * Process a `sync_accounts` payload: build accounts from refs and store
@@ -91,6 +96,25 @@ class InMemoryImplicitAccountStore {
    * reaching this method.
    */
   async upsert(refs, ctx) {
+    const snapshot = structuredClone(refs);
+    return this.withPrincipalLock(ctx, () => this.upsertUnlocked(snapshot, ctx));
+  }
+  withPrincipalLock(ctx, run) {
+    const key = ctx?.authInfo ? this._keyFn(ctx.authInfo) : void 0;
+    if (key === void 0) return run();
+    const next = (this._writes.get(key) ?? Promise.resolve()).then(run);
+    const tail = next.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this._writes.set(key, tail);
+    return next.finally(() => {
+      if (this._writes.get(key) === tail) this._writes.delete(key);
+    });
+  }
+  async upsertUnlocked(refs, ctx) {
     const authInfo = ctx?.authInfo;
     const key = authInfo !== void 0 ? this._keyFn(authInfo) : void 0;
     if (key === void 0) {
@@ -112,8 +136,10 @@ class InMemoryImplicitAccountStore {
     }
     const existing = this._store.get(key);
     const existingByNk = /* @__PURE__ */ new Map();
-    if (existing) {
+    if (existing && Date.now() - existing.storedAt <= this._ttlMs) {
       for (let i = 0; i < existing.refs.length; i++) {
+        if (Date.now() - (existing.storedAtByKey.get(refNaturalKey(existing.refs[i])) ?? existing.storedAt) > this._ttlMs)
+          continue;
         existingByNk.set(refNaturalKey(existing.refs[i]), {
           account: existing.accounts[i],
           ref: existing.refs[i]
@@ -170,13 +196,41 @@ class InMemoryImplicitAccountStore {
       }
     }
     if (newAccounts.length > 0) {
-      this._store.set(key, { accounts: newAccounts, refs: newRefs, storedAt: Date.now() });
+      const storedAt = Date.now();
+      const storedAtByKey = new Map(newRefs.map((ref) => [refNaturalKey(ref), storedAt]));
+      if (this._mergeOnUpsert && ctx?.input?.delete_missing !== true) {
+        const syncedKeys = new Set(newRefs.map(refNaturalKey));
+        for (const [nk, hit] of existingByNk) {
+          if (!syncedKeys.has(nk)) {
+            newAccounts.push(hit.account);
+            newRefs.push(hit.ref);
+            storedAtByKey.set(nk, existing.storedAtByKey.get(nk) ?? existing.storedAt);
+          }
+        }
+      }
+      this._store.set(key, { accounts: newAccounts, refs: newRefs, storedAt, storedAtByKey });
     }
     return rows;
   }
   // ---------------------------------------------------------------------------
   // Test helpers
   // ---------------------------------------------------------------------------
+  /** Revoke a single reference for this principal without clearing other brands. */
+  async remove(ref, ctx) {
+    return this.withPrincipalLock(ctx, () => this.removeUnlocked(ref, ctx));
+  }
+  async removeUnlocked(ref, ctx) {
+    const key = ctx?.authInfo ? this._keyFn(ctx.authInfo) : void 0;
+    if (key === void 0) return;
+    const entry = this._store.get(key);
+    if (!entry) return;
+    const index = entry.refs.findIndex((stored) => refNaturalKey(stored) === refNaturalKey(ref));
+    if (index < 0) return;
+    entry.refs.splice(index, 1);
+    entry.accounts.splice(index, 1);
+    entry.storedAtByKey.delete(refNaturalKey(ref));
+    if (!entry.accounts.length) this._store.delete(key);
+  }
   /** Remove all stored sync linkages. */
   clear() {
     this._store.clear();

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

@@ -191,6 +191,7 @@ export declare class CapabilityPreflightError extends Error {
 export declare class AgentClient {
     private agent;
     private config;
+    get accounts(): import("./buyer-account-registry.mjs").BuyerAccountRegistry;
     private client;
     private currentContextId?;
     private pendingTask?;

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

@@ -191,6 +191,7 @@ export declare class CapabilityPreflightError extends Error {
 export declare class AgentClient {
     private agent;
     private config;
+    get accounts(): import("./buyer-account-registry").BuyerAccountRegistry;
     private client;
     private currentContextId?;
     private pendingTask?;

package/dist/lib/core/AgentClient.js

@@ -67,6 +67,9 @@ class AgentClient {
   }
   agent;
   config;
+  get accounts() {
+    return this.client.accounts;
+  }
   client;
   currentContextId;
   pendingTask;

package/dist/lib/core/AgentClient.mjs

@@ -35,6 +35,9 @@ class AgentClient {
   }
   agent;
   config;
+  get accounts() {
+    return this.client.accounts;
+  }
   client;
   currentContextId;
   pendingTask;

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

@@ -11,9 +11,11 @@ import type { AdcpTaskName, TaskRequestFor, TaskResponseTypeMap } from './AgentC
 import type { DeferredTaskStorage } from '../storage/interfaces.mjs';
 import type { Activity, AsyncHandlerConfig } from './AsyncHandler.mjs';
 import { type WebhookHeaderValue, type WebhookHeadersLike } from '../webhooks/index.mjs';
-import { type WebhookRegistrationStore } from './webhook-registration.mjs';
+import { type WebhookRegistration, type WebhookRegistrationStore } from './webhook-registration.mjs';
 import { type ReplayStore, type RevocationStore, type JwksResolver, type WebhookSignatureErrorCode, type ResolvedAgentJwksResolverOptions } from '../signing/server.mjs';
 import type { AdcpCapabilities, FeatureName } from '../utils/capabilities.mjs';
+import { BuyerAccountRegistry, type AccountPolicy, type BuyerAccountStorage } from './buyer-account-registry.mjs';
+import type { ProductCache } from './product-cache.mjs';
 import { type ResolveAccountOptions } from './account-resolution.mjs';
 import { type BuyerPropertyPolicy, type ProductPropertyPolicyMode } from '../media-buy/property-policy.mjs';
 import { type ResolveListOptions } from '../server/targeting-helpers.mjs';
@@ -93,6 +95,10 @@ export type WebhookParseErrorCode = WebhookSignatureErrorCode | 'webhook_signatu
  */
  | 'webhook_unverifiable' | 'webhook_registration_not_found' | 'webhook_registration_mismatch' | 'webhook_verification_context_missing' | 'webhook_registration_store_unavailable' | 'webhook_durable_settlement_unavailable' | 'webhook_publication_in_progress' | 'webhook_idempotency_conflict' | 'webhook_verification_unavailable';
 export interface WebhookVerificationConfig {
+    /** Applicable pins from persisted media-buy records. Reuse refresh callbacks bound to the seller/publisher/tenant across deliveries to share their cooldown. Never use webhook payload fields. */
+    publisherPins?: (registration: Readonly<WebhookRegistration>) => Promise<readonly import('../signing/publisher-pins.mjs').PublisherSigningKeyPin[]>;
+    /** Local diagnostics for request_signature_* discovery causes. */
+    onKeyResolutionError?: (error: unknown) => void;
     /** Deterministic/custom key source. Defaults to resolveAgent brand.json discovery. */
     jwks?: JwksResolver;
     /** Shared nonce replay store. Defaults to one process-local store per client. */
@@ -189,6 +195,13 @@ export declare class WebhookDispatchError extends Error {
  * Configuration for SingleAgentClient (and multi-agent client)
  */
 export interface SingleAgentClientConfig extends ConversationConfig {
+    /** Default off preserves existing wire requests; auto/strict use the provisioning registry. */
+    accountPolicy?: AccountPolicy;
+    accountStorage?: BuyerAccountStorage;
+    accountRegistryMaxEntries?: number;
+    /** Trusted stable caller identity for durable registry partitioning. Default is credential fingerprint. */
+    accountRegistryScope?: string;
+    productCache?: ProductCache;
     /** Durable storage for restart-safe A2A human continuations. */
     deferredStorage?: DeferredTaskStorage;
     /** Resolve current trusted agent configuration for a persisted continuation. */
@@ -460,6 +473,23 @@ export interface CapabilityEvidenceSnapshot {
 export declare class SingleAgentClient {
     private agent;
     private config;
+    private _accounts?;
+    private accountRegistryExplicitlyAccessed;
+    private initialOAuthGrantMaterial?;
+    private accountCredentialMaterial?;
+    private accountCredentialScope?;
+    private credentialScope;
+    private accountScope;
+    get accounts(): BuyerAccountRegistry;
+    private getAccountRegistry;
+    /**
+     * The memoized registry backs `resolveAccount()` only when the caller opts
+     * in with an account policy or registry configuration. Otherwise
+     * `resolveAccount()` keeps the SDK 14.0 sync-on-every-call behavior.
+     */
+    private accountRegistryOptedIn;
+    private accountRegistryContext;
+    private applyAccountPolicy;
     private executor;
     private asyncHandler?;
     private normalizedAgent;

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

@@ -11,9 +11,11 @@ import type { AdcpTaskName, TaskRequestFor, TaskResponseTypeMap } from './AgentC
 import type { DeferredTaskStorage } from '../storage/interfaces';
 import type { Activity, AsyncHandlerConfig } from './AsyncHandler';
 import { type WebhookHeaderValue, type WebhookHeadersLike } from '../webhooks';
-import { type WebhookRegistrationStore } from './webhook-registration';
+import { type WebhookRegistration, type WebhookRegistrationStore } from './webhook-registration';
 import { type ReplayStore, type RevocationStore, type JwksResolver, type WebhookSignatureErrorCode, type ResolvedAgentJwksResolverOptions } from '../signing/server';
 import type { AdcpCapabilities, FeatureName } from '../utils/capabilities';
+import { BuyerAccountRegistry, type AccountPolicy, type BuyerAccountStorage } from './buyer-account-registry';
+import type { ProductCache } from './product-cache';
 import { type ResolveAccountOptions } from './account-resolution';
 import { type BuyerPropertyPolicy, type ProductPropertyPolicyMode } from '../media-buy/property-policy';
 import { type ResolveListOptions } from '../server/targeting-helpers';
@@ -93,6 +95,10 @@ export type WebhookParseErrorCode = WebhookSignatureErrorCode | 'webhook_signatu
  */
  | 'webhook_unverifiable' | 'webhook_registration_not_found' | 'webhook_registration_mismatch' | 'webhook_verification_context_missing' | 'webhook_registration_store_unavailable' | 'webhook_durable_settlement_unavailable' | 'webhook_publication_in_progress' | 'webhook_idempotency_conflict' | 'webhook_verification_unavailable';
 export interface WebhookVerificationConfig {
+    /** Applicable pins from persisted media-buy records. Reuse refresh callbacks bound to the seller/publisher/tenant across deliveries to share their cooldown. Never use webhook payload fields. */
+    publisherPins?: (registration: Readonly<WebhookRegistration>) => Promise<readonly import('../signing/publisher-pins').PublisherSigningKeyPin[]>;
+    /** Local diagnostics for request_signature_* discovery causes. */
+    onKeyResolutionError?: (error: unknown) => void;
     /** Deterministic/custom key source. Defaults to resolveAgent brand.json discovery. */
     jwks?: JwksResolver;
     /** Shared nonce replay store. Defaults to one process-local store per client. */
@@ -189,6 +195,13 @@ export declare class WebhookDispatchError extends Error {
  * Configuration for SingleAgentClient (and multi-agent client)
  */
 export interface SingleAgentClientConfig extends ConversationConfig {
+    /** Default off preserves existing wire requests; auto/strict use the provisioning registry. */
+    accountPolicy?: AccountPolicy;
+    accountStorage?: BuyerAccountStorage;
+    accountRegistryMaxEntries?: number;
+    /** Trusted stable caller identity for durable registry partitioning. Default is credential fingerprint. */
+    accountRegistryScope?: string;
+    productCache?: ProductCache;
     /** Durable storage for restart-safe A2A human continuations. */
     deferredStorage?: DeferredTaskStorage;
     /** Resolve current trusted agent configuration for a persisted continuation. */
@@ -460,6 +473,23 @@ export interface CapabilityEvidenceSnapshot {
 export declare class SingleAgentClient {
     private agent;
     private config;
+    private _accounts?;
+    private accountRegistryExplicitlyAccessed;
+    private initialOAuthGrantMaterial?;
+    private accountCredentialMaterial?;
+    private accountCredentialScope?;
+    private credentialScope;
+    private accountScope;
+    get accounts(): BuyerAccountRegistry;
+    private getAccountRegistry;
+    /**
+     * The memoized registry backs `resolveAccount()` only when the caller opts
+     * in with an account policy or registry configuration. Otherwise
+     * `resolveAccount()` keeps the SDK 14.0 sync-on-every-call behavior.
+     */
+    private accountRegistryOptedIn;
+    private accountRegistryContext;
+    private applyAccountPolicy;
     private executor;
     private asyncHandler?;
     private normalizedAgent;