@adcp/sdk 12.1.0 → 13.0.0-rc.0

package/dist/lib/core/SingleAgentClient.mjs

@@ -57,6 +57,7 @@ import {
   TASK_FEATURE_MAP
 } from "../utils/capabilities.mjs";
 import { normalizeRequestParams } from "../utils/request-normalizer.mjs";
+import { globalAsyncLocalStorage } from "../utils/global-async-local-storage.mjs";
 import { validateUserAgent } from "../utils/validate-user-agent.mjs";
 import { resolveWebhookUrl, selectWebhookTemplate } from "./webhook-url.mjs";
 import { getV25Adapter } from "../adapters/legacy/v2-5/index.mjs";
@@ -65,6 +66,388 @@ import {
   validateProductsAgainstPropertyPolicy
 } from "../media-buy/property-policy.mjs";
 import { resolvePropertyList } from "../server/targeting-helpers.mjs";
+import {
+  CreativeFormatCapabilityError,
+  CreativeFormatProjectionError,
+  projectMediaBuyCreativesForDelivery,
+  projectCreativeForDelivery,
+  projectSyncCreativesForDelivery,
+  resolveCreativeFormatWireMode,
+  stripLegacyCreativeIdentity
+} from "../v2/projection/creative-delivery.mjs";
+import {
+  legacyFormatConverterFromCatalogSnapshots
+} from "../v2/projection/catalog-snapshot.mjs";
+import { toCanonicalOnlyResponse } from "../v2/projection/augment-response.mjs";
+import { legacyFormatRefsForDeclaration } from "../v2/projection/legacy-metadata.mjs";
+import { canonicalize as canonicalizeJson } from "../utils/jcs.mjs";
+const CAPABILITY_DISCOVERY_CONTEXT = /* @__PURE__ */ Symbol("capabilityDiscoveryContext");
+function creativeSchemaSupport(value, depth = 0) {
+  if (depth > 24 || value === null || typeof value !== "object") return "unknown";
+  if (Array.isArray(value)) {
+    let legacy2 = false;
+    for (const item of value) {
+      const support = creativeSchemaSupport(item, depth + 1);
+      if (support === "canonical") return support;
+      if (support === "legacy") legacy2 = true;
+    }
+    return legacy2 ? "legacy" : "unknown";
+  }
+  const object = value;
+  const properties = object.properties;
+  if (properties !== null && typeof properties === "object" && !Array.isArray(properties)) {
+    const keys = properties;
+    if ("creative_id" in keys && "format_kind" in keys) return "canonical";
+    if ("creative_id" in keys && "format_id" in keys) return "legacy";
+  }
+  let legacy = false;
+  for (const child of Object.values(object)) {
+    const support = creativeSchemaSupport(child, depth + 1);
+    if (support === "canonical") return support;
+    if (support === "legacy") legacy = true;
+  }
+  return legacy ? "legacy" : "unknown";
+}
+function hasMediaBuyCreativeFormatData(request) {
+  if (request === null || typeof request !== "object" || Array.isArray(request)) return false;
+  const record = request;
+  return ["packages", "new_packages"].some((key) => {
+    const packages = record[key];
+    return Array.isArray(packages) && packages.some((pkg) => {
+      if (pkg === null || typeof pkg !== "object" || Array.isArray(pkg)) return false;
+      const packageRecord = pkg;
+      return Array.isArray(packageRecord.creatives) || Array.isArray(packageRecord.format_option_refs) || Array.isArray(packageRecord.format_ids) || typeof packageRecord.format_kind === "string" || Object.getOwnPropertySymbols(packageRecord).length > 0;
+    });
+  });
+}
+const CANONICAL_CREATIVE_ACTIVITY_TASKS = /* @__PURE__ */ new Set([
+  "get_products",
+  "create_media_buy",
+  "update_media_buy",
+  "sync_creatives",
+  "list_creatives",
+  "get_media_buys",
+  "get_media_buy_delivery",
+  "get_creative_delivery"
+]);
+const TASK_SCOPED_STATE_LIMIT = 1e4;
+const CANONICAL_PACKAGE_ROUTE_TASKS = /* @__PURE__ */ new Set(["create_media_buy", "update_media_buy", "get_media_buys"]);
+const canonicalCreativeRoutingSnapshots = /* @__PURE__ */ new WeakSet();
+function canonicalAccountRoutingSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const account = value;
+  if (typeof account.account_id === "string") return Object.freeze({ account_id: account.account_id });
+  if (!account.brand || typeof account.brand !== "object" || Array.isArray(account.brand) || typeof account.operator !== "string") {
+    return void 0;
+  }
+  const sourceBrand = account.brand;
+  if (typeof sourceBrand.domain !== "string") return void 0;
+  const brand = Object.freeze({
+    domain: sourceBrand.domain,
+    ...typeof sourceBrand.brand_id === "string" ? { brand_id: sourceBrand.brand_id } : {}
+  });
+  return Object.freeze({
+    brand,
+    operator: account.operator,
+    ...typeof account.sandbox === "boolean" ? { sandbox: account.sandbox } : {}
+  });
+}
+function canonicalOptionRefRoutingSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const ref = value;
+  if (typeof ref.format_option_id !== "string") return void 0;
+  if (ref.scope === "publisher" || typeof ref.publisher_domain === "string") {
+    if (typeof ref.publisher_domain !== "string") return void 0;
+    return Object.freeze({
+      scope: "publisher",
+      publisher_domain: ref.publisher_domain,
+      format_option_id: ref.format_option_id
+    });
+  }
+  return Object.freeze({ scope: "product", format_option_id: ref.format_option_id });
+}
+function canonicalPackageRouteSelectorSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const selector = value;
+  const formatOptionRefs = Array.isArray(selector.format_option_refs) ? selector.format_option_refs.map(canonicalOptionRefRoutingSnapshot).filter((ref) => ref !== void 0) : [];
+  const snapshot = {
+    ...typeof selector.package_id === "string" ? { package_id: selector.package_id } : {},
+    ...typeof selector.product_id === "string" ? { product_id: selector.product_id } : {},
+    ...formatOptionRefs.length > 0 ? { format_option_refs: Object.freeze(formatOptionRefs) } : {}
+  };
+  return Object.keys(snapshot).length > 0 ? Object.freeze(snapshot) : void 0;
+}
+function canonicalCreativeRoutingSnapshot(taskType, request) {
+  if (!CANONICAL_PACKAGE_ROUTE_TASKS.has(taskType) || !request || typeof request !== "object" || Array.isArray(request)) {
+    return void 0;
+  }
+  if (canonicalCreativeRoutingSnapshots.has(request)) {
+    return request;
+  }
+  const record = request;
+  const account = canonicalAccountRoutingSnapshot(record.account);
+  if (!account) return void 0;
+  const packageSnapshots = (key) => Object.freeze(
+    (Array.isArray(record[key]) ? record[key] : []).map(canonicalPackageRouteSelectorSnapshot).filter((selector) => selector !== void 0)
+  );
+  const packages = packageSnapshots("packages");
+  const newPackages = packageSnapshots("new_packages");
+  const snapshot = Object.freeze({
+    account,
+    ...packages.length > 0 ? { packages } : {},
+    ...newPackages.length > 0 ? { new_packages: newPackages } : {}
+  });
+  canonicalCreativeRoutingSnapshots.add(snapshot);
+  return snapshot;
+}
+const canonicalCreativeExecutionStorage = globalAsyncLocalStorage("canonicalCreativeExecution");
+function prepareCanonicalCreativePayload(value, taskType, active = /* @__PURE__ */ new WeakSet(), prepared = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  for (let owner = value; owner !== null; owner = Object.getPrototypeOf(owner)) {
+    const toJSON = Object.getOwnPropertyDescriptor(owner, "toJSON");
+    if (toJSON && (!("value" in toJSON) || typeof toJSON.value === "function")) {
+      throw new CreativeFormatProjectionError(
+        taskType,
+        "(response:toJSON)",
+        "custom or accessor toJSON hooks cannot cross the canonical creative boundary safely"
+      );
+    }
+  }
+  if (active.has(value)) {
+    throw new CreativeFormatProjectionError(
+      taskType,
+      "(response:cycle)",
+      "cyclic values cannot cross the canonical creative boundary"
+    );
+  }
+  const cached = prepared.get(value);
+  if (cached !== void 0) return cached;
+  active.add(value);
+  try {
+    const isArray = Array.isArray(value);
+    const prototype = Object.getPrototypeOf(value);
+    const plain = isArray ? prototype === Array.prototype : prototype === Object.prototype || prototype === null;
+    const output = isArray ? [] : Object.create(prototype === null ? null : Object.prototype);
+    prepared.set(value, output);
+    let changed = !plain;
+    for (const key of Reflect.ownKeys(value)) {
+      if (isArray && key === "length") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor) continue;
+      if (!("value" in descriptor)) {
+        throw new CreativeFormatProjectionError(
+          taskType,
+          `(response:${String(key)})`,
+          "accessors cannot cross the canonical creative boundary safely"
+        );
+      }
+      if (!descriptor.enumerable) continue;
+      const safe = prepareCanonicalCreativePayload(descriptor.value, taskType, active, prepared);
+      if (safe !== descriptor.value) changed = true;
+      Object.defineProperty(output, key, { ...descriptor, value: safe });
+    }
+    if (!changed) {
+      prepared.set(value, value);
+      return value;
+    }
+    return output;
+  } finally {
+    active.delete(value);
+  }
+}
+function projectPreparedCanonicalCreativeResponseValue(value, taskType, legacyFormatConverter, selectorContainer = {}) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => projectPreparedCanonicalCreativeResponseValue(item, taskType, legacyFormatConverter, selectorContainer)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  let projected = value;
+  const isProduct = typeof projected.product_id === "string" && ("name" in projected || "description" in projected) && (Array.isArray(projected.format_ids) || Array.isArray(projected.format_options));
+  if (isProduct) {
+    const canonical = toCanonicalOnlyResponse(
+      { products: [projected] },
+      { legacyFormatConverter }
+    );
+    if (canonical.diagnostics.length > 0 || canonical.response.products.length !== 1) {
+      throw new CreativeFormatProjectionError(
+        taskType,
+        `(product:${String(projected.product_id)})`,
+        "legacy product formats in the response have no complete canonical representation"
+      );
+    }
+    projected = canonical.response.products[0];
+  } else if ((typeof projected.package_id === "string" || typeof projected.product_id === "string") && Array.isArray(projected.format_ids)) {
+    projected = projectMediaBuyCreativesForDelivery(
+      { packages: [projected] },
+      "canonical",
+      taskType === "update_media_buy" ? "update_media_buy" : "create_media_buy",
+      legacyFormatConverter
+    ).packages[0];
+  }
+  if (typeof projected.creative_id === "string" && (projected.format_id !== void 0 || typeof projected.format_kind === "string")) {
+    projected = projectCreativeForDelivery(
+      projected,
+      selectorContainer,
+      "canonical",
+      taskType,
+      legacyFormatConverter
+    );
+  }
+  const nextSelector = Array.isArray(projected.format_ids) || Array.isArray(projected.format_options) || Array.isArray(projected.format_option_refs) ? projected : selectorContainer;
+  let changed = projected !== value;
+  const next = { ...projected };
+  for (const [key, child] of Object.entries(projected)) {
+    const childProjected = projectPreparedCanonicalCreativeResponseValue(
+      child,
+      taskType,
+      legacyFormatConverter,
+      nextSelector
+    );
+    if (childProjected !== child) {
+      next[key] = childProjected;
+      changed = true;
+    }
+  }
+  return changed ? next : projected;
+}
+function projectCanonicalCreativeResponseValue(value, taskType, legacyFormatConverter, selectorContainer = {}) {
+  return projectPreparedCanonicalCreativeResponseValue(
+    prepareCanonicalCreativePayload(value, taskType),
+    taskType,
+    legacyFormatConverter,
+    selectorContainer
+  );
+}
+function projectCanonicalCreativeAncillaryValue(value, taskType, legacyFormatConverter) {
+  try {
+    return stripLegacyCreativeIdentity(projectCanonicalCreativeResponseValue(value, taskType, legacyFormatConverter));
+  } catch (error) {
+    if (!(error instanceof CreativeFormatProjectionError)) throw error;
+    return { omitted: true, reason: "canonical creative payload unavailable" };
+  }
+}
+function canonicalCreativeActivity(activity) {
+  const active = canonicalCreativeExecutionStorage.getStore();
+  const effectiveTaskType = active?.taskType && CANONICAL_CREATIVE_ACTIVITY_TASKS.has(active.taskType) ? active.taskType : activity.task_type;
+  if (!CANONICAL_CREATIVE_ACTIVITY_TASKS.has(effectiveTaskType) || activity.payload === void 0) {
+    return activity;
+  }
+  const converter = active?.taskType === effectiveTaskType ? active.legacyFormatConverter : void 0;
+  const source = activity.type === "protocol_request" && active?.taskType === effectiveTaskType && active.canonicalRequest !== void 0 ? { params: active.canonicalRequest } : activity.payload;
+  try {
+    return {
+      ...activity,
+      payload: stripLegacyCreativeIdentity(projectCanonicalCreativeResponseValue(source, effectiveTaskType, converter))
+    };
+  } catch (error) {
+    if (!(error instanceof CreativeFormatProjectionError)) throw error;
+    return { ...activity, payload: { omitted: true, reason: "canonical creative payload unavailable" } };
+  }
+}
+function canonicalCreativeDiagnosticBody(body, taskType) {
+  if (body === void 0) return void 0;
+  try {
+    const active = canonicalCreativeExecutionStorage.getStore();
+    const converter = active?.taskType === taskType ? active.legacyFormatConverter : void 0;
+    return JSON.stringify(
+      stripLegacyCreativeIdentity(projectCanonicalCreativeResponseValue(JSON.parse(body), taskType, converter))
+    );
+  } catch {
+    return "[canonical creative payload omitted]";
+  }
+}
+function canonicalCreativeTransportActivity(event) {
+  const active = canonicalCreativeExecutionStorage.getStore();
+  const taskType = active?.taskType && CANONICAL_CREATIVE_ACTIVITY_TASKS.has(active.taskType) ? active.taskType : event.taskType ?? event.tool;
+  if (!taskType || !CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType)) return event;
+  return {
+    ...event,
+    ...event.requestBody !== void 0 && {
+      requestBody: canonicalCreativeDiagnosticBody(event.requestBody, taskType)
+    },
+    ...event.responseBody !== void 0 && {
+      responseBody: canonicalCreativeDiagnosticBody(event.responseBody, taskType)
+    }
+  };
+}
+function canonicalCreativeErrorInstance(error, legacySource) {
+  const own = {};
+  const descriptors = Object.getOwnPropertyDescriptors(error);
+  for (const [key, descriptor] of Object.entries(descriptors)) {
+    if ("value" in descriptor) own[key] = descriptor.value;
+  }
+  const { legacySource: _dropLegacySource, own: safeOwn } = stripLegacyCreativeIdentity({ own, legacySource });
+  void _dropLegacySource;
+  const clone = Object.create(Object.getPrototypeOf(error));
+  for (const [key, value] of Object.entries(safeOwn)) {
+    const descriptor = descriptors[key];
+    if (!descriptor || !("value" in descriptor)) continue;
+    Object.defineProperty(clone, key, { ...descriptor, value });
+  }
+  for (const symbol of Object.getOwnPropertySymbols(error)) {
+    const descriptor = Object.getOwnPropertyDescriptor(error, symbol);
+    if (!descriptor || !("value" in descriptor)) continue;
+    const safe = stripLegacyCreativeIdentity({ value: descriptor.value, legacySource });
+    Object.defineProperty(clone, symbol, { ...descriptor, value: safe.value });
+  }
+  return stripLegacyCreativeIdentity(clone);
+}
+const PRIMARY_ADCP_TASK_NAMES = {
+  get_products: true,
+  create_media_buy: true,
+  update_media_buy: true,
+  sync_creatives: true,
+  list_creatives: true,
+  get_media_buys: true,
+  get_media_buy_delivery: true,
+  get_creative_delivery: true,
+  provide_performance_feedback: true,
+  get_signals: true,
+  activate_signal: true,
+  get_adcp_capabilities: true,
+  list_accounts: true,
+  sync_accounts: true,
+  sync_audiences: true,
+  create_property_list: true,
+  get_property_list: true,
+  update_property_list: true,
+  list_property_lists: true,
+  delete_property_list: true,
+  si_get_offering: true,
+  si_initiate_session: true,
+  si_send_message: true,
+  si_terminate_session: true,
+  get_brand_identity: true,
+  sync_plans: true,
+  check_governance: true,
+  report_plan_outcome: true,
+  get_plan_audit_logs: true,
+  context_match: true,
+  identity_match: true
+};
+const STANDARD_ADCP_TASK_NAMES = /* @__PURE__ */ new Set([
+  ...Object.keys(PRIMARY_ADCP_TASK_NAMES),
+  "list_creative_formats",
+  "list_transformers",
+  "preview_creative",
+  "build_creative",
+  // These standard protocol tools still carry legacy creative `format_id`
+  // identity through artifacts, manifests, standards, or rights constraints.
+  // They are available only through explicitly named *Legacy APIs until a
+  // lossless canonical projection exists.
+  "list_content_standards",
+  "get_content_standards",
+  "create_content_standards",
+  "update_content_standards",
+  "calibrate_content",
+  "validate_content_delivery",
+  "get_media_buy_artifacts",
+  "get_creative_features",
+  "get_rights",
+  "acquire_rights",
+  "update_rights"
+]);
 class UnsupportedFeatureError extends Error {
   constructor(feature, serverVersion, message) {
     super(message || `Feature '${feature}' requires AdCP v3 but server is ${serverVersion}`);
@@ -135,6 +518,14 @@ function propertyListReferenceFromRequest(params) {
     ...typeof ref.auth_token === "string" ? { auth_token: ref.auth_token } : {}
   };
 }
+function productPolicyRequestSnapshot(requestParams) {
+  const account = canonicalAccountRoutingSnapshot(requestParams.account);
+  const propertyList = propertyListReferenceFromRequest(requestParams);
+  return Object.freeze({
+    ...account ? { account } : {},
+    ...propertyList ? { property_list: Object.freeze(propertyList) } : {}
+  });
+}
 function hasProductPropertyPolicyRules(policy) {
   return Boolean(
     policy.allowedDomains?.length || policy.allowedPropertyIdentifiers?.length || policy.requireAllowedPropertyMatch || policy.excludedDomains?.length || policy.excludedPropertyIds?.length || policy.strict || policy.unknownSelectorBehavior || policy.missingPublisherPropertiesBehavior
@@ -195,8 +586,8 @@ class SingleAgentClient {
         ...config.validation?.requests != null && { requests: config.validation.requests },
         ...config.validation?.responses != null && { responses: config.validation.responses }
       },
-      onActivity: config.onActivity,
-      onTransportActivity: config.onTransportActivity,
+      onActivity: config.onActivity ? (activity) => config.onActivity(canonicalCreativeActivity(activity)) : void 0,
+      onTransportActivity: config.onTransportActivity ? (event) => config.onTransportActivity(canonicalCreativeTransportActivity(event)) : void 0,
       governance: config.governance,
       adcpVersion: this.resolvedAdcpVersion,
       ...config.wireAdcpVersion !== void 0 && { wireAdcpVersion: config.wireAdcpVersion },
@@ -231,7 +622,237 @@ class SingleAgentClient {
   _syntheticV2WarningFired = false;
   // Gate: emit the synthetic-v2 warning once per client instance
   productPolicyRequestParamsByTask = /* @__PURE__ */ new Map();
+  canonicalCreativeTaskAssociations = /* @__PURE__ */ new Map();
+  canonicalLegacyRoutes = /* @__PURE__ */ new Map();
   resolvedAdcpVersion;
+  resolveLegacyFormatConverter(override, projectionCatalogs = this.config.projectionCatalogs) {
+    return legacyFormatConverterFromCatalogSnapshots(projectionCatalogs, override ?? this.config.legacyFormatConverter);
+  }
+  canonicalAccountScope(account) {
+    if (account === void 0) return "none";
+    return canonicalizeJson(canonicalAccountRoutingSnapshot(account) ?? account);
+  }
+  canonicalLegacyRouteKey(account, productId, ref) {
+    return canonicalizeJson([
+      this.canonicalAccountScope(account),
+      productId,
+      ref.scope,
+      ref.scope === "publisher" ? ref.publisher_domain.toLowerCase() : "",
+      ref.format_option_id
+    ]);
+  }
+  canonicalLegacyPackageRouteKey(account, packageId) {
+    return canonicalizeJson([this.canonicalAccountScope(account), "package", packageId]);
+  }
+  sameCanonicalOptionRef(left, right) {
+    return left.scope === right.scope && left.format_option_id === right.format_option_id && (left.scope !== "publisher" || right.scope === "publisher" && left.publisher_domain.toLowerCase() === right.publisher_domain.toLowerCase());
+  }
+  rememberCanonicalLegacyRoute(key, route) {
+    this.canonicalLegacyRoutes.delete(key);
+    this.canonicalLegacyRoutes.set(key, {
+      ...route,
+      refs: Object.freeze(route.refs.map((ref) => Object.freeze({ ...ref })))
+    });
+    while (this.canonicalLegacyRoutes.size > TASK_SCOPED_STATE_LIMIT) {
+      const oldest = this.canonicalLegacyRoutes.keys().next().value;
+      if (oldest === void 0) break;
+      this.canonicalLegacyRoutes.delete(oldest);
+    }
+  }
+  invalidateCanonicalProductRoutes(products, account) {
+    const accountScope = this.canonicalAccountScope(account);
+    const productIds = /* @__PURE__ */ new Set();
+    for (const value of products) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const productId = value.product_id;
+      if (typeof productId === "string") productIds.add(productId);
+    }
+    if (productIds.size === 0) return;
+    for (const [key, route] of this.canonicalLegacyRoutes) {
+      if (route.kind === "product" && route.accountScope === accountScope && productIds.has(route.productId)) {
+        this.canonicalLegacyRoutes.delete(key);
+      }
+    }
+  }
+  rememberCanonicalProductRoutes(products, account, authoritativeProducts = products) {
+    this.invalidateCanonicalProductRoutes(authoritativeProducts, account);
+    const accountScope = this.canonicalAccountScope(account);
+    for (const value of products) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const product = value;
+      if (typeof product.product_id !== "string" || !Array.isArray(product.format_options)) continue;
+      for (const optionValue of product.format_options) {
+        if (!optionValue || typeof optionValue !== "object" || Array.isArray(optionValue)) continue;
+        const option = optionValue;
+        if (typeof option.format_option_id !== "string") continue;
+        const ref = typeof option.publisher_domain === "string" ? {
+          scope: "publisher",
+          publisher_domain: option.publisher_domain,
+          format_option_id: option.format_option_id
+        } : { scope: "product", format_option_id: option.format_option_id };
+        const refs = legacyFormatRefsForDeclaration(option);
+        if (refs.length === 0) continue;
+        this.rememberCanonicalLegacyRoute(this.canonicalLegacyRouteKey(account, product.product_id, ref), {
+          kind: "product",
+          accountScope,
+          productId: product.product_id,
+          optionRef: ref,
+          refs
+        });
+      }
+    }
+  }
+  routeForOption(account, productId, optionRef) {
+    const accountScope = this.canonicalAccountScope(account);
+    const exactKey = this.canonicalLegacyRouteKey(account, productId, optionRef);
+    const exact = this.canonicalLegacyRoutes.get(exactKey);
+    if (exact) {
+      this.canonicalLegacyRoutes.delete(exactKey);
+      this.canonicalLegacyRoutes.set(exactKey, exact);
+      return exact;
+    }
+    const candidates = [...this.canonicalLegacyRoutes.entries()].filter(
+      ([, route]) => route.kind === "product" && route.productId === productId && this.sameCanonicalOptionRef(route.optionRef, optionRef)
+    );
+    if (candidates.length !== 1) return void 0;
+    const [key, candidate] = candidates[0];
+    if (accountScope === "none" || candidate.accountScope !== "none") return void 0;
+    this.canonicalLegacyRoutes.delete(key);
+    this.canonicalLegacyRoutes.set(key, candidate);
+    return candidate;
+  }
+  routeForPackage(account, packageId) {
+    const exactKey = this.canonicalLegacyPackageRouteKey(account, packageId);
+    const exact = this.canonicalLegacyRoutes.get(exactKey);
+    if (exact) {
+      this.canonicalLegacyRoutes.delete(exactKey);
+      this.canonicalLegacyRoutes.set(exactKey, exact);
+      return exact;
+    }
+    return void 0;
+  }
+  packageIdsFromSelector(selector) {
+    const ids = /* @__PURE__ */ new Set();
+    if (typeof selector.package_id === "string") ids.add(selector.package_id);
+    if (Array.isArray(selector.selector_containers)) {
+      for (const value of selector.selector_containers) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+        for (const id of this.packageIdsFromSelector(value)) ids.add(id);
+      }
+    }
+    return [...ids];
+  }
+  cachedCanonicalLegacyRefs(context, account) {
+    const selector = context.source === "product" ? context.declaration : context.source === "creative" ? context.selector : context.selector;
+    const productId = context.source === "product" ? context.productId : typeof selector.product_id === "string" ? selector.product_id : void 0;
+    if (!productId) {
+      const packageIds = this.packageIdsFromSelector(selector);
+      if (packageIds.length === 0) return void 0;
+      const routes = packageIds.map((packageId) => this.routeForPackage(account, packageId));
+      if (routes.some((route) => route === void 0)) return void 0;
+      const normalized = routes.map(
+        (route) => canonicalizeJson(
+          route.refs.map((ref) => ({ ...ref })).sort((left, right) => canonicalizeJson(left).localeCompare(canonicalizeJson(right)))
+        )
+      );
+      if (!normalized.every((value) => value === normalized[0])) return void 0;
+      return routes[0].refs.map((value) => ({ ...value }));
+    }
+    const rawRefs = [];
+    if (context.source === "product") rawRefs.push(context.declaration);
+    if (context.source === "creative" && context.creative.format_option_ref !== void 0) {
+      rawRefs.push(context.creative.format_option_ref);
+    } else if (Array.isArray(selector.format_option_refs)) {
+      rawRefs.push(...selector.format_option_refs);
+    }
+    const optionRefs = [];
+    for (const value of rawRefs) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const record = value;
+      if (typeof record.format_option_id !== "string") continue;
+      if (record.scope === "publisher" || typeof record.publisher_domain === "string") {
+        if (typeof record.publisher_domain !== "string") continue;
+        optionRefs.push({
+          scope: "publisher",
+          publisher_domain: record.publisher_domain,
+          format_option_id: record.format_option_id
+        });
+      } else {
+        optionRefs.push({ scope: "product", format_option_id: record.format_option_id });
+      }
+    }
+    if (optionRefs.length === 0) return void 0;
+    const resolved = [];
+    for (const ref of optionRefs) {
+      const route = this.routeForOption(account, productId, ref);
+      if (!route) return void 0;
+      resolved.push(...route.refs.map((value) => ({ ...value })));
+    }
+    return resolved;
+  }
+  rememberCanonicalPackageRoutes(response, request) {
+    if (!response || typeof response !== "object" || Array.isArray(response)) return;
+    const requestRecord = request && typeof request === "object" && !Array.isArray(request) ? request : void 0;
+    const account = requestRecord?.account;
+    if (account === void 0) return;
+    const accountScope = this.canonicalAccountScope(account);
+    const requestPackages = ["packages", "new_packages"].flatMap(
+      (key) => Array.isArray(requestRecord?.[key]) ? requestRecord[key].filter(
+        (value) => Boolean(value && typeof value === "object" && !Array.isArray(value))
+      ) : []
+    );
+    const responsePackages = [];
+    const visit = (value, depth = 0) => {
+      if (depth > 8 || !value || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        for (const item of value) visit(item, depth + 1);
+        return;
+      }
+      const record = value;
+      if (typeof record.package_id === "string") responsePackages.push(record);
+      for (const key of ["packages", "affected_packages", "media_buys"]) {
+        if (record[key] !== void 0) visit(record[key], depth + 1);
+      }
+    };
+    visit(response);
+    for (const pkg of responsePackages) {
+      const packageId = pkg.package_id;
+      let selector = pkg;
+      let refs = this.cachedCanonicalLegacyRefs(
+        { source: "selector", selector, operation: "package_route", field: packageId },
+        account
+      );
+      if (!refs) {
+        const byPackageId = requestPackages.filter((value) => value.package_id === packageId);
+        const productId = typeof pkg.product_id === "string" ? pkg.product_id : void 0;
+        const byProduct = productId ? requestPackages.filter((value) => value.product_id === productId) : [];
+        const matches = byPackageId.length === 1 ? byPackageId : byProduct.length === 1 ? byProduct : [];
+        selector = matches[0];
+        if (selector) {
+          refs = this.cachedCanonicalLegacyRefs(
+            { source: "selector", selector, operation: "package_route", field: packageId },
+            account
+          );
+        }
+      }
+      if (!refs || refs.length === 0) continue;
+      this.rememberCanonicalLegacyRoute(this.canonicalLegacyPackageRouteKey(account, packageId), {
+        kind: "package",
+        accountScope,
+        packageId,
+        refs
+      });
+    }
+  }
+  rememberCanonicalPackageRoutesForTask(taskType, response, request) {
+    if (taskType === "create_media_buy" || taskType === "update_media_buy" || taskType === "get_media_buys") {
+      this.rememberCanonicalPackageRoutes(response, request);
+    }
+  }
+  resolveCanonicalFormatLegacyResolver(override, account) {
+    const configured = this.config.canonicalFormatLegacyResolver;
+    return (context) => override?.(context) ?? this.cachedCanonicalLegacyRefs(context, account) ?? configured?.(context);
+  }
   /**
    * Returns the AdCP protocol version this client is configured to speak.
    *
@@ -255,25 +876,52 @@ class SingleAgentClient {
   async ensureEndpointDiscovered(options) {
     throwIfAborted(options?.signal);
     const needsDiscovery = this.normalizedAgent._needsDiscovery;
+    const transport = options?.transport ?? this.config.transport;
+    const usesScopedFetch = transport?.fetchFn !== void 0;
     if (!needsDiscovery) {
       return this.normalizedAgent;
     }
-    if (this.discoveredAgent) {
+    if (!usesScopedFetch && this.discoveredAgent) {
       return this.discoveredAgent;
     }
-    if (this.discoveredEndpoint) {
+    if (!usesScopedFetch && this.discoveredEndpoint) {
       this.discoveredAgent = {
         ...this.normalizedAgent,
         agent_uri: this.discoveredEndpoint
       };
+      if (this.normalizedAgent.oauth_tokens && !this.normalizedAgent.oauth_client_credentials) {
+        const { shareNonInteractiveOAuthProvider } = await import("../auth/oauth/provider-cache.mjs");
+        shareNonInteractiveOAuthProvider(this.normalizedAgent, this.discoveredAgent);
+      }
       return this.discoveredAgent;
     }
-    this.discoveredEndpoint = await this.discoverMCPEndpoint(this.normalizedAgent.agent_uri, options);
+    if (this.normalizedAgent.oauth_client_credentials) {
+      const { ensureClientCredentialsTokens, getAgentStorage } = await import("../auth/oauth/index.mjs");
+      await ensureClientCredentialsTokens(this.normalizedAgent, {
+        storage: getAgentStorage(this.normalizedAgent),
+        allowPrivateIp: isLikelyPrivateUrl(this.normalizedAgent.agent_uri),
+        fetch: transport?.fetchFn
+      });
+    }
+    const discoveredEndpoint = await this.discoverMCPEndpoint(this.normalizedAgent.agent_uri, options);
+    if (usesScopedFetch) {
+      const discoveredAgent = { ...this.normalizedAgent, agent_uri: discoveredEndpoint };
+      if (this.normalizedAgent.oauth_tokens && !this.normalizedAgent.oauth_client_credentials) {
+        const { shareNonInteractiveOAuthProvider } = await import("../auth/oauth/provider-cache.mjs");
+        shareNonInteractiveOAuthProvider(this.normalizedAgent, discoveredAgent);
+      }
+      return discoveredAgent;
+    }
+    this.discoveredEndpoint = discoveredEndpoint;
     this.canonicalBaseUrl = this.computeBaseUrl(this.discoveredEndpoint);
     this.discoveredAgent = {
       ...this.normalizedAgent,
       agent_uri: this.discoveredEndpoint
     };
+    if (this.normalizedAgent.oauth_tokens && !this.normalizedAgent.oauth_client_credentials) {
+      const { shareNonInteractiveOAuthProvider } = await import("../auth/oauth/provider-cache.mjs");
+      shareNonInteractiveOAuthProvider(this.normalizedAgent, this.discoveredAgent);
+    }
     return this.discoveredAgent;
   }
   /**
@@ -285,17 +933,27 @@ class SingleAgentClient {
   async ensureCanonicalUrlResolved(options) {
     throwIfAborted(options?.signal);
     const needsCanonicalUrl = this.normalizedAgent._needsCanonicalUrl;
+    const transport = options?.transport ?? this.config.transport;
+    const usesScopedFetch = transport?.fetchFn !== void 0;
     if (!needsCanonicalUrl) {
       return this.normalizedAgent;
     }
-    if (this.canonicalBaseUrl) {
+    if (!usesScopedFetch && this.canonicalBaseUrl) {
       return {
         ...this.normalizedAgent,
         agent_uri: this.canonicalBaseUrl
       };
     }
+    if (this.normalizedAgent.oauth_client_credentials) {
+      const { ensureClientCredentialsTokens, getAgentStorage } = await import("../auth/oauth/index.mjs");
+      await ensureClientCredentialsTokens(this.normalizedAgent, {
+        storage: getAgentStorage(this.normalizedAgent),
+        allowPrivateIp: isLikelyPrivateUrl(this.normalizedAgent.agent_uri),
+        fetch: transport?.fetchFn
+      });
+    }
     const canonicalUrl = await this.fetchA2ACanonicalUrl(this.normalizedAgent.agent_uri, options);
-    this.canonicalBaseUrl = canonicalUrl;
+    if (!usesScopedFetch) this.canonicalBaseUrl = canonicalUrl;
     return {
       ...this.normalizedAgent,
       agent_uri: canonicalUrl
@@ -313,8 +971,10 @@ class SingleAgentClient {
     const transport = readOptions?.transport ?? this.config.transport;
     const maxResponseBytes = transport?.maxResponseBytes;
     const requestTimeoutMs = resolveRequestTimeoutMs(transport?.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS);
-    const sizeLimitedFetch = wrapFetchWithSizeLimit((input, init) => fetch(input, init));
-    const authToken = this.normalizedAgent.auth_token;
+    const sizeLimitedFetch = wrapFetchWithSizeLimit(
+      (input, init) => transport?.fetchFn ? transport.fetchFn(input, init) : fetch(input, init)
+    );
+    const authToken = this.normalizedAgent.oauth_client_credentials ? this.normalizedAgent.oauth_tokens?.access_token : this.normalizedAgent.auth_token;
     let got401 = false;
     const fetchImpl = async (url, requestInit) => {
       const headers = {
@@ -362,13 +1022,17 @@ class SingleAgentClient {
     } catch (error) {
       if (is401Error(error, got401)) {
         const requirements = await discoverAuthorizationRequirements(agentUri, {
-          allowPrivateIp: isLikelyPrivateUrl(agentUri)
+          allowPrivateIp: isLikelyPrivateUrl(agentUri),
+          fetchFn: transport?.fetchFn
         });
         if (requirements) {
           throw new NeedsAuthorizationError(requirements);
         }
-        const challenge = await probeAuthChallenge(agentUri, { allowPrivateIp: isLikelyPrivateUrl(agentUri) });
-        const oauthMetadata = await discoverOAuthMetadata(agentUri);
+        const challenge = await probeAuthChallenge(agentUri, {
+          allowPrivateIp: isLikelyPrivateUrl(agentUri),
+          fetchFn: transport?.fetchFn
+        });
+        const oauthMetadata = await discoverOAuthMetadata(agentUri, { fetch: transport?.fetchFn });
         throw new AuthenticationRequiredError(agentUri, oauthMetadata || void 0, void 0, challenge ?? void 0);
       }
       throw error;
@@ -409,31 +1073,47 @@ class SingleAgentClient {
     throwIfAborted(options?.signal);
     const { connectMCPWithFallback } = await import("../protocols/mcp.mjs");
     const { probeModernMCPConnection } = await import("../protocols/mcp-modern.mjs");
-    const authToken = this.agent.auth_token;
+    const usesScopedFetch = (options?.transport ?? this.config.transport)?.fetchFn !== void 0;
+    const authToken = this.normalizedAgent.oauth_client_credentials ? this.normalizedAgent.oauth_tokens?.access_token : this.agent.auth_token;
     const agentHeaders = this.agent.headers;
     const authHeaders = { ...agentHeaders, ...createMCPAuthHeaders(authToken) };
-    const authProvider = this.normalizedAgent.oauth_tokens ? (await import("../auth/oauth/index.mjs")).createNonInteractiveOAuthProvider(this.normalizedAgent, {
-      agentHint: this.normalizedAgent.id
+    const oauth = this.normalizedAgent.oauth_tokens && !this.normalizedAgent.oauth_client_credentials ? await import("../auth/oauth/index.mjs") : void 0;
+    const authProvider = oauth ? (await import("../auth/oauth/provider-cache.mjs")).getNonInteractiveOAuthProvider(this.normalizedAgent, {
+      agentHint: this.normalizedAgent.id,
+      storage: oauth.getAgentStorage(this.normalizedAgent),
+      allowHttp: isLikelyPrivateUrl(this.normalizedAgent.agent_uri)
     }) : void 0;
     const testEndpoint = async (url) => {
       try {
         const modern = await probeModernMCPConnection(url, authToken, agentHeaders, {
           authProvider,
           signal: options?.signal,
-          requestTimeoutMs: options?.transport?.requestTimeoutMs ?? this.config.transport?.requestTimeoutMs
+          requestTimeoutMs: options?.transport?.requestTimeoutMs ?? this.config.transport?.requestTimeoutMs,
+          fetchFn: options?.transport?.fetchFn ?? this.config.transport?.fetchFn
         });
         if (modern.connected) {
-          this.discoveredMcpEra = modern.era;
-          this.discoveredMcpEraAt = Date.now();
+          if (!usesScopedFetch) {
+            this.discoveredMcpEra = modern.era;
+            this.discoveredMcpEraAt = Date.now();
+          }
           return { success: true };
         }
-        const client = await connectMCPWithFallback(new URL(url), authHeaders, [], "endpoint discovery", void 0, {
-          signal: options?.signal,
-          requestTimeoutMs: options?.transport?.requestTimeoutMs ?? this.config.transport?.requestTimeoutMs
-        });
+        const client = await connectMCPWithFallback(
+          new URL(url),
+          authHeaders,
+          [],
+          "endpoint discovery",
+          options?.transport?.fetchFn ?? this.config.transport?.fetchFn,
+          {
+            signal: options?.signal,
+            requestTimeoutMs: options?.transport?.requestTimeoutMs ?? this.config.transport?.requestTimeoutMs
+          }
+        );
         await client.close();
-        this.discoveredMcpEra = "legacy";
-        this.discoveredMcpEraAt = Date.now();
+        if (!usesScopedFetch) {
+          this.discoveredMcpEra = "legacy";
+          this.discoveredMcpEraAt = Date.now();
+        }
         return { success: true };
       } catch (error) {
         if (isAbortOrTimeoutError(error)) {
@@ -475,13 +1155,19 @@ class SingleAgentClient {
     }
     if (got401) {
       const requirements = await discoverAuthorizationRequirements(providedUri, {
-        allowPrivateIp: isLikelyPrivateUrl(providedUri)
+        allowPrivateIp: isLikelyPrivateUrl(providedUri),
+        fetchFn: options?.transport?.fetchFn ?? this.config.transport?.fetchFn
       });
       if (requirements) {
         throw new NeedsAuthorizationError(requirements);
       }
-      const challenge = await probeAuthChallenge(providedUri, { allowPrivateIp: isLikelyPrivateUrl(providedUri) });
-      const oauthMetadata = await discoverOAuthMetadata(providedUri);
+      const challenge = await probeAuthChallenge(providedUri, {
+        allowPrivateIp: isLikelyPrivateUrl(providedUri),
+        fetchFn: options?.transport?.fetchFn ?? this.config.transport?.fetchFn
+      });
+      const oauthMetadata = await discoverOAuthMetadata(providedUri, {
+        fetch: options?.transport?.fetchFn ?? this.config.transport?.fetchFn
+      });
       throw new AuthenticationRequiredError(providedUri, oauthMetadata || void 0, void 0, challenge ?? void 0);
     }
     throw new Error(
@@ -592,8 +1278,9 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * This is the lower-level receiver primitive for integrations that need to
    * map malformed webhooks to precise HTTP responses. It verifies the legacy
    * HMAC profile when `webhookSecret` is configured, parses raw JSON bodies,
-   * validates the transport envelope shape, and returns the unwrapped AdCP
-   * result plus routing metadata.
+   * validates the transport envelope shape, and returns the canonicalized
+   * AdCP result plus routing metadata. Legacy wire inspection is intentionally
+   * confined to the transport adapter and is not returned by this primary API.
    */
   async verifyAndParseWebhook(options) {
     const rawBody = options.rawBody ?? rawBodyFromUnknown(options.body);
@@ -625,37 +1312,107 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if (!parsedPayload.ok) {
       return parsedPayload;
     }
+    const parsedTaskType = isObjectRecord(parsedPayload.payload) && typeof parsedPayload.payload.task_type === "string" ? parsedPayload.payload.task_type : void 0;
+    const payloadRecord = isObjectRecord(parsedPayload.payload) ? parsedPayload.payload : void 0;
+    const associatedTaskTypes = new Set(
+      [
+        options.operationId,
+        typeof payloadRecord?.operation_id === "string" ? payloadRecord.operation_id : void 0,
+        typeof payloadRecord?.task_id === "string" ? payloadRecord.task_id : void 0,
+        typeof payloadRecord?.context_id === "string" ? payloadRecord.context_id : void 0
+      ].flatMap((id) => {
+        const taskType = this.canonicalCreativeTaskAssociation(id)?.taskType;
+        return taskType ? [taskType] : [];
+      })
+    );
+    const associatedTaskType = associatedTaskTypes.size === 1 ? [...associatedTaskTypes][0] : void 0;
+    const routedTaskType = options.taskType === "unknown" ? void 0 : options.taskType;
+    const declaredTaskType = routedTaskType ?? parsedTaskType;
+    if (associatedTaskTypes.size > 1 || associatedTaskType !== void 0 && declaredTaskType !== void 0 && associatedTaskType !== declaredTaskType) {
+      return {
+        ok: false,
+        code: "webhook_envelope_invalid",
+        message: "Webhook task_type does not match the locally tracked task association."
+      };
+    }
+    let normalizedTaskType = associatedTaskType ?? declaredTaskType;
     try {
       const normalizedPayload = this.normalizeWebhookPayload(
         parsedPayload.payload,
-        options.taskType ?? "unknown",
+        normalizedTaskType ?? "unknown",
         options.operationId ?? "unknown"
       );
+      normalizedTaskType = normalizedPayload.task_type;
+      if (associatedTaskType !== void 0 && normalizedPayload.task_type !== associatedTaskType) {
+        return {
+          ok: false,
+          code: "webhook_envelope_invalid",
+          message: "Webhook task_type does not match the locally tracked task association."
+        };
+      }
+      const metadata = {
+        operation_id: normalizedPayload.operation_id,
+        context_id: normalizedPayload.context_id,
+        task_id: normalizedPayload.task_id,
+        agent_id: this.agent.id,
+        task_type: normalizedPayload.task_type,
+        status: normalizedPayload.status,
+        message: normalizedPayload.message,
+        timestamp: normalizedPayload.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        idempotency_key: normalizedPayload.idempotency_key,
+        protocol: normalizedPayload.protocol ?? "mcp"
+      };
+      const canonicalResult = this.canonicalizeWebhookCreativeResult(metadata, normalizedPayload.result);
+      const canonicalCreativeTask = CANONICAL_CREATIVE_ACTIVITY_TASKS.has(normalizedPayload.task_type);
+      const legacyFormatConverter = this.legacyFormatConverterForWebhook(metadata);
+      const canonicalEnvelope = canonicalCreativeTask ? stripLegacyCreativeIdentity(
+        projectCanonicalCreativeResponseValue(
+          parsedPayload.payload,
+          normalizedPayload.task_type,
+          legacyFormatConverter
+        )
+      ) : parsedPayload.payload;
+      const canonicalMessage = canonicalCreativeTask ? stripLegacyCreativeIdentity({
+        message: normalizedPayload.message,
+        legacySource: parsedPayload.payload
+      }).message : normalizedPayload.message;
       return {
         ok: true,
         protocol: normalizedPayload.protocol ?? "mcp",
-        envelope: parsedPayload.payload,
-        result: normalizedPayload.result,
+        envelope: canonicalEnvelope,
+        result: canonicalResult,
         metadata: {
           operationId: normalizedPayload.operation_id,
           contextId: normalizedPayload.context_id,
           taskId: normalizedPayload.task_id,
           taskType: normalizedPayload.task_type,
           status: normalizedPayload.status,
-          message: normalizedPayload.message,
+          message: canonicalMessage,
           timestamp: normalizedPayload.timestamp,
           idempotencyKey: normalizedPayload.idempotency_key
         }
       };
     } catch (error) {
+      const canonicalCreativeTask = normalizedTaskType !== void 0 && CANONICAL_CREATIVE_ACTIVITY_TASKS.has(normalizedTaskType);
       if (error instanceof WebhookDispatchError) {
-        return { ok: false, code: error.code, message: error.message, cause: error.cause };
+        if (!canonicalCreativeTask) {
+          return { ok: false, code: error.code, message: error.message };
+        }
+        const safe = stripLegacyCreativeIdentity({
+          message: error.message,
+          legacySource: parsedPayload.payload
+        });
+        return { ok: false, code: error.code, message: safe.message };
+      }
+      const message = error instanceof Error ? error.message : "Webhook payload could not be normalized.";
+      if (canonicalCreativeTask) {
+        const safe = stripLegacyCreativeIdentity({ message, legacySource: parsedPayload.payload });
+        return { ok: false, code: "webhook_result_invalid", message: safe.message };
       }
       return {
         ok: false,
         code: "webhook_result_invalid",
-        message: error instanceof Error ? error.message : "Webhook payload could not be normalized.",
-        cause: error
+        message: "Webhook payload could not be normalized."
       };
     }
   }
@@ -671,36 +1428,88 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       timestamp: parsed.metadata.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
       idempotency_key: parsed.metadata.idempotencyKey,
       protocol: parsed.protocol,
-      rawHTTPPayload: parsed.envelope
+      rawHTTPPayload: CANONICAL_CREATIVE_ACTIVITY_TASKS.has(parsed.metadata.taskType) ? stripLegacyCreativeIdentity(parsed.envelope) : parsed.envelope
     };
-    const policyDispatch = await this.applyProductPropertyPolicyToWebhookResult(
-      parsed.result,
-      metadata
-    );
-    const webhookResult = policyDispatch.result;
-    metadata = policyDispatch.metadata;
-    await this.config.onActivity?.({
-      type: "webhook_received",
-      operation_id: metadata.operation_id,
-      agent_id: metadata.agent_id,
-      context_id: metadata.context_id,
-      task_id: metadata.task_id,
-      task_type: metadata.task_type,
-      status: metadata.status,
-      payload: parsed.result,
-      timestamp: metadata.timestamp
-    });
-    if (policyDispatch.suppressHandler) {
+    this.rememberCanonicalCreativeWebhookContext(metadata);
+    try {
+      const canonicalResult = this.canonicalizeWebhookCreativeResult(metadata, parsed.result);
+      const policyDispatch = await this.applyProductPropertyPolicyToWebhookResult(
+        canonicalResult,
+        metadata
+      );
+      const webhookResult = policyDispatch.result;
+      metadata = policyDispatch.metadata;
+      await this.config.onActivity?.(
+        canonicalCreativeActivity({
+          type: "webhook_received",
+          operation_id: metadata.operation_id,
+          agent_id: metadata.agent_id,
+          context_id: metadata.context_id,
+          task_id: metadata.task_id,
+          task_type: metadata.task_type,
+          status: metadata.status,
+          payload: canonicalResult,
+          timestamp: metadata.timestamp
+        })
+      );
+      if (policyDispatch.suppressHandler) return true;
+      if (this.asyncHandler) {
+        await this.asyncHandler.handleWebhook({ result: webhookResult, metadata });
+        return true;
+      }
+      return false;
+    } finally {
+      this.executor.observeExternalTaskStatus(
+        metadata.operation_id,
+        metadata.status,
+        metadata.rawHTTPPayload
+      );
       this.forgetProductPolicyRequestParams(metadata);
-      return true;
     }
-    if (this.asyncHandler) {
-      await this.asyncHandler.handleWebhook({ result: webhookResult, metadata });
-      this.forgetProductPolicyRequestParams(metadata);
-      return true;
+  }
+  rememberCanonicalCreativeWebhookContext(metadata) {
+    if (!metadata.context_id || !CANONICAL_CREATIVE_ACTIVITY_TASKS.has(metadata.task_type)) return;
+    const association = this.canonicalCreativeTaskAssociation(metadata.operation_id) ?? this.canonicalCreativeTaskAssociation(metadata.task_id) ?? this.canonicalCreativeTaskAssociation(metadata.context_id);
+    if (!association) return;
+    this.rememberCanonicalCreativeTaskAssociation(
+      metadata.context_id,
+      association.taskType,
+      association.legacyFormatConverter,
+      association.routingSnapshot
+    );
+  }
+  canonicalizeWebhookCreativeResult(metadata, result) {
+    if (!result || typeof result !== "object" || Array.isArray(result)) return result;
+    const taskType = metadata.task_type;
+    const legacyFormatConverter = this.legacyFormatConverterForWebhook(metadata);
+    const response = result;
+    if (taskType === "get_products" && Array.isArray(response.products)) {
+      const { response: canonical2, diagnostics } = toCanonicalOnlyResponse(
+        response,
+        { legacyFormatConverter }
+      );
+      const requestParams = this.productPolicyRequestParamsForWebhook(metadata);
+      this.rememberCanonicalProductRoutes(canonical2.products, requestParams.account, response.products);
+      const { _message: _dropLegacyMessage, ...safe } = canonical2;
+      void _dropLegacyMessage;
+      return stripLegacyCreativeIdentity({ ...safe, projection: { diagnostics } });
+    }
+    if (taskType === "list_creatives" && Array.isArray(response.creatives)) {
+      const { _message: _dropLegacyMessage, ...safe } = response;
+      void _dropLegacyMessage;
+      return stripLegacyCreativeIdentity({
+        ...safe,
+        creatives: response.creatives.map(
+          (creative) => projectCreativeForDelivery(creative, {}, "canonical", "list_creatives", legacyFormatConverter)
+        )
+      });
+    }
+    const canonical = CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType) ? stripLegacyCreativeIdentity(projectCanonicalCreativeResponseValue(result, taskType, legacyFormatConverter)) : result;
+    const association = this.canonicalCreativeTaskAssociation(metadata.operation_id) ?? this.canonicalCreativeTaskAssociation(metadata.task_id) ?? this.canonicalCreativeTaskAssociation(metadata.context_id);
+    if (metadata.status === "completed") {
+      this.rememberCanonicalPackageRoutesForTask(taskType, canonical, association?.routingSnapshot);
     }
-    this.forgetProductPolicyRequestParams(metadata);
-    return false;
+    return canonical;
   }
   /**
    * Normalize webhook payload - handles both MCP and A2A webhook formats
@@ -739,7 +1548,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       if (typeof payload.status !== "string" || !WEBHOOK_TASK_STATUSES.has(payload.status)) {
         throw new WebhookDispatchError(
           "webhook_envelope_invalid",
-          `Invalid MCP webhook envelope: unsupported top-level status ${JSON.stringify(payload.status)}. Expected one of ${Array.from(WEBHOOK_TASK_STATUSES).join(", ")}.`
+          `Invalid MCP webhook envelope: unsupported top-level status. Expected one of ${Array.from(WEBHOOK_TASK_STATUSES).join(", ")}.`
         );
       }
       if (typeof payload.timestamp !== "string" || Number.isNaN(Date.parse(payload.timestamp))) {
@@ -779,7 +1588,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         } catch (error) {
           throw new WebhookDispatchError(
             "webhook_result_invalid",
-            `Failed to unwrap A2A webhook payload artifacts: ${error instanceof Error ? error.message : "unknown error"}`,
+            "Failed to unwrap A2A webhook payload artifacts.",
             error
           );
         }
@@ -811,7 +1620,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     }
     throw new WebhookDispatchError(
       "webhook_unsupported_payload",
-      `Unsupported webhook payload format. Expected an MCP webhook envelope with top-level idempotency_key, operation_id, task_id, task_type, status, timestamp, and result, or an A2A Task/TaskStatusUpdateEvent with AdCP data nested in status.message.parts[].data or task artifacts. Received: ${safeJsonPreview(payload)}`
+      "Unsupported webhook payload format. Expected an MCP webhook envelope with top-level idempotency_key, operation_id, task_id, task_type, status, timestamp, and result, or an A2A Task/TaskStatusUpdateEvent with AdCP data nested in status.message.parts[].data or task artifacts."
     );
   }
   /**
@@ -952,7 +1761,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    *
    * Automatically adapts requests for v2 servers and normalizes responses.
    */
-  async executeAndHandle(taskType, handlerName, params, inputHandler, options) {
+  async executeAndHandle(taskType, handlerName, params, inputHandler, options, transformCompletedResponse, legacyFormatConverter, canonicalRequest) {
     throwIfAborted(options?.signal);
     let normalizedParams = normalizeRequestParams(taskType, params, {
       skipIdempotencyAutoInject: options?.skipIdempotencyAutoInject,
@@ -981,26 +1790,36 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if (!options?.skipIdempotencyAutoInject && !options?.skipAccountValidation) {
       this.executor.validateRequest(taskType, normalizedParams);
     }
-    const serverVersion = await this.detectServerVersion(options);
+    const capabilityDiscoveryContext = {};
+    const detectionOptions = {
+      ...options,
+      [CAPABILITY_DISCOVERY_CONTEXT]: capabilityDiscoveryContext
+    };
+    const serverVersion = await this.detectServerVersion(detectionOptions);
     const inputSchemaStripLogs = [];
     const { params: adaptedParams, driftLogs: adaptDriftLogs } = this.adaptRequest(
       taskType,
       normalizedParams,
       serverVersion,
-      inputSchemaStripLogs
+      inputSchemaStripLogs,
+      capabilityDiscoveryContext.toolSchemas
     );
     const v25DriftLogs = [...adaptDriftLogs];
     if (webhookDriftLog) v25DriftLogs.push(webhookDriftLog);
     if (serverVersion === "v2") {
       this.executor.validateAdaptedRequestAgainstV2(taskType, adaptedParams, v25DriftLogs);
     }
-    let result = await this.executor.executeTask(
-      agent,
-      taskType,
-      adaptedParams,
-      inputHandler,
-      effectiveOptions,
-      serverVersion
+    const canonicalInputHandler = this.canonicalCreativeInputHandler(taskType, inputHandler);
+    let result = await canonicalCreativeExecutionStorage.run(
+      { taskType, legacyFormatConverter, canonicalRequest: canonicalRequest ?? normalizedParams },
+      () => this.executor.executeTask(
+        agent,
+        taskType,
+        adaptedParams,
+        canonicalInputHandler,
+        effectiveOptions,
+        serverVersion
+      )
     );
     const postAdapterLogs = [...inputSchemaStripLogs, ...v25DriftLogs];
     if (postAdapterLogs.length > 0) {
@@ -1009,9 +1828,26 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if (result.success && result.data) {
       result.data = this.normalizeResponseToV3(taskType, result.data);
     }
-    result = this.wrapProductPolicySubmittedContinuation(result, taskType, normalizedParams);
-    this.rememberProductPolicyRequestParams(taskType, normalizedParams, result, options);
+    result = this.wrapProductPolicySubmittedContinuation(result, taskType, normalizedParams, options);
+    if (result.status === "working") {
+      this.rememberProductPolicyRequestParams(taskType, normalizedParams, result, options);
+    }
+    this.rememberLegacyFormatConverter(taskType, legacyFormatConverter, result, options);
     result = await this.applyProductPropertyPolicy(result, taskType, normalizedParams);
+    if (CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType)) {
+      const routingSnapshot = canonicalCreativeRoutingSnapshot(taskType, canonicalRequest ?? normalizedParams);
+      result = this.canonicalizeCreativeTaskResult(result, taskType, transformCompletedResponse, legacyFormatConverter);
+      result = this.wrapCanonicalCreativeContinuations(
+        result,
+        taskType,
+        transformCompletedResponse,
+        legacyFormatConverter,
+        routingSnapshot
+      );
+      this.rememberCanonicalCreativeTaskIds(result, taskType, legacyFormatConverter, routingSnapshot);
+    } else if (result.status === "completed" && result.success && result.data && transformCompletedResponse) {
+      result = { ...result, data: transformCompletedResponse(result.data) };
+    }
     if (result.status === "completed" && result.success && this.asyncHandler) {
       const handler = this.config.handlers?.[handlerName];
       if (handler) {
@@ -1021,6 +1857,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           task_id: result.metadata.taskId,
           agent_id: this.agent.id,
           task_type: taskType,
+          status: result.status,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         await handler(result.data, metadata);
@@ -1028,6 +1865,255 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     }
     return result;
   }
+  canonicalCreativeInputHandler(taskType, inputHandler) {
+    if (!inputHandler || !CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType)) return inputHandler;
+    return async (context) => {
+      const active = canonicalCreativeExecutionStorage.getStore();
+      const converter = this.resolveLegacyFormatConverter(
+        active?.taskType === taskType ? active.legacyFormatConverter : void 0
+      );
+      const project = (value) => projectCanonicalCreativeAncillaryValue(value, taskType, converter);
+      const messages = context.messages.map((message) => ({
+        ...message,
+        content: project(message.content)
+      }));
+      const safeContext = {
+        ...context,
+        messages,
+        inputRequest: project(context.inputRequest),
+        getSummary: () => messages.map((message) => `${message.role}: ${JSON.stringify(message.content)}`).join("\n"),
+        getPreviousResponse: (field) => project(context.getPreviousResponse(field))
+      };
+      return inputHandler(safeContext);
+    };
+  }
+  projectCanonicalCreativeData(taskType, data, transform, legacyFormatConverter) {
+    let projected = this.normalizeResponseToV3(taskType, data);
+    const record = projected && typeof projected === "object" ? projected : void 0;
+    const canProjectRead = taskType === "get_products" ? Array.isArray(record?.products) : taskType === "list_creatives" ? Array.isArray(record?.creatives) : true;
+    if (transform && canProjectRead) {
+      projected = transform(projected);
+    } else if (canProjectRead && taskType === "get_products" && record) {
+      const active = canonicalCreativeExecutionStorage.getStore();
+      const { response, diagnostics } = toCanonicalOnlyResponse(record, {
+        legacyFormatConverter: this.resolveLegacyFormatConverter(
+          legacyFormatConverter ?? (active?.taskType === taskType ? active.legacyFormatConverter : void 0)
+        ),
+        projectionCatalogs: this.config.projectionCatalogs
+      });
+      const { _message: _dropLegacyMessage, ...canonical } = response;
+      void _dropLegacyMessage;
+      projected = { ...canonical, projection: { diagnostics } };
+    } else if (canProjectRead && taskType === "list_creatives" && record) {
+      const active = canonicalCreativeExecutionStorage.getStore();
+      const activeLegacyFormatConverter = this.resolveLegacyFormatConverter(
+        legacyFormatConverter ?? (active?.taskType === taskType ? active.legacyFormatConverter : void 0)
+      );
+      const { _message: _dropLegacyMessage, ...safe } = record;
+      void _dropLegacyMessage;
+      projected = {
+        ...safe,
+        creatives: record.creatives.map(
+          (creative) => projectCreativeForDelivery(
+            creative,
+            {},
+            "canonical",
+            "list_creatives",
+            activeLegacyFormatConverter
+          )
+        )
+      };
+    } else if (canProjectRead && CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType)) {
+      const active = canonicalCreativeExecutionStorage.getStore();
+      projected = projectCanonicalCreativeResponseValue(
+        projected,
+        taskType,
+        this.resolveLegacyFormatConverter(
+          legacyFormatConverter ?? (active?.taskType === taskType ? active.legacyFormatConverter : void 0)
+        )
+      );
+    }
+    return stripLegacyCreativeIdentity(projected);
+  }
+  canonicalizeCreativeTaskResult(result, taskType, transform, legacyFormatConverter) {
+    const projectedData = result.data !== void 0 ? this.projectCanonicalCreativeData(taskType, result.data, transform, legacyFormatConverter) : void 0;
+    const errorInstance = result.errorInstance;
+    const converter = this.resolveLegacyFormatConverter(legacyFormatConverter);
+    const metadataRecord = result.metadata;
+    const semanticMetadata = {
+      ...metadataRecord,
+      ...metadataRecord.inputRequest !== void 0 && {
+        inputRequest: projectCanonicalCreativeAncillaryValue(metadataRecord.inputRequest, taskType, converter)
+      }
+    };
+    const semanticConversation = result.conversation?.map((message) => ({
+      ...message,
+      content: projectCanonicalCreativeAncillaryValue(message.content, taskType, converter)
+    }));
+    const safe = stripLegacyCreativeIdentity({
+      data: projectedData,
+      metadata: semanticMetadata,
+      conversation: semanticConversation,
+      debug_logs: result.debug_logs,
+      adcpError: result.adcpError,
+      error: result.error,
+      governance: result.governance,
+      governanceOutcome: result.governanceOutcome,
+      governanceOutcomeError: result.governanceOutcomeError,
+      deferredQuestion: result.deferred?.question,
+      // Token source only: discarded below, but lets the sanitizer remove exact
+      // legacy IDs/URLs when the seller repeats them in messages or diagnostics.
+      legacySource: result.data
+    });
+    const safeErrorInstance = errorInstance ? canonicalCreativeErrorInstance(errorInstance, result.data) : void 0;
+    const safeDeferred = result.deferred ? { ...result.deferred, ...result.deferred.question !== void 0 && { question: safe.deferredQuestion } } : void 0;
+    return attachMatch({
+      ...result,
+      ...result.data !== void 0 && { data: safe.data },
+      metadata: safe.metadata,
+      ...result.conversation !== void 0 && { conversation: safe.conversation },
+      ...result.debug_logs !== void 0 && { debug_logs: safe.debug_logs },
+      ...result.adcpError !== void 0 && { adcpError: safe.adcpError },
+      ...result.error !== void 0 && { error: safe.error },
+      ...result.governance !== void 0 && { governance: safe.governance },
+      ...result.governanceOutcome !== void 0 && { governanceOutcome: safe.governanceOutcome },
+      ...result.governanceOutcomeError !== void 0 && { governanceOutcomeError: safe.governanceOutcomeError },
+      ...safeDeferred !== void 0 && { deferred: safeDeferred },
+      ...safeErrorInstance !== void 0 && { errorInstance: safeErrorInstance }
+    });
+  }
+  canonicalizeCreativeTaskInfo(taskInfo, taskType, transform, legacyFormatConverter) {
+    const source = taskInfo.result;
+    const projected = source !== void 0 ? this.projectCanonicalCreativeData(taskType, source, transform, legacyFormatConverter) : void 0;
+    const { legacySource: _dropLegacySource, ...safe } = stripLegacyCreativeIdentity({
+      ...taskInfo,
+      taskType,
+      ...source !== void 0 && { result: projected },
+      legacySource: source
+    });
+    void _dropLegacySource;
+    return safe;
+  }
+  wrapCanonicalCreativeContinuations(result, taskType, transform, legacyFormatConverter, routingRequest) {
+    const routingSnapshot = canonicalCreativeRoutingSnapshot(taskType, routingRequest);
+    if (result.submitted) {
+      const submitted = result.submitted;
+      result = {
+        ...result,
+        submitted: {
+          ...submitted,
+          track: async (transport) => {
+            const canonical = this.canonicalizeCreativeTaskInfo(
+              await canonicalCreativeExecutionStorage.run(
+                { taskType, legacyFormatConverter },
+                () => submitted.track(transport)
+              ),
+              taskType,
+              transform,
+              legacyFormatConverter
+            );
+            if (canonical.status === "completed" && canonical.result !== void 0) {
+              this.rememberCanonicalPackageRoutesForTask(taskType, canonical.result, routingSnapshot);
+            }
+            return canonical;
+          },
+          waitForCompletion: async (pollInterval, signal) => {
+            const completed = await canonicalCreativeExecutionStorage.run(
+              { taskType, legacyFormatConverter },
+              () => submitted.waitForCompletion(pollInterval, signal)
+            );
+            const canonical = this.canonicalizeCreativeTaskResult(
+              completed,
+              taskType,
+              transform,
+              legacyFormatConverter
+            );
+            if (canonical.success && canonical.status === "completed" && canonical.data !== void 0) {
+              this.rememberCanonicalPackageRoutesForTask(taskType, canonical.data, routingSnapshot);
+            }
+            this.rememberCanonicalCreativeTaskIds(canonical, taskType, legacyFormatConverter, routingSnapshot);
+            return this.wrapCanonicalCreativeContinuations(
+              canonical,
+              taskType,
+              transform,
+              legacyFormatConverter,
+              routingSnapshot
+            );
+          }
+        }
+      };
+    }
+    if (result.deferred) {
+      const deferred = result.deferred;
+      result = {
+        ...result,
+        deferred: {
+          ...deferred,
+          resume: async (input) => {
+            const resumed = await canonicalCreativeExecutionStorage.run(
+              { taskType, legacyFormatConverter },
+              () => deferred.resume(input)
+            );
+            const canonical = this.canonicalizeCreativeTaskResult(resumed, taskType, transform, legacyFormatConverter);
+            if (canonical.success && canonical.status === "completed" && canonical.data !== void 0) {
+              this.rememberCanonicalPackageRoutesForTask(taskType, canonical.data, routingSnapshot);
+            }
+            this.rememberCanonicalCreativeTaskIds(canonical, taskType, legacyFormatConverter, routingSnapshot);
+            return this.wrapCanonicalCreativeContinuations(
+              canonical,
+              taskType,
+              transform,
+              legacyFormatConverter,
+              routingSnapshot
+            );
+          }
+        }
+      };
+    }
+    return attachMatch(result);
+  }
+  rememberCanonicalCreativeTaskIds(result, taskType, legacyFormatConverter, routingRequest) {
+    const routingSnapshot = canonicalCreativeRoutingSnapshot(taskType, routingRequest);
+    const keys = [
+      result.metadata.taskId,
+      result.metadata.contextId,
+      result.metadata.serverTaskId,
+      result.submitted?.taskId
+    ];
+    for (const key of keys) {
+      if (!key) continue;
+      this.rememberCanonicalCreativeTaskAssociation(key, taskType, legacyFormatConverter, routingSnapshot);
+    }
+  }
+  rememberCanonicalCreativeTaskAssociation(key, taskType, legacyFormatConverter, canonicalRequest) {
+    const previous = this.canonicalCreativeTaskAssociations.get(key);
+    const routingSnapshot = canonicalCreativeRoutingSnapshot(taskType, canonicalRequest);
+    const effectiveRoutingSnapshot = routingSnapshot ?? (previous?.taskType === taskType ? previous.routingSnapshot : void 0);
+    this.canonicalCreativeTaskAssociations.delete(key);
+    this.canonicalCreativeTaskAssociations.set(key, {
+      taskType,
+      legacyFormatConverter,
+      ...effectiveRoutingSnapshot ? { routingSnapshot: effectiveRoutingSnapshot } : {}
+    });
+    while (this.canonicalCreativeTaskAssociations.size > TASK_SCOPED_STATE_LIMIT) {
+      const oldest = this.canonicalCreativeTaskAssociations.keys().next().value;
+      if (oldest === void 0) break;
+      this.canonicalCreativeTaskAssociations.delete(oldest);
+    }
+  }
+  canonicalCreativeTaskAssociation(key) {
+    if (!key) return void 0;
+    const association = this.canonicalCreativeTaskAssociations.get(key);
+    if (!association) return void 0;
+    this.canonicalCreativeTaskAssociations.delete(key);
+    this.canonicalCreativeTaskAssociations.set(key, association);
+    return association;
+  }
+  forgetCanonicalCreativeTaskAssociationKeys(keys) {
+    for (const key of keys) {
+      if (key) this.canonicalCreativeTaskAssociations.delete(key);
+    }
+  }
   /**
    * Drop products that arrive without a usable `pricing_options[]` array from a
    * completed `get_products` response. `pricing_options` is required and
@@ -1238,20 +2324,62 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     return result;
   }
   rememberProductPolicyRequestParams(taskType, requestParams, result, options) {
+    this.rememberProductPolicyRequestState(
+      taskType,
+      { request: productPolicyRequestSnapshot(requestParams) },
+      result,
+      options
+    );
+  }
+  rememberProductPolicyRequestState(taskType, requestState, result, options) {
     if (taskType !== "get_products") return;
     if (result.status !== "submitted" && result.status !== "working") return;
     const keys = /* @__PURE__ */ new Set();
     if (result.metadata.taskId) keys.add(result.metadata.taskId);
     if (result.metadata.contextId) keys.add(result.metadata.contextId);
     if (result.metadata.serverTaskId) keys.add(result.metadata.serverTaskId);
+    if (result.submitted?.taskId) keys.add(result.submitted.taskId);
     if (options?.taskId) keys.add(options.taskId);
     if (options?.contextId) keys.add(options.contextId);
     for (const key of keys) {
-      this.productPolicyRequestParamsByTask.set(key, requestParams);
+      this.productPolicyRequestParamsByTask.delete(key);
+      this.productPolicyRequestParamsByTask.set(key, requestState);
+      while (this.productPolicyRequestParamsByTask.size > TASK_SCOPED_STATE_LIMIT) {
+        const oldest = this.productPolicyRequestParamsByTask.keys().next().value;
+        if (oldest === void 0) break;
+        this.productPolicyRequestParamsByTask.delete(oldest);
+      }
     }
   }
+  rememberLegacyFormatConverter(taskType, converter, result, options) {
+    if (!converter || taskType !== "get_products" && taskType !== "list_creatives") return;
+    const metadata = result.metadata;
+    const keys = [
+      metadata.operationId,
+      metadata.taskId,
+      metadata.contextId,
+      metadata.serverTaskId,
+      options?.taskId,
+      options?.contextId
+    ];
+    for (const key of keys) {
+      if (key) this.rememberCanonicalCreativeTaskAssociation(key, taskType, converter);
+    }
+  }
+  legacyFormatConverterForWebhook(metadata) {
+    return this.canonicalCreativeTaskAssociation(metadata.operation_id)?.legacyFormatConverter ?? this.canonicalCreativeTaskAssociation(metadata.task_id)?.legacyFormatConverter ?? this.canonicalCreativeTaskAssociation(metadata.context_id)?.legacyFormatConverter ?? this.resolveLegacyFormatConverter();
+  }
   forgetProductPolicyRequestParams(metadata) {
-    this.forgetProductPolicyRequestParamKeys([metadata.operation_id, metadata.task_id, metadata.context_id]);
+    const aliases = [metadata.operation_id, metadata.task_id, metadata.context_id];
+    const states = new Set(
+      aliases.filter((key) => key !== void 0).map((key) => this.productPolicyRequestParamsByTask.get(key)).filter((value) => value !== void 0)
+    );
+    for (const state of states) state.request = void 0;
+    this.forgetProductPolicyRequestParamKeys(aliases);
+    if (states.size === 0) return;
+    for (const [key, state] of this.productPolicyRequestParamsByTask) {
+      if (states.has(state)) this.productPolicyRequestParamsByTask.delete(key);
+    }
   }
   forgetProductPolicyRequestParamKeys(keys) {
     for (const key of keys) {
@@ -1259,38 +2387,61 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       this.productPolicyRequestParamsByTask.delete(key);
     }
   }
-  wrapProductPolicySubmittedContinuation(result, taskType, requestParams) {
+  wrapProductPolicySubmittedContinuation(result, taskType, requestParams, options) {
     if (taskType !== "get_products" || result.status !== "submitted" || !result.submitted) return result;
     const submitted = result.submitted;
+    const policyState = {
+      request: productPolicyRequestSnapshot(requestParams)
+    };
+    this.rememberProductPolicyRequestState(taskType, policyState, result, options);
+    const retainedKeys = [
+      result.metadata.taskId,
+      result.metadata.contextId,
+      result.metadata.serverTaskId,
+      submitted.taskId,
+      options?.taskId,
+      options?.contextId
+    ];
     result.submitted = {
       ...submitted,
       track: async (transport) => {
         const taskInfo = await submitted.track(transport);
-        const processed = await this.applyProductPropertyPolicyToTaskInfo(taskInfo, taskType, requestParams);
-        if (["completed", "failed", "rejected", "canceled"].includes(processed.status)) {
-          this.forgetProductPolicyRequestParamKeys([
-            result.metadata.taskId,
-            result.metadata.serverTaskId,
-            processed.taskId
-          ]);
+        const terminal = ["completed", "failed", "rejected", "canceled"].includes(taskInfo.status);
+        try {
+          return await this.applyProductPropertyPolicyToTaskInfo(
+            taskInfo,
+            taskType,
+            policyState.request ?? {}
+          );
+        } finally {
+          if (terminal) {
+            policyState.request = void 0;
+            this.forgetProductPolicyRequestParamKeys([...retainedKeys, taskInfo.taskId]);
+          }
         }
-        return processed;
       },
       waitForCompletion: async (pollInterval, signal) => {
         let completed = await submitted.waitForCompletion(pollInterval, signal);
         if (completed.success && completed.data) {
           completed.data = this.normalizeResponseToV3(taskType, completed.data);
         }
-        const processed = await this.applyProductPropertyPolicy(completed, taskType, requestParams);
-        if (processed.status === "completed" || processed.status === "failed") {
-          this.forgetProductPolicyRequestParamKeys([
-            result.metadata.taskId,
-            result.metadata.serverTaskId,
-            processed.metadata.taskId,
-            processed.metadata.serverTaskId
-          ]);
+        const terminal = completed.status === "completed" || completed.status === "failed";
+        try {
+          return await this.applyProductPropertyPolicy(
+            completed,
+            taskType,
+            policyState.request ?? {}
+          );
+        } finally {
+          if (terminal) {
+            policyState.request = void 0;
+            this.forgetProductPolicyRequestParamKeys([
+              ...retainedKeys,
+              completed.metadata.taskId,
+              completed.metadata.serverTaskId
+            ]);
+          }
         }
-        return processed;
       }
     };
     return result;
@@ -1328,7 +2479,15 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     };
   }
   productPolicyRequestParamsForWebhook(metadata) {
-    return this.executor.getRequestParams(metadata.operation_id) ?? this.executor.getRequestParams(metadata.task_id) ?? this.productPolicyRequestParamsByTask.get(metadata.operation_id) ?? this.productPolicyRequestParamsByTask.get(metadata.task_id) ?? (metadata.context_id ? this.productPolicyRequestParamsByTask.get(metadata.context_id) : void 0) ?? {};
+    return this.executor.getRequestParams(metadata.operation_id) ?? this.executor.getRequestParams(metadata.task_id) ?? this.productPolicyRequestParamsForKey(metadata.operation_id) ?? this.productPolicyRequestParamsForKey(metadata.task_id) ?? this.productPolicyRequestParamsForKey(metadata.context_id) ?? {};
+  }
+  productPolicyRequestParamsForKey(key) {
+    if (!key) return void 0;
+    const state = this.productPolicyRequestParamsByTask.get(key);
+    if (!state?.request) return void 0;
+    this.productPolicyRequestParamsByTask.delete(key);
+    this.productPolicyRequestParamsByTask.set(key, state);
+    return state.request;
   }
   async applyProductPropertyPolicyToWebhookResult(result, metadata) {
     if (metadata.task_type !== "get_products" || metadata.status !== "completed" || !result) {
@@ -1373,17 +2532,17 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * 3.1-only fields for a 3.0 seller). Returns the adapted params and any
    * drift log entries describing what was changed.
    *
-   * Runs after `detectServerVersion` so `cachedCapabilities` is populated
-   * and the protocol-version adapters see the seller's declared caps.
+   * Runs after `detectServerVersion` so capabilities are available and the
+   * current call's tool schemas can be supplied without cross-tenant caching.
    */
-  adaptRequest(taskType, params, serverVersion, debugLogs) {
+  adaptRequest(taskType, params, serverVersion, debugLogs, perCallToolSchemas) {
     const driftLogs = [];
     let adapted = params;
     if (serverVersion !== "v3") {
       const pair = getV25Adapter(taskType);
       if (pair) adapted = pair.adaptRequest(adapted);
     }
-    const toolSchema = this.cachedToolSchemas?.get(taskType);
+    const toolSchema = (perCallToolSchemas ?? this.cachedToolSchemas)?.get(taskType);
     if (toolSchema && Object.keys(toolSchema).length > 0) {
       const declaredFields = new Set(Object.keys(toolSchema));
       const adapterAliases = [["brand_manifest", "brand"]];
@@ -1523,30 +2682,57 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getProducts(params, inputHandler, options) {
+    const { legacyFormatConverter, projectionCatalogs, ...taskOptions } = options ?? {};
+    const effectiveLegacyFormatConverter = this.resolveLegacyFormatConverter(
+      legacyFormatConverter,
+      projectionCatalogs ?? this.config.projectionCatalogs
+    );
+    const account = canonicalAccountRoutingSnapshot(params.account);
     return this.executeAndHandle(
       "get_products",
       "onGetProductsStatusChange",
       params,
       inputHandler,
-      options
+      taskOptions,
+      (data) => {
+        const { response, diagnostics } = toCanonicalOnlyResponse(data, {
+          legacyFormatConverter: effectiveLegacyFormatConverter,
+          projectionCatalogs: projectionCatalogs ?? this.config.projectionCatalogs
+        });
+        const authoritativeProducts = Array.isArray(data.products) ? data.products : response.products;
+        this.rememberCanonicalProductRoutes(response.products, account, authoritativeProducts);
+        const { _message: _dropLegacyMessage, ...canonical } = response;
+        void _dropLegacyMessage;
+        return { ...canonical, projection: { diagnostics } };
+      },
+      effectiveLegacyFormatConverter
     );
   }
+  /** @deprecated Explicit raw-wire escape hatch for migration tooling. */
+  async getProductsLegacy(params, inputHandler, options) {
+    return this.executeTaskUnprojected("get_products", params, inputHandler, options);
+  }
   /**
-   * List available creative formats
+   * List a legacy named-format catalog for migration tooling.
    *
    * @param params - Format listing parameters
    * @param inputHandler - Handler for clarification requests
    * @param options - Task execution options
+   * @deprecated Canonical applications discover `format_options[]` through `getProducts()`.
    */
-  async listCreativeFormats(params, inputHandler, options) {
+  async listCreativeFormatsLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "list_creative_formats",
-      "onListCreativeFormatsStatusChange",
+      "onListCreativeFormatsLegacyStatusChange",
       params,
       inputHandler,
       options
     );
   }
+  /** @deprecated Migration-only access to legacy creative transformer declarations. */
+  async listTransformersLegacy(params, inputHandler, options) {
+    return this.executeTaskUnprojected("list_transformers", params, inputHandler, options);
+  }
   /**
    * Create a new media buy
    *
@@ -1555,6 +2741,23 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @param options - Task execution options
    */
   async createMediaBuy(params, inputHandler, options) {
+    const { legacyFormatConverter, projectionCatalogs, canonicalFormatLegacyResolver, ...taskOptions } = options ?? {};
+    const effectiveLegacyFormatConverter = this.resolveLegacyFormatConverter(
+      legacyFormatConverter,
+      projectionCatalogs ?? this.config.projectionCatalogs
+    );
+    const effectiveCanonicalFormatLegacyResolver = this.resolveCanonicalFormatLegacyResolver(
+      canonicalFormatLegacyResolver,
+      params.account
+    );
+    const hasCreativeFormatData = hasMediaBuyCreativeFormatData(params);
+    if (hasCreativeFormatData) {
+      this.validateBeforeCreativeCapabilityProbe("create_media_buy", params, taskOptions);
+    }
+    const wireMode = hasCreativeFormatData ? this.resolveCreativeFormatWireMode(
+      "create_media_buy",
+      await this.getCapabilities({ signal: taskOptions.signal, transport: taskOptions.transport })
+    ) : "canonical";
     if (this.config.webhookUrlTemplate && !options?.disableWebhook) {
       const now = /* @__PURE__ */ new Date();
       const year = now.getUTCFullYear();
@@ -1589,9 +2792,28 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         };
       }
     }
-    return this.executeAndHandle(
+    const result = await this.executeAndHandle(
       "create_media_buy",
       "onCreateMediaBuyStatusChange",
+      projectMediaBuyCreativesForDelivery(
+        params,
+        wireMode,
+        "create_media_buy",
+        effectiveLegacyFormatConverter,
+        effectiveCanonicalFormatLegacyResolver
+      ),
+      inputHandler,
+      taskOptions,
+      void 0,
+      effectiveLegacyFormatConverter,
+      params
+    );
+    if (result.data !== void 0) this.rememberCanonicalPackageRoutes(result.data, params);
+    return result;
+  }
+  /** @deprecated Compatibility-only entry point for callers still holding legacy creative `format_id` values. */
+  async createMediaBuyLegacy(params, inputHandler, options) {
+    return await this.createMediaBuy(
       params,
       inputHandler,
       options
@@ -1605,9 +2827,45 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @param options - Task execution options
    */
   async updateMediaBuy(params, inputHandler, options) {
-    return this.executeAndHandle(
+    const { legacyFormatConverter, projectionCatalogs, canonicalFormatLegacyResolver, ...taskOptions } = options ?? {};
+    const effectiveLegacyFormatConverter = this.resolveLegacyFormatConverter(
+      legacyFormatConverter,
+      projectionCatalogs ?? this.config.projectionCatalogs
+    );
+    const effectiveCanonicalFormatLegacyResolver = this.resolveCanonicalFormatLegacyResolver(
+      canonicalFormatLegacyResolver,
+      params.account
+    );
+    const hasCreativeFormatData = hasMediaBuyCreativeFormatData(params);
+    if (hasCreativeFormatData) {
+      this.validateBeforeCreativeCapabilityProbe("update_media_buy", params, taskOptions);
+    }
+    const wireMode = hasCreativeFormatData ? this.resolveCreativeFormatWireMode(
+      "update_media_buy",
+      await this.getCapabilities({ signal: taskOptions.signal, transport: taskOptions.transport })
+    ) : "canonical";
+    const result = await this.executeAndHandle(
       "update_media_buy",
       "onUpdateMediaBuyStatusChange",
+      projectMediaBuyCreativesForDelivery(
+        params,
+        wireMode,
+        "update_media_buy",
+        effectiveLegacyFormatConverter,
+        effectiveCanonicalFormatLegacyResolver
+      ),
+      inputHandler,
+      taskOptions,
+      void 0,
+      effectiveLegacyFormatConverter,
+      params
+    );
+    if (result.data !== void 0) this.rememberCanonicalPackageRoutes(result.data, params);
+    return result;
+  }
+  /** @deprecated Compatibility-only entry point for callers still holding legacy creative `format_id` values. */
+  async updateMediaBuyLegacy(params, inputHandler, options) {
+    return await this.updateMediaBuy(
       params,
       inputHandler,
       options
@@ -1621,41 +2879,149 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @param options - Task execution options
    */
   async syncCreatives(params, inputHandler, options) {
+    const {
+      creativeFormatProjection,
+      legacyFormatConverter,
+      projectionCatalogs,
+      canonicalFormatLegacyResolver,
+      ...taskOptions
+    } = options ?? {};
+    const effectiveCanonicalFormatLegacyResolver = this.resolveCanonicalFormatLegacyResolver(
+      canonicalFormatLegacyResolver,
+      params.account
+    );
+    const effectiveLegacyFormatConverter = this.resolveLegacyFormatConverter(
+      creativeFormatProjection?.legacyFormatConverter ?? legacyFormatConverter,
+      projectionCatalogs ?? this.config.projectionCatalogs
+    );
+    this.validateBeforeCreativeCapabilityProbe("sync_creatives", params, taskOptions);
+    const wireMode = this.resolveCreativeFormatWireMode(
+      "sync_creatives",
+      await this.getCapabilities({ signal: taskOptions.signal, transport: taskOptions.transport })
+    );
+    const configuredSelectorContainers = [
+      ...creativeFormatProjection?.selectorContainers ?? []
+    ];
+    const configuredPackageIds = new Set(
+      configuredSelectorContainers.flatMap(
+        (container) => typeof container.package_id === "string" ? [container.package_id] : []
+      )
+    );
+    const assignmentPackageContainers = Array.isArray(params.assignments) ? params.assignments.flatMap(
+      (assignment) => typeof assignment.package_id === "string" && !configuredPackageIds.has(assignment.package_id) ? [{ package_id: assignment.package_id }] : []
+    ) : [];
+    const wireParams = projectSyncCreativesForDelivery(
+      params,
+      [...configuredSelectorContainers, ...assignmentPackageContainers],
+      wireMode,
+      effectiveLegacyFormatConverter,
+      effectiveCanonicalFormatLegacyResolver
+    );
     return this.executeAndHandle(
       "sync_creatives",
       "onSyncCreativesStatusChange",
+      wireParams,
+      inputHandler,
+      taskOptions,
+      void 0,
+      effectiveLegacyFormatConverter,
+      params
+    );
+  }
+  /** @deprecated Compatibility-only entry point for callers still holding legacy creative `format_id` values. */
+  async syncCreativesLegacy(params, inputHandler, options) {
+    return await this.syncCreatives(
       params,
       inputHandler,
       options
     );
   }
+  resolveCreativeFormatWireMode(taskType, capabilities) {
+    const wireRelease = this.config.wireAdcpVersion ?? this.resolvedAdcpVersion;
+    const declared = resolveCreativeFormatWireMode(capabilities, wireRelease);
+    const schema = creativeSchemaSupport(this.cachedToolSchemas?.get(taskType));
+    if (declared !== "unknown" && schema !== "unknown" && declared !== schema) {
+      throw new CreativeFormatCapabilityError(
+        `Seller capability and ${taskType} input schema disagree about canonical creative support`
+      );
+    }
+    const resolved = declared !== "unknown" ? declared : schema;
+    const release = /^v?(\d+)\.(\d+)(?:\.|-|$)/.exec(wireRelease.trim());
+    const canonicalRequiredByBuyerPin = release !== null && (Number(release[1]) > 3 || Number(release[1]) === 3 && Number(release[2]) >= 2);
+    if (resolved === "unknown" && canonicalRequiredByBuyerPin) {
+      throw new CreativeFormatCapabilityError(
+        `Cannot prove which AdCP release the seller serves for ${taskType}; a 3.2+ client will not guess a legacy creative wire shape`
+      );
+    }
+    return resolved;
+  }
+  /** Validate malformed creative payloads before capability discovery can perform I/O. */
+  validateBeforeCreativeCapabilityProbe(taskType, params, options) {
+    if (options.skipIdempotencyAutoInject || options.skipAccountValidation) return;
+    let normalizedParams = normalizeRequestParams(taskType, params);
+    if (isMutatingTask(taskType) && normalizedParams && typeof normalizedParams === "object" && !normalizedParams.idempotency_key) {
+      normalizedParams = { ...normalizedParams, idempotency_key: generateIdempotencyKey() };
+    }
+    this.validateRequest(taskType, normalizedParams);
+  }
   /**
-   * List creative assets
+   * List creatives through the canonical SDK boundary.
+   *
+   * Legacy format filters are rejected and returned creative identities are
+   * projected to `format_kind` / `format_option_ref`. Migration tooling that
+   * needs the negotiated raw wire shape must call `listCreativesLegacy()`.
    *
    * @param params - Creative listing parameters
    * @param inputHandler - Handler for clarification requests
    * @param options - Task execution options
    */
   async listCreatives(params, inputHandler, options) {
+    const { legacyFormatConverter, projectionCatalogs, ...taskOptions } = options ?? {};
+    const effectiveLegacyFormatConverter = this.resolveLegacyFormatConverter(
+      legacyFormatConverter,
+      projectionCatalogs ?? this.config.projectionCatalogs
+    );
     return this.executeAndHandle(
       "list_creatives",
       "onListCreativesStatusChange",
       params,
       inputHandler,
-      options
+      taskOptions,
+      (data) => {
+        const { _message: _dropLegacyMessage, ...safe } = data;
+        void _dropLegacyMessage;
+        return {
+          ...safe,
+          creatives: data.creatives.map(
+            (creative) => projectCreativeForDelivery(
+              creative,
+              {},
+              "canonical",
+              "list_creatives",
+              effectiveLegacyFormatConverter
+            )
+          )
+        };
+      },
+      effectiveLegacyFormatConverter
     );
   }
+  /** @deprecated Explicit raw-wire escape hatch for migration tooling. */
+  async listCreativesLegacy(params, inputHandler, options) {
+    return this.executeTaskUnprojected("list_creatives", params, inputHandler, options);
+  }
   /**
-   * Preview a creative
+   * Preview a creative through the legacy named-format protocol.
    *
    * @param params - Preview creative parameters
    * @param inputHandler - Handler for clarification requests
    * @param options - Task execution options
+   * @deprecated Migration-only access to `format_id`-based creative preview.
    */
-  async previewCreative(params, inputHandler, options) {
+  async previewCreativeLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "preview_creative",
-      "onPreviewCreativeStatusChange",
+      "onPreviewCreativeLegacyStatusChange",
       params,
       inputHandler,
       options
@@ -1669,13 +3035,18 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @param options - Task execution options
    */
   async getMediaBuys(params, inputHandler, options) {
-    return this.executeAndHandle(
+    const { legacyFormatConverter, projectionCatalogs, ...taskOptions } = options ?? {};
+    const result = await this.executeAndHandle(
       "get_media_buys",
       "onGetMediaBuysStatusChange",
       params,
       inputHandler,
-      options
+      taskOptions,
+      void 0,
+      this.resolveLegacyFormatConverter(legacyFormatConverter, projectionCatalogs ?? this.config.projectionCatalogs)
     );
+    if (result.data !== void 0) this.rememberCanonicalPackageRoutes(result.data, params);
+    return result;
   }
   /**
    * Get media buy delivery information
@@ -1685,12 +3056,28 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @param options - Task execution options
    */
   async getMediaBuyDelivery(params, inputHandler, options) {
+    const { legacyFormatConverter, projectionCatalogs, ...taskOptions } = options ?? {};
     return this.executeAndHandle(
       "get_media_buy_delivery",
       "onGetMediaBuyDeliveryStatusChange",
       params,
       inputHandler,
-      options
+      taskOptions,
+      void 0,
+      this.resolveLegacyFormatConverter(legacyFormatConverter, projectionCatalogs ?? this.config.projectionCatalogs)
+    );
+  }
+  /** Retrieve canonical creative-level and variant-level delivery metrics. */
+  async getCreativeDelivery(params, inputHandler, options) {
+    const { legacyFormatConverter, ...taskOptions } = options ?? {};
+    return this.executeAndHandle(
+      "get_creative_delivery",
+      "onGetCreativeDeliveryStatusChange",
+      params,
+      inputHandler,
+      taskOptions,
+      void 0,
+      legacyFormatConverter
     );
   }
   /**
@@ -1817,12 +3204,13 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   }
   // ====== CREATIVE BUILD TASKS ======
   /**
-   * Build a creative from a format and brand context
+   * Build a creative through the legacy named-format protocol.
+   * @deprecated Migration-only access to `target_format_id`-based creative building.
    */
-  async buildCreative(params, inputHandler, options) {
+  async buildCreativeLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "build_creative",
-      "onBuildCreativeStatusChange",
+      "onBuildCreativeLegacyStatusChange",
       params,
       inputHandler,
       options
@@ -1929,10 +3317,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   /**
    * List content standards
    */
-  async listContentStandards(params, inputHandler, options) {
+  async listContentStandardsLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "list_content_standards",
-      "onListContentStandardsStatusChange",
+      "onListContentStandardsLegacyStatusChange",
       params,
       inputHandler,
       options
@@ -1941,10 +3329,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   /**
    * Get content standards
    */
-  async getContentStandards(params, inputHandler, options) {
+  async getContentStandardsLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "get_content_standards",
-      "onGetContentStandardsStatusChange",
+      "onGetContentStandardsLegacyStatusChange",
       params,
       inputHandler,
       options
@@ -1953,10 +3341,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   /**
    * Calibrate content against standards
    */
-  async calibrateContent(params, inputHandler, options) {
+  async calibrateContentLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "calibrate_content",
-      "onCalibrateContentStatusChange",
+      "onCalibrateContentLegacyStatusChange",
       params,
       inputHandler,
       options
@@ -1965,10 +3353,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   /**
    * Validate content delivery
    */
-  async validateContentDelivery(params, inputHandler, options) {
+  async validateContentDeliveryLegacy(params, inputHandler, options) {
     return this.executeAndHandle(
       "validate_content_delivery",
-      "onValidateContentDeliveryStatusChange",
+      "onValidateContentDeliveryLegacyStatusChange",
       params,
       inputHandler,
       options
@@ -2023,25 +3411,62 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       options
     );
   }
-  // ====== GENERIC TASK EXECUTION ======
+  async executeTask(taskName, params, inputHandler, options) {
+    switch (taskName) {
+      case "get_products":
+        return this.getProducts(params, inputHandler, options);
+      case "create_media_buy":
+        return await this.createMediaBuy(
+          params,
+          inputHandler,
+          options
+        );
+      case "update_media_buy":
+        return await this.updateMediaBuy(
+          params,
+          inputHandler,
+          options
+        );
+      case "sync_creatives":
+        return await this.syncCreatives(
+          params,
+          inputHandler,
+          options
+        );
+      case "list_creatives":
+        return this.listCreatives(params, inputHandler, options);
+      case "get_media_buys":
+        return this.getMediaBuys(params, inputHandler, options);
+      case "get_media_buy_delivery":
+        return this.getMediaBuyDelivery(params, inputHandler, options);
+      case "get_creative_delivery":
+        return this.getCreativeDelivery(params, inputHandler, options);
+    }
+    return this.executeTaskUnprojected(taskName, params, inputHandler, options);
+  }
   /**
-   * Execute any task by name with type safety
-   *
-   * @param taskName - Name of the task to execute
-   * @param params - Task parameters
-   * @param inputHandler - Handler for clarification requests
-   * @param options - Task execution options
+   * Execute an extension task that is not part of the standard AdCP task set.
    *
-   * @example
-   * ```typescript
-   * const result = await client.executeTask(
-   *   'get_products',
-   *   { brief: 'Coffee brands' },
-   *   handler
-   * );
-   * ```
+   * Keeping custom tasks on an explicitly named API prevents a response-type
+   * generic from weakening the canonical request types enforced by
+   * `executeTask()` for standard creative-boundary tasks.
    */
-  async executeTask(taskName, params, inputHandler, options) {
+  async executeCustomTask(taskName, params, inputHandler, options) {
+    if (STANDARD_ADCP_TASK_NAMES.has(taskName)) {
+      throw new Error(
+        `executeCustomTask() cannot execute standard AdCP task "${taskName}". Use its typed primary method, or an explicitly named *Legacy method for legacy creative tools.`
+      );
+    }
+    return this.executeTaskUnprojected(taskName, params, inputHandler, options);
+  }
+  /**
+   * Explicit raw-task compatibility escape hatch for conformance and migration tooling.
+   * @deprecated Application code should use typed primary methods or `executeTask()`.
+   */
+  async executeTaskLegacy(taskName, params, inputHandler, options) {
+    return this.executeTaskUnprojected(taskName, params, inputHandler, options);
+  }
+  async executeTaskUnprojected(taskName, params, inputHandler, options) {
     throwIfAborted(options?.signal);
     const startTime = Date.now();
     try {
@@ -2062,13 +3487,19 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       if (!options?.skipIdempotencyAutoInject && !options?.skipAccountValidation) {
         this.executor.validateRequest(taskName, normalizedParams);
       }
-      const serverVersion = await this.detectServerVersion(options);
+      const capabilityDiscoveryContext = {};
+      const detectionOptions = {
+        ...options,
+        [CAPABILITY_DISCOVERY_CONTEXT]: capabilityDiscoveryContext
+      };
+      const serverVersion = await this.detectServerVersion(detectionOptions);
       const inputSchemaStripLogs = [];
       const { params: adaptedParams, driftLogs: adaptDriftLogs } = this.adaptRequest(
         taskName,
         normalizedParams,
         serverVersion,
-        inputSchemaStripLogs
+        inputSchemaStripLogs,
+        capabilityDiscoveryContext.toolSchemas
       );
       const v25DriftLogs = [...adaptDriftLogs];
       if (webhookDriftLog) v25DriftLogs.push(webhookDriftLog);
@@ -2090,8 +3521,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       if (result.success && result.data) {
         result.data = this.normalizeResponseToV3(taskName, result.data);
       }
-      result = this.wrapProductPolicySubmittedContinuation(result, taskName, normalizedParams);
-      this.rememberProductPolicyRequestParams(taskName, normalizedParams, result, options);
+      result = this.wrapProductPolicySubmittedContinuation(result, taskName, normalizedParams, options);
+      if (result.status === "working") {
+        this.rememberProductPolicyRequestParams(taskName, normalizedParams, result, options);
+      }
       result = await this.applyProductPropertyPolicy(result, taskName, normalizedParams);
       return result;
     } catch (error) {
@@ -2169,19 +3602,58 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    */
   async continueConversation(message, contextId, inputHandler) {
     const agent = await this.ensureEndpointDiscovered();
-    return this.executor.executeTask(agent, "continue_conversation", { message }, inputHandler, { contextId });
+    const creativeAssociation = this.canonicalCreativeTaskAssociation(contextId);
+    if (!creativeAssociation) {
+      return this.executor.executeTask(agent, "continue_conversation", { message }, inputHandler, { contextId });
+    }
+    const { taskType: creativeTaskType } = creativeAssociation;
+    const legacyFormatConverter = this.resolveLegacyFormatConverter(creativeAssociation.legacyFormatConverter);
+    const result = await canonicalCreativeExecutionStorage.run(
+      { taskType: creativeTaskType, legacyFormatConverter },
+      () => this.executor.executeTask(
+        agent,
+        "continue_conversation",
+        { message },
+        this.canonicalCreativeInputHandler(creativeTaskType, inputHandler),
+        { contextId }
+      )
+    );
+    const canonical = this.canonicalizeCreativeTaskResult(result, creativeTaskType, void 0, legacyFormatConverter);
+    this.rememberCanonicalCreativeTaskIds(
+      canonical,
+      creativeTaskType,
+      legacyFormatConverter,
+      creativeAssociation.routingSnapshot
+    );
+    return this.wrapCanonicalCreativeContinuations(
+      canonical,
+      creativeTaskType,
+      void 0,
+      legacyFormatConverter,
+      creativeAssociation.routingSnapshot
+    );
   }
   /**
    * Get conversation history for a task
    */
   getConversationHistory(taskId) {
-    return this.executor.getConversationHistory(taskId);
+    const history = this.executor.getConversationHistory(taskId);
+    const association = this.canonicalCreativeTaskAssociation(taskId);
+    if (!association) return history;
+    const { taskType } = association;
+    const converter = this.resolveLegacyFormatConverter(association.legacyFormatConverter);
+    return history?.map((message) => ({
+      ...message,
+      content: projectCanonicalCreativeAncillaryValue(message.content, taskType, converter)
+    }));
   }
   /**
    * Clear conversation history for a task
    */
   clearConversationHistory(taskId) {
     this.executor.clearConversationHistory(taskId);
+    this.forgetCanonicalCreativeTaskAssociationKeys([taskId]);
+    this.productPolicyRequestParamsByTask.delete(taskId);
   }
   // ====== AGENT INFORMATION ======
   /**
@@ -2322,7 +3794,23 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * Get active tasks for this agent
    */
   getActiveTasks() {
-    return this.executor.getActiveTasks().filter((task) => task.agent.id === this.agent.id);
+    return this.executor.getActiveTasks().filter((task) => task.agent.id === this.agent.id).map((task) => {
+      if (!CANONICAL_CREATIVE_ACTIVITY_TASKS.has(task.taskName)) return task;
+      const converter = this.resolveLegacyFormatConverter(
+        this.canonicalCreativeTaskAssociation(task.taskId)?.legacyFormatConverter
+      );
+      return stripLegacyCreativeIdentity({
+        ...task,
+        params: projectCanonicalCreativeAncillaryValue(task.params, task.taskName, converter),
+        messages: task.messages.map((message) => ({
+          ...message,
+          content: projectCanonicalCreativeAncillaryValue(message.content, task.taskName, converter)
+        })),
+        ...task.pendingInput !== void 0 && {
+          pendingInput: projectCanonicalCreativeAncillaryValue(task.pendingInput, task.taskName, converter)
+        }
+      });
+    });
   }
   // ====== TASK MANAGEMENT & NOTIFICATIONS ======
   /**
@@ -2339,7 +3827,15 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async listTasks() {
-    return this.executor.getTaskList(this.agent.id);
+    const tasks = await this.executor.getTaskList(this.agent.id);
+    return tasks.map(
+      (task) => CANONICAL_CREATIVE_ACTIVITY_TASKS.has(task.taskType) ? this.canonicalizeCreativeTaskInfo(
+        task,
+        task.taskType,
+        void 0,
+        this.resolveLegacyFormatConverter(this.canonicalCreativeTaskAssociation(task.taskId)?.legacyFormatConverter)
+      ) : task
+    );
   }
   /**
    * Get detailed information about a specific task
@@ -2348,7 +3844,13 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @returns Promise resolving to task information
    */
   async getTaskInfo(taskId) {
-    return this.executor.getTaskInfo(taskId);
+    const task = await this.executor.getTaskInfo(taskId);
+    return task && CANONICAL_CREATIVE_ACTIVITY_TASKS.has(task.taskType) ? this.canonicalizeCreativeTaskInfo(
+      task,
+      task.taskType,
+      void 0,
+      this.resolveLegacyFormatConverter(this.canonicalCreativeTaskAssociation(task.taskId)?.legacyFormatConverter)
+    ) : task;
   }
   /**
    * Subscribe to task notifications for this agent
@@ -2370,7 +3872,19 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   onTaskUpdate(callback) {
-    return this.executor.onTaskUpdate(this.agent.id, callback);
+    return this.executor.onTaskUpdate(
+      this.agent.id,
+      (task) => callback(
+        CANONICAL_CREATIVE_ACTIVITY_TASKS.has(task.taskType) ? this.canonicalizeCreativeTaskInfo(
+          task,
+          task.taskType,
+          void 0,
+          this.resolveLegacyFormatConverter(
+            this.canonicalCreativeTaskAssociation(task.taskId)?.legacyFormatConverter
+          )
+        ) : task
+      )
+    );
   }
   /**
    * Subscribe to all task events (create, update, complete, error)
@@ -2379,7 +3893,23 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @returns Unsubscribe function
    */
   onTaskEvents(callbacks) {
-    return this.executor.onTaskEvents(this.agent.id, callbacks);
+    const safe = (task) => CANONICAL_CREATIVE_ACTIVITY_TASKS.has(task.taskType) ? this.canonicalizeCreativeTaskInfo(
+      task,
+      task.taskType,
+      void 0,
+      this.resolveLegacyFormatConverter(this.canonicalCreativeTaskAssociation(task.taskId)?.legacyFormatConverter)
+    ) : task;
+    return this.executor.onTaskEvents(this.agent.id, {
+      ...callbacks.onTaskCreated && { onTaskCreated: (task) => callbacks.onTaskCreated(safe(task)) },
+      ...callbacks.onTaskUpdated && { onTaskUpdated: (task) => callbacks.onTaskUpdated(safe(task)) },
+      ...callbacks.onTaskCompleted && { onTaskCompleted: (task) => callbacks.onTaskCompleted(safe(task)) },
+      ...callbacks.onTaskFailed && {
+        onTaskFailed: (task, error) => {
+          const safeTask = safe(task);
+          callbacks.onTaskFailed(safeTask, safeTask.error ?? stripLegacyCreativeIdentity(error));
+        }
+      }
+    });
   }
   /**
    * Register webhook URL for receiving task notifications
@@ -2443,6 +3973,16 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       ...options?.signal && { signal: options.signal },
       ...clientRequestTimeoutMs !== void 0 && { timeout: clientRequestTimeoutMs }
     };
+    const ensureReadAuthToken = async () => {
+      if (!this.normalizedAgent.oauth_client_credentials) return this.normalizedAgent.auth_token;
+      const { ensureClientCredentialsTokens, getAgentStorage } = await import("../auth/oauth/index.mjs");
+      await ensureClientCredentialsTokens(this.normalizedAgent, {
+        storage: getAgentStorage(this.normalizedAgent),
+        allowPrivateIp: isLikelyPrivateUrl(this.normalizedAgent.agent_uri),
+        fetch: transport?.fetchFn
+      });
+      return this.normalizedAgent.oauth_tokens?.access_token;
+    };
     if (this.normalizedAgent.protocol === "mcp") {
       if (this.normalizedAgent._inProcessMcpClient) {
         const mcpClient2 = this.normalizedAgent._inProcessMcpClient;
@@ -2464,6 +4004,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           tools
         };
       }
+      const readAuthToken = await ensureReadAuthToken();
       const agent = await this.ensureEndpointDiscovered(options);
       const { connectMCP } = await import("../protocols/mcp.mjs");
       const { tryListModernMCPTools } = await import("../protocols/mcp-modern.mjs");
@@ -2474,25 +4015,32 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       if (transport?.requestTimeoutMs !== void 0) {
         connectOptions.requestTimeoutMs = transport.requestTimeoutMs;
       }
+      if (transport?.fetchFn) {
+        connectOptions.fetchFn = transport.fetchFn;
+      }
       if (this.normalizedAgent.headers && Object.keys(this.normalizedAgent.headers).length > 0) {
         connectOptions.customHeaders = this.normalizedAgent.headers;
       }
       let authProvider;
-      if (this.normalizedAgent.oauth_tokens) {
-        const { createNonInteractiveOAuthProvider } = await import("../auth/oauth/index.mjs");
-        authProvider = createNonInteractiveOAuthProvider(this.normalizedAgent, {
-          agentHint: this.normalizedAgent.id
+      if (this.normalizedAgent.oauth_tokens && !this.normalizedAgent.oauth_client_credentials) {
+        const { getAgentStorage } = await import("../auth/oauth/index.mjs");
+        const { getNonInteractiveOAuthProvider } = await import("../auth/oauth/provider-cache.mjs");
+        authProvider = getNonInteractiveOAuthProvider(this.normalizedAgent, {
+          agentHint: this.normalizedAgent.id,
+          storage: getAgentStorage(this.normalizedAgent),
+          allowHttp: isLikelyPrivateUrl(this.normalizedAgent.agent_uri)
         });
         connectOptions.authProvider = authProvider;
-      } else if (this.normalizedAgent.auth_token) {
-        connectOptions.authToken = this.normalizedAgent.auth_token;
+      } else if (readAuthToken) {
+        connectOptions.authToken = readAuthToken;
       }
-      const modernTools = this.discoveredMcpEra === "legacy" && Date.now() - this.discoveredMcpEraAt < 5 * 60 * 1e3 ? { handled: false } : await withResponseSizeLimit(
+      const modernTools = !transport?.fetchFn && this.discoveredMcpEra === "legacy" && Date.now() - this.discoveredMcpEraAt < 5 * 60 * 1e3 ? { handled: false } : await withResponseSizeLimit(
         maxResponseBytes,
-        () => tryListModernMCPTools(agent.agent_uri, this.normalizedAgent.auth_token, this.normalizedAgent.headers, {
+        () => tryListModernMCPTools(agent.agent_uri, readAuthToken, this.normalizedAgent.headers, {
           authProvider,
           signal: options?.signal,
-          requestTimeoutMs: transport?.requestTimeoutMs
+          requestTimeoutMs: transport?.requestTimeoutMs,
+          fetchFn: transport?.fetchFn
         })
       );
       if (modernTools.handled) {
@@ -2537,9 +4085,11 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       }
     } else if (this.normalizedAgent.protocol === "a2a") {
       const { wrapFetchWithSizeLimit } = await import("../protocols/responseSizeLimit.mjs");
-      const authToken = this.normalizedAgent.auth_token;
+      const authToken = await ensureReadAuthToken();
       const agentHeaders = this.normalizedAgent.headers ?? {};
-      const sizeLimitedFetch = wrapFetchWithSizeLimit((input, init) => fetch(input, init));
+      const sizeLimitedFetch = wrapFetchWithSizeLimit(
+        (input, init) => transport?.fetchFn ? transport.fetchFn(input, init) : fetch(input, init)
+      );
       const normalizeHeaders = (headers) => {
         const normalized = {};
         if (!headers) return normalized;
@@ -2630,7 +4180,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    */
   async getCapabilities(options) {
     throwIfAborted(options?.signal);
-    if (this.cachedCapabilities) {
+    const discoveryContext = options?.[CAPABILITY_DISCOVERY_CONTEXT];
+    const usesScopedFetch = (options?.transport ?? this.config.transport)?.fetchFn !== void 0;
+    if (!usesScopedFetch && this.cachedCapabilities) {
+      if (discoveryContext) discoveryContext.toolSchemas = this.cachedToolSchemas;
       this.maybeWarnV2Sunset(this.cachedCapabilities);
       return this.cachedCapabilities;
     }
@@ -2639,10 +4192,14 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       name: t.name,
       description: t.description
     }));
-    this.cachedToolSchemas = new Map(
+    const discoveredToolSchemas = new Map(
       agentInfo.tools.filter((t) => t.inputSchema?.properties).map((t) => [t.name, t.inputSchema.properties])
     );
-    const hasCapabilitiesTool = tools.some((t) => t.name === "get_adcp_capabilities");
+    if (discoveryContext) discoveryContext.toolSchemas = discoveredToolSchemas;
+    if (!usesScopedFetch) this.cachedToolSchemas = discoveredToolSchemas;
+    const advertisesCapabilitiesTool = tools.some((t) => t.name === "get_adcp_capabilities");
+    const officialA2ALifecycle = this.normalizedAgent.protocol === "a2a" && tools.some((tool) => ["tasks/get", "get_task_status", "list_tasks"].includes(tool.name));
+    const hasCapabilitiesTool = advertisesCapabilitiesTool || officialA2ALifecycle;
     if (hasCapabilitiesTool) {
       try {
         const agent = await this.ensureEndpointDiscovered(options);
@@ -2655,9 +4212,13 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           throw createTimeoutError(requestTimeoutMs);
         }
         if (result.success && result.data) {
-          this.cachedCapabilities = augmentCapabilitiesFromTools(parseCapabilitiesResponse(result.data), tools);
-          this.maybeWarnV2Sunset(this.cachedCapabilities);
-          return this.cachedCapabilities;
+          const capabilities2 = augmentCapabilitiesFromTools(parseCapabilitiesResponse(result.data), tools);
+          if (!usesScopedFetch) this.cachedCapabilities = capabilities2;
+          this.maybeWarnV2Sunset(capabilities2);
+          return capabilities2;
+        }
+        if (!advertisesCapabilitiesTool) {
+          throw new Error("unadvertised official A2A capability probe was not supported");
         }
         if (result.data && looksLikeV3Capabilities(result.data)) {
           console.warn(
@@ -2670,9 +4231,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
             version: "v3",
             majorVersions: parsed.majorVersions.includes(3) ? parsed.majorVersions : [3]
           };
-          this.cachedCapabilities = augmentCapabilitiesFromTools(v3Capabilities, tools);
-          this.maybeWarnV2Sunset(this.cachedCapabilities);
-          return this.cachedCapabilities;
+          const capabilities2 = augmentCapabilitiesFromTools(v3Capabilities, tools);
+          if (!usesScopedFetch) this.cachedCapabilities = capabilities2;
+          this.maybeWarnV2Sunset(capabilities2);
+          return capabilities2;
         }
         console.warn(
           `[AdCP] Agent "${this.agent.id}" advertises get_adcp_capabilities but the call returned non-success and the response is not v3-shaped \u2014 treating as v3 (synthetic) since the agent has the v3-only discovery tool. This client routes to v3 adapters, but calls reading capability details (idempotency TTL, supported_versions, feature flags) will fail until the agent operator fixes the capabilities endpoint.`,
@@ -2686,19 +4248,25 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         if (error instanceof AuthenticationRequiredError || error instanceof TaskTimeoutError || isAbortOrTimeoutError(error)) {
           throw error;
         }
-        console.warn(
-          `[AdCP] Agent "${this.agent.id}" advertises get_adcp_capabilities but the call threw \u2014 treating as v3 (synthetic) since the agent has the v3-only discovery tool. This client routes to v3 adapters, but calls reading capability details (idempotency TTL, supported_versions, feature flags) will fail until the agent operator fixes the capabilities endpoint.`
-        );
+        if (advertisesCapabilitiesTool) {
+          console.warn(
+            `[AdCP] Agent "${this.agent.id}" advertises get_adcp_capabilities but the call threw \u2014 treating as v3 (synthetic) since the agent has the v3-only discovery tool. This client routes to v3 adapters, but calls reading capability details (idempotency TTL, supported_versions, feature flags) will fail until the agent operator fixes the capabilities endpoint.`
+          );
+        }
+      }
+      if (advertisesCapabilitiesTool) {
+        const capabilities2 = augmentCapabilitiesFromTools(buildSyntheticV3Capabilities(tools), tools);
+        if (!usesScopedFetch) this.cachedCapabilities = capabilities2;
+        this.maybeWarnV2Sunset(capabilities2);
+        return capabilities2;
       }
-      this.cachedCapabilities = augmentCapabilitiesFromTools(buildSyntheticV3Capabilities(tools), tools);
-      this.maybeWarnV2Sunset(this.cachedCapabilities);
-      return this.cachedCapabilities;
     }
     console.warn(
       `[AdCP] Agent "${this.agent.id}" detected as v2 (no get_adcp_capabilities tool). Tools: [${tools.map((t) => t.name).join(", ")}]`
     );
-    this.cachedCapabilities = buildSyntheticCapabilities(tools);
-    return this.cachedCapabilities;
+    const capabilities = buildSyntheticCapabilities(tools);
+    if (!usesScopedFetch) this.cachedCapabilities = capabilities;
+    return capabilities;
   }
   /**
    * Emit a one-time warning when the agent reports v2 capabilities.
@@ -3011,38 +4579,18 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   }
   // ====== STATIC HELPER METHODS ======
   /**
-   * Query a creative agent to discover available creative formats
+   * Query a legacy creative-agent named-format catalog.
    *
-   * This is a static utility method that allows you to query any creative agent
-   * (like creative.adcontextprotocol.org) to discover what formats are available
-   * before creating a media buy.
+   * Canonical applications discover seller-supported declarations through
+   * `AgentClient.getProducts()` and consume `format_options[]` instead.
    *
    * @param creativeAgentUrl - URL of the creative agent (e.g., 'https://creative.adcontextprotocol.org/mcp')
    * @param protocol - Protocol to use ('mcp' or 'a2a'), defaults to 'mcp'
    * @returns Promise resolving to the list of available formats
    *
-   * @example
-   * ```typescript
-   * // Discover formats from the standard creative agent
-   * const formats = await SingleAgentClient.discoverCreativeFormats(
-   *   'https://creative.adcontextprotocol.org/mcp'
-   * );
-   *
-   * // Find a specific format
-   * const banner = formats.find(f => f.format_id.id === 'display_300x250_image');
-   *
-   * // Use the format in a media buy
-   * await salesAgent.createMediaBuy({
-   *   packages: [{
-   *     format_ids: [{
-   *       agent_url: banner.format_id.agent_url,
-   *       id: banner.format_id.id
-   *     }]
-   *   }]
-   * });
-   * ```
+   * @deprecated Migration-only helper for the legacy named-format protocol.
    */
-  static async discoverCreativeFormats(creativeAgentUrl, protocol = "mcp") {
+  static async discoverCreativeFormatsLegacy(creativeAgentUrl, protocol = "mcp") {
     const client = new SingleAgentClient(
       {
         id: "creative_agent_discovery",
@@ -3052,7 +4600,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       },
       {}
     );
-    const result = await client.listCreativeFormats({});
+    const result = await client.listCreativeFormatsLegacy({});
     if (!result.success || !result.data) {
       throw new Error(`Failed to discover creative formats: ${result.error || "Unknown error"}`);
     }
@@ -3132,12 +4680,11 @@ function parseWebhookBody(value) {
     const raw = Buffer.isBuffer(value) || value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : value;
     try {
       return { ok: true, payload: JSON.parse(raw) };
-    } catch (error) {
+    } catch {
       return {
         ok: false,
         code: "webhook_envelope_invalid",
-        message: "Webhook body must be valid JSON.",
-        cause: error
+        message: "Webhook body must be valid JSON."
       };
     }
   }
@@ -3158,13 +4705,6 @@ function missingMcpWebhookFields(payload) {
     return typeof value !== "string" || value.length === 0;
   });
 }
-function safeJsonPreview(value) {
-  try {
-    return JSON.stringify(value).substring(0, 200);
-  } catch {
-    return "[unserializable payload]";
-  }
-}
 function webhookErrorHttpStatus(error) {
   if (error instanceof WebhookDispatchError) {
     if (error.code === "webhook_signature_invalid" || error.code === "webhook_timestamp_invalid") {