@adcp/sdk 12.1.1 → 13.0.0-rc.0

package/dist/lib/server/decisioning/runtime/from-platform.js

@@ -56,6 +56,11 @@ var import_account_mode = require('../../account-mode.js');
 var import_observed_modes = require('./observed-modes.js');
 var import_normalize_errors = require('../../normalize-errors.js');
 var import_redact = require('../../redact.js');
+var import_creative_delivery = require('../../../v2/projection/creative-delivery.js');
+var import_augment_response = require('../../../v2/projection/augment-response.js');
+var import_v2_to_v1 = require('../../../v2/projection/v2-to-v1.js');
+var import_legacy_metadata = require('../../../v2/projection/legacy-metadata.js');
+var import_version = require('../../../version.js');
 const DEFAULT_FRAMEWORK_LOGGER = {
   debug: () => {
   },
@@ -66,6 +71,87 @@ const DEFAULT_FRAMEWORK_LOGGER = {
   // eslint-disable-next-line no-console
   error: console.error.bind(console)
 };
+function supportsCanonicalCreativeCapability(version) {
+  if (typeof version !== "string") return false;
+  const match = /^v?(\d+)\.(\d+)(?:\.|-|$)/.exec(version.trim());
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > 3 || major === 3 && minor >= 1;
+}
+function requiresCanonicalCreativeWire(version) {
+  if (typeof version !== "string") return false;
+  const match = /^v?(\d+)\.(\d+)(?:\.|-|$)/.exec(version.trim());
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > 3 || major === 3 && minor >= 2;
+}
+function creativeWireEvidenceForRequest(request) {
+  let canonical = false;
+  let legacy = false;
+  const seen = /* @__PURE__ */ new WeakSet();
+  if (request !== null && typeof request === "object") {
+    const ext = Object.getOwnPropertyDescriptor(request, "ext");
+    if (ext && "value" in ext && ext.value !== null && typeof ext.value === "object") {
+      const adcp = Object.getOwnPropertyDescriptor(ext.value, "adcp");
+      if (adcp && "value" in adcp && adcp.value !== null && typeof adcp.value === "object") {
+        const wire = Object.getOwnPropertyDescriptor(adcp.value, "creative_wire");
+        if (wire && "value" in wire) {
+          if (wire.value === "canonical") canonical = true;
+          if (wire.value === "legacy") legacy = true;
+        }
+      }
+    }
+  }
+  const visit = (value) => {
+    if (value === null || typeof value !== "object" || seen.has(value)) return;
+    seen.add(value);
+    const arrayValue = Array.isArray(value);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!descriptor.enumerable || !("value" in descriptor)) continue;
+      const child = descriptor.value;
+      if (key === "context" || key === "ext") continue;
+      if (/(^|_)(?:format_ids?|v1_format_ref)($|_)/.test(key)) legacy = true;
+      if (key === "format_kind" || key === "format_options" || key === "format_option_ref" || key === "format_option_refs") {
+        canonical = true;
+      }
+      if (arrayValue && typeof child === "string") {
+        if (child === "format_id" || child === "format_ids") legacy = true;
+        if (child === "format_kind" || child === "format_options" || child === "format_option_ref") canonical = true;
+      }
+      visit(child);
+    }
+  };
+  visit(request);
+  if (canonical && legacy) return "mixed";
+  if (canonical) return "canonical";
+  if (legacy) return "legacy";
+  return "unknown";
+}
+function creativeWireModeForRequest(ctx, fallback, request) {
+  if (ctx.servedAdcpVersion === void 0) return fallback;
+  if (!supportsCanonicalCreativeCapability(ctx.servedAdcpVersion)) return "legacy";
+  if (requiresCanonicalCreativeWire(ctx.servedAdcpVersion)) return "canonical";
+  const evidence = creativeWireEvidenceForRequest(request);
+  if (evidence === "canonical" || evidence === "mixed") return "canonical";
+  if (evidence === "legacy") return "legacy";
+  return fallback;
+}
+function parseAdcpRelease(version) {
+  if (typeof version !== "string") return void 0;
+  const match = /^v?(\d+)\.(\d+)(?:\.(\d+))?(?:-|$)/.exec(version.trim());
+  if (!match) return void 0;
+  return [Number(match[1]), Number(match[2]), Number(match[3] ?? 0)];
+}
+function compareAdcpReleases(left, right) {
+  for (let index = 0; index < left.length; index++) {
+    const delta = left[index] - right[index];
+    if (delta !== 0) return delta;
+  }
+  return 0;
+}
 function isPlainObject(v) {
   if (v === null || typeof v !== "object") return false;
   if (Array.isArray(v)) return false;
@@ -95,6 +181,414 @@ function normalizeRowErrors(row) {
   if (row?.errors == null) return row;
   return { ...row, errors: (0, import_normalize_errors.normalizeErrors)(row.errors) };
 }
+function asCanonicalServerResponse(response) {
+  return (0, import_creative_delivery.stripLegacyCreativeIdentity)(response);
+}
+function ownEnumerableDataRecord(value, operation) {
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const entries = Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable);
+  if (entries.length === 0) return void 0;
+  const record = {};
+  for (const [key, descriptor] of entries) {
+    if (!("value" in descriptor)) {
+      throw new import_creative_delivery.CreativeFormatProjectionError(
+        operation,
+        `(response:${key})`,
+        "enumerable accessors cannot cross the creative format boundary safely"
+      );
+    }
+    record[key] = descriptor.value;
+  }
+  return record;
+}
+function assertSafeSemanticPayload(value, operation) {
+  const active = /* @__PURE__ */ new WeakSet();
+  const visited = /* @__PURE__ */ new WeakSet();
+  const visit = (current, path) => {
+    if (current === null || typeof current !== "object") return;
+    if (Array.isArray(current) && Object.getPrototypeOf(current) !== Array.prototype) {
+      throw new import_creative_delivery.CreativeFormatProjectionError(
+        operation,
+        `(payload:${path})`,
+        "array subclasses cannot cross the creative format boundary safely"
+      );
+    }
+    for (let owner = current; owner !== null; owner = Object.getPrototypeOf(owner)) {
+      const toJSON = Object.getOwnPropertyDescriptor(owner, "toJSON");
+      if (!toJSON) continue;
+      if (!("value" in toJSON) || typeof toJSON.value === "function") {
+        throw new import_creative_delivery.CreativeFormatProjectionError(
+          operation,
+          `(payload:${path}.toJSON)`,
+          "custom or accessor toJSON hooks cannot cross the creative format boundary safely"
+        );
+      }
+    }
+    if (active.has(current)) {
+      throw new import_creative_delivery.CreativeFormatProjectionError(
+        operation,
+        `(payload:${path})`,
+        "cyclic values cannot cross the creative format boundary"
+      );
+    }
+    if (visited.has(current)) return;
+    active.add(current);
+    try {
+      const descriptors = Object.getOwnPropertyDescriptors(current);
+      for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (!("value" in descriptor)) {
+          throw new import_creative_delivery.CreativeFormatProjectionError(
+            operation,
+            `(payload:${path}.${key})`,
+            "accessors cannot cross the creative format boundary safely"
+          );
+        }
+        if (!descriptor.enumerable) continue;
+        visit(descriptor.value, `${path}.${key}`);
+      }
+    } finally {
+      active.delete(current);
+    }
+    visited.add(current);
+  };
+  visit(value, "$");
+}
+function projectResponseCreativeIdentities(value, operation, legacyFormatConverter, canonicalFormatLegacyResolver, wireMode, selectorContainer = {}) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => projectResponseCreativeIdentities(
+        item,
+        operation,
+        legacyFormatConverter,
+        canonicalFormatLegacyResolver,
+        wireMode,
+        selectorContainer
+      )
+    );
+  }
+  if (value === null || typeof value !== "object") return value;
+  const inspectedRecord = ownEnumerableDataRecord(value, operation);
+  if (inspectedRecord === void 0) return value;
+  const dataRecord = isPlainObject(value) ? value : inspectedRecord;
+  let projected = dataRecord;
+  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) {
+    if (wireMode === "canonical") {
+      const canonical = (0, import_augment_response.toCanonicalOnlyResponse)(
+        { products: [projected] },
+        { legacyFormatConverter }
+      );
+      if (canonical.diagnostics.length > 0 || canonical.response.products.length !== 1) {
+        throw new import_creative_delivery.CreativeFormatProjectionError(
+          operation,
+          `(product:${String(projected.product_id)})`,
+          "legacy product formats in the platform response have no complete canonical representation"
+        );
+      }
+      projected = canonical.response.products[0];
+    } else if (Array.isArray(projected.format_options)) {
+      const legacy = (0, import_v2_to_v1.projectV2ProductToV1)(projected, { canonicalFormatLegacyResolver });
+      if (legacy.diagnostics.length > 0 || legacy.v1.format_ids.length === 0 && projected.format_options.length > 0) {
+        throw new import_creative_delivery.CreativeFormatProjectionError(
+          operation,
+          `(product:${String(projected.product_id)})`,
+          "canonical product formats in the platform response have no complete legacy representation"
+        );
+      }
+      projected = legacy.v1;
+    }
+  } else if ((typeof projected.package_id === "string" || typeof projected.product_id === "string") && (Array.isArray(projected.format_ids) || Array.isArray(projected.format_option_refs) || typeof projected.format_kind === "string")) {
+    projected = (0, import_creative_delivery.projectMediaBuyCreativesForDelivery)(
+      { packages: [projected] },
+      wireMode,
+      "create_media_buy",
+      legacyFormatConverter,
+      canonicalFormatLegacyResolver
+    ).packages[0];
+  }
+  if (typeof projected.creative_id === "string" && (projected.format_id !== void 0 || typeof projected.format_kind === "string")) {
+    projected = (0, import_creative_delivery.projectCreativeForDelivery)(
+      projected,
+      selectorContainer,
+      wireMode,
+      operation,
+      legacyFormatConverter,
+      canonicalFormatLegacyResolver
+    );
+  }
+  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 = projectResponseCreativeIdentities(
+      child,
+      operation,
+      legacyFormatConverter,
+      canonicalFormatLegacyResolver,
+      wireMode,
+      nextSelector
+    );
+    if (childProjected !== child) {
+      next[key] = childProjected;
+      changed = true;
+    }
+  }
+  return changed ? next : projected;
+}
+function asCanonicalSemanticServerResponse(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver) {
+  try {
+    assertSafeSemanticPayload(response, operation);
+    return asCanonicalServerResponse(
+      projectResponseCreativeIdentities(
+        response,
+        operation,
+        legacyFormatConverter,
+        canonicalFormatLegacyResolver,
+        "canonical"
+      )
+    );
+  } catch (error) {
+    if (!(error instanceof import_creative_delivery.CreativeFormatProjectionError)) throw error;
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: `${operation} platform response contains a legacy creative format that cannot be represented canonically.`,
+      field: "response",
+      suggestion: "Return canonical format_kind values, or configure legacyCreativeFormatConverter for custom legacy formats."
+    });
+  }
+}
+function asSemanticServerResponseForWire(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver, wireMode) {
+  if (wireMode === "canonical") {
+    return attachCanonicalCustomFormatWireRefs(
+      asCanonicalSemanticServerResponse(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver),
+      canonicalFormatLegacyResolver,
+      operation
+    );
+  }
+  try {
+    assertSafeSemanticPayload(response, operation);
+    return projectResponseCreativeIdentities(
+      response,
+      operation,
+      legacyFormatConverter,
+      canonicalFormatLegacyResolver,
+      "legacy"
+    );
+  } catch (error) {
+    if (!(error instanceof import_creative_delivery.CreativeFormatProjectionError)) throw error;
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: `${operation} platform response contains a canonical creative format that cannot be represented on the configured legacy wire.`,
+      field: "response",
+      suggestion: "Return an explicit legacy mapping for the canonical format, or configure this server for AdCP 3.1 or newer."
+    });
+  }
+}
+function legacyIdentityContext(ownerKey) {
+  if (typeof ownerKey !== "string") return "default";
+  if (ownerKey === "signal_id" || ownerKey === "signal_ids") return "signal";
+  if (/(^|_)(?:property_lists?|collection_lists?)($|_)/.test(ownerKey)) return "list";
+  if (!/(^|_)(?:creative|format|legacy|placement)($|_)/.test(ownerKey) && /(^|_)(?:agents?|agent_details|agent_info)($|_)/.test(ownerKey)) {
+    return "agent";
+  }
+  return "default";
+}
+function allowsNonCreativeAgentUrl(owner, context) {
+  return context === "agent" || context === "list" && typeof owner.list_id === "string" || context === "signal" && owner.source === "agent";
+}
+function findLegacyCreativeIdentity(value, seen = {
+  agent: /* @__PURE__ */ new WeakSet(),
+  signal: /* @__PURE__ */ new WeakSet(),
+  list: /* @__PURE__ */ new WeakSet(),
+  default: /* @__PURE__ */ new WeakSet()
+}, ownerKey) {
+  if (value === null || typeof value !== "object") return void 0;
+  const owner = value;
+  const context = legacyIdentityContext(ownerKey);
+  const policySeen = seen[context];
+  if (policySeen.has(value)) return void 0;
+  policySeen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = findLegacyCreativeIdentity(item, seen, ownerKey);
+      if (nested) return nested;
+    }
+    return void 0;
+  }
+  for (const [key, child] of Object.entries(owner)) {
+    if (/(^|_)(?:format_ids?|v1_format_ref)($|_)/.test(key)) return key;
+    if (key === "agent_url" && (typeof owner.id === "string" || typeof owner.list_id === "string") && !allowsNonCreativeAgentUrl(owner, context)) {
+      return key;
+    }
+    const nested = findLegacyCreativeIdentity(child, seen, key);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function asCanonicalSemanticServerRequest(request, operation, legacyFormatConverter) {
+  try {
+    assertSafeSemanticPayload(request, operation);
+    const projected = projectResponseCreativeIdentities(
+      request,
+      operation,
+      legacyFormatConverter,
+      void 0,
+      "canonical"
+    );
+    const forbidden = findLegacyCreativeIdentity(projected);
+    if (forbidden) {
+      throw new import_creative_delivery.CreativeFormatProjectionError(
+        operation,
+        "(request extension)",
+        `legacy creative identity ${forbidden} has no recognized canonical container`
+      );
+    }
+    return projected;
+  } catch (error) {
+    if (!(error instanceof import_creative_delivery.CreativeFormatProjectionError)) throw error;
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: `${operation} request contains a legacy creative format that cannot be represented canonically.`,
+      field: "request",
+      suggestion: "Send canonical format_kind values, or configure legacyCreativeFormatConverter for custom legacy formats."
+    });
+  }
+}
+function asCanonicalGetProductsRequest(request) {
+  if (!Array.isArray(request["fields"])) return request;
+  const fields = [
+    ...new Set(
+      request["fields"].flatMap(
+        (field) => field === "format_ids" ? ["format_options"] : typeof field === "string" ? [field] : []
+      )
+    )
+  ];
+  return { ...request, fields };
+}
+function asCanonicalListCreativesRequest(request, legacyFormatConverter) {
+  const filters = request["filters"] !== null && typeof request["filters"] === "object" && !Array.isArray(request["filters"]) ? request["filters"] : void 0;
+  const legacyFormatIds = filters?.["format_ids"];
+  if (Array.isArray(legacyFormatIds) && legacyFormatIds.length > 0) {
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: "list_creatives legacy format_ids filters are unavailable on the canonical platform surface.",
+      field: "filters.format_ids",
+      suggestion: "Filter by canonical creative fields, or use an explicit legacy wire handler during migration."
+    });
+  }
+  const { format_ids: _dropLegacyFormatIds, ...canonicalFilters } = filters ?? {};
+  void _dropLegacyFormatIds;
+  const withoutLegacyFilter = filters === void 0 ? request : { ...request, filters: canonicalFilters };
+  const projected = asCanonicalSemanticServerRequest(
+    withoutLegacyFilter,
+    "list_creatives",
+    legacyFormatConverter
+  );
+  if (!Array.isArray(projected["fields"])) return projected;
+  const fields = [
+    ...new Set(
+      projected["fields"].flatMap(
+        (field) => field === "format_id" ? ["format_kind"] : typeof field === "string" ? [field] : []
+      )
+    )
+  ];
+  return { ...projected, fields };
+}
+function asCanonicalProductResponse(response, legacyFormatConverter) {
+  try {
+    assertSafeSemanticPayload(response, "get_products");
+  } catch (error) {
+    if (!(error instanceof import_creative_delivery.CreativeFormatProjectionError)) throw error;
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: "get_products platform response cannot be represented safely at the canonical boundary.",
+      field: "response",
+      suggestion: "Return an acyclic data-only product response without enumerable accessors."
+    });
+  }
+  const projected = (0, import_augment_response.toCanonicalOnlyResponse)(response, {
+    legacyFormatConverter
+  });
+  if (projected.diagnostics.length > 0) {
+    const first = projected.diagnostics[0];
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: "get_products returned a legacy format that cannot be represented canonically.",
+      field: first.field,
+      suggestion: "Declare canonical format_options or configure legacyCreativeFormatConverter for the legacy format."
+    });
+  }
+  return asCanonicalServerResponse(projected.response);
+}
+function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolver, operation) {
+  const visit = (current) => {
+    if (Array.isArray(current)) return current.map(visit);
+    if (current === null || typeof current !== "object") return current;
+    const record = current;
+    const hasFormatDeclarations = Array.isArray(record.format_options);
+    const declarationOwner = typeof record.product_id === "string" ? record.product_id : typeof record.placement_id === "string" ? record.placement_id : "(response)";
+    let projected = record;
+    if (hasFormatDeclarations) {
+      const formatOptions = record.format_options.map((value2, index) => {
+        if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) return value2;
+        const declaration = value2;
+        if (declaration.format_kind !== "custom" || declaration.canonical_formats_only === true) return declaration;
+        let refs = [...(0, import_legacy_metadata.legacyFormatRefsForDeclaration)(declaration)];
+        if (refs.length === 0) {
+          try {
+            refs = (0, import_v2_to_v1.resolveCanonicalFormatLegacyRefs)(canonicalFormatLegacyResolver, {
+              source: "product",
+              declaration,
+              productId: declarationOwner,
+              field: `${declarationOwner}.format_options[${index}]`
+            }) ?? [];
+          } catch (error) {
+            if (!(error instanceof import_v2_to_v1.CanonicalFormatLegacyResolutionError)) throw error;
+            throw new import_creative_delivery.CreativeFormatProjectionError(
+              operation,
+              `(format owner:${declarationOwner})`,
+              "canonical format legacy resolver returned an invalid custom declaration mapping"
+            );
+          }
+        }
+        if (refs.length === 0) {
+          throw new import_creative_delivery.CreativeFormatProjectionError(
+            operation,
+            `(format owner:${declarationOwner})`,
+            "custom canonical declaration must set canonical_formats_only or provide an explicit legacy mapping"
+          );
+        }
+        return { ...declaration, v1_format_ref: refs.map((ref) => ({ ...ref })) };
+      });
+      projected = { ...record, format_options: formatOptions };
+    }
+    let changed = projected !== record;
+    const next = { ...projected };
+    for (const [key, child] of Object.entries(projected)) {
+      if (hasFormatDeclarations && key === "format_options") continue;
+      const visited = visit(child);
+      if (visited !== child) {
+        next[key] = visited;
+        changed = true;
+      }
+    }
+    return changed ? next : projected;
+  };
+  return visit(value);
+}
+function asProductResponseForWire(canonicalResponse, wireMode, canonicalFormatLegacyResolver) {
+  if (wireMode === "canonical") {
+    return attachCanonicalCustomFormatWireRefs(canonicalResponse, canonicalFormatLegacyResolver, "get_products");
+  }
+  if (!Array.isArray(canonicalResponse.products)) return canonicalResponse;
+  const products = canonicalResponse.products.map((product) => {
+    const projected = (0, import_v2_to_v1.projectV2ProductToV1)(product, { canonicalFormatLegacyResolver });
+    if (projected.diagnostics.length > 0) {
+      const first = projected.diagnostics[0];
+      throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+        message: "get_products returned a canonical format that cannot be represented on the configured legacy wire.",
+        field: first.field,
+        suggestion: "Add an explicit legacy format mapping to the canonical declaration, or configure this server for AdCP 3.1 or newer."
+      });
+    }
+    return projected.v1;
+  });
+  return { ...canonicalResponse, products };
+}
 function refuseInlineAccountIdWhenForbidden(resolution, ref) {
   if (resolution !== "implicit" && resolution !== "derived") return;
   if ((0, import_account.refAccountId)(ref) === void 0) return;
@@ -123,6 +617,13 @@ function warnIfTruncatedMultiIdResponse(toolName, idFieldName, requestedIds, res
 }
 function createAdcpServerFromPlatform(platform, opts) {
   (0, import_validate_platform.validatePlatform)(platform);
+  const runtimeLegacyOptions = opts;
+  const legacyHandlers = {
+    mediaBuy: opts.legacyHandlers?.mediaBuy ?? runtimeLegacyOptions.mediaBuy,
+    creative: opts.legacyHandlers?.creative ?? runtimeLegacyOptions.creative,
+    governance: opts.legacyHandlers?.governance ?? runtimeLegacyOptions.governance,
+    brandRights: opts.legacyHandlers?.brandRights ?? runtimeLegacyOptions.brandRights
+  };
   {
     const specialisms = platform.capabilities.specialisms;
     const issues = (0, import_validate_specialisms.validateSpecialismRequiredTools)(platform, specialisms);
@@ -194,6 +695,28 @@ function createAdcpServerFromPlatform(platform, opts) {
   const hasSalesPlatform = platform.sales != null || platform.proposalManager != null;
   const supportsProposals = platform.capabilities.supportsProposals ?? (platform.proposalManager != null ? true : hasSalesPlatform ? false : void 0);
   const hasMediaBuyProjection = hasSalesPlatform || at != null || ct != null || cs != null || som != null || fc != null || targeting != null || supportsProposals !== void 0;
+  const configuredAdcpVersion = opts.adcpVersion ?? import_version.ADCP_VERSION;
+  const configuredRelease = parseAdcpRelease(configuredAdcpVersion);
+  if (!configuredRelease) {
+    throw new import_validate_platform.PlatformConfigError(
+      `Configured AdCP version '${configuredAdcpVersion}' is not a valid release identifier`
+    );
+  }
+  for (const advertisedVersion of platform.capabilities.supported_versions ?? []) {
+    const advertisedRelease = parseAdcpRelease(advertisedVersion);
+    if (!advertisedRelease) {
+      throw new import_validate_platform.PlatformConfigError(
+        `capabilities.supported_versions contains invalid release identifier '${advertisedVersion}'`
+      );
+    }
+    if (compareAdcpReleases(advertisedRelease, configuredRelease) > 0) {
+      throw new import_validate_platform.PlatformConfigError(
+        `capabilities.supported_versions advertises AdCP ${advertisedVersion}, newer than the configured server schema ${configuredAdcpVersion}`
+      );
+    }
+  }
+  const canonicalCreativeCapability = supportsCanonicalCreativeCapability(configuredAdcpVersion);
+  const defaultCreativeWireMode = canonicalCreativeCapability ? "canonical" : "legacy";
   const mediaBuyOverrides = {
     ...hasSalesPlatform && {
       buying_modes: supportsProposals ? ["brief", "refine"] : ["brief"]
@@ -205,12 +728,11 @@ function createAdcpServerFromPlatform(platform, opts) {
     ...fc != null && { frequency_capping: fc },
     ...targeting != null && { execution: { targeting } },
     ...supportsProposals !== void 0 && { supports_proposals: supportsProposals },
-    ...hasMediaBuyProjection && {
-      features: {
-        ...at != null && { audience_targeting: true },
-        ...ct != null && { conversion_tracking: true },
-        ...cs != null && { content_standards: true }
-      }
+    features: {
+      ...canonicalCreativeCapability && { canonical_creatives: true },
+      ...at != null && { audience_targeting: true },
+      ...ct != null && { conversion_tracking: true },
+      ...cs != null && { content_standards: true }
     }
   };
   if (process.env.NODE_ENV !== "production") {
@@ -261,19 +783,23 @@ function createAdcpServerFromPlatform(platform, opts) {
   const hasSpecialisms = platformSpecialisms.length > 0;
   const claimsSignedSpecialism = platformSpecialisms.includes("signed-requests");
   const hasOverridesProjection = hasMediaBuyProjection || hasBrandProjection || hasAccountProjection || hasComplianceTestingProjection;
-  const adopterFeatures = platform.capabilities.features;
+  const { canonicalCreatives: _adopterCanonicalCreatives, ...adopterFeatureBase } = platform.capabilities.features ?? {};
+  void _adopterCanonicalCreatives;
+  const adopterFeatures = {
+    ...adopterFeatureBase,
+    ...canonicalCreativeCapability && { canonicalCreatives: true }
+  };
   const adopterCreative = platform.capabilities.creative;
   const adopterAccount = platform.capabilities.account;
   const adopterOverrides = platform.capabilities.overrides;
   const adopterSupportedVersions = platform.capabilities.supported_versions;
-  const hasAdopterPassthroughs = adopterFeatures !== void 0 || adopterCreative !== void 0 || adopterAccount !== void 0 || adopterOverrides !== void 0 || adopterSupportedVersions !== void 0;
   const hasOverridesObject = hasOverridesProjection || adopterOverrides !== void 0;
-  const projectedCapabilitiesConfig = hasOverridesObject || hasSpecialisms || hasAdopterPassthroughs ? {
+  const projectedCapabilitiesConfig = {
     ...hasSpecialisms && {
       specialisms: [...platformSpecialisms]
     },
     ...claimsSignedSpecialism && { request_signing: { supported: true } },
-    ...adopterFeatures !== void 0 && { features: adopterFeatures },
+    features: adopterFeatures,
     ...adopterCreative !== void 0 && { creative: adopterCreative },
     ...adopterAccount !== void 0 && { account: adopterAccount },
     ...adopterSupportedVersions !== void 0 && {
@@ -282,9 +808,7 @@ function createAdcpServerFromPlatform(platform, opts) {
     ...hasOverridesObject && {
       overrides: {
         ...adopterOverrides ?? {},
-        ...hasMediaBuyProjection && {
-          media_buy: mergeCapabilityOverride(adopterOverrides?.media_buy, mediaBuyOverrides)
-        },
+        media_buy: mergeCapabilityOverride(adopterOverrides?.media_buy, mediaBuyOverrides),
         ...hasBrandProjection && {
           brand: mergeCapabilityOverride(adopterOverrides?.brand, brandOverrides)
         },
@@ -294,7 +818,7 @@ function createAdcpServerFromPlatform(platform, opts) {
         ...hasComplianceTestingProjection && complianceTestingOverrides != null && { compliance_testing: complianceTestingOverrides }
       }
     }
-  } : void 0;
+  };
   const ctxFor = makeCtxFor(effectiveCtxMetadata);
   if (opts.resolveIdempotencyPrincipal === void 0) {
     const env = process.env.NODE_ENV;
@@ -420,7 +944,7 @@ function createAdcpServerFromPlatform(platform, opts) {
     // See `CreateAdcpServerFromPlatformOptions` JSDoc for the migration-seam
     // contract.
     mediaBuy: mergeHandlers(
-      opts.mediaBuy,
+      legacyHandlers.mediaBuy,
       buildMediaBuyHandlers(
         platform,
         taskRegistry,
@@ -434,13 +958,16 @@ function createAdcpServerFromPlatform(platform, opts) {
         ctxFor,
         effectiveCtxMetadata,
         opts.mediaBuyStore,
-        opts.proposalStore
+        opts.proposalStore,
+        opts.legacyCreativeFormatConverter,
+        opts.canonicalFormatLegacyResolver,
+        defaultCreativeWireMode
       ),
       "mediaBuy",
       mergeOpts
     ),
     creative: mergeHandlers(
-      opts.creative,
+      legacyHandlers.creative,
       buildCreativeHandlers(
         platform,
         taskRegistry,
@@ -451,7 +978,10 @@ function createAdcpServerFromPlatform(platform, opts) {
           allowPrivateWebhookUrls: opts.allowPrivateWebhookUrls === true,
           autoEmitCompletionWebhooks: opts.autoEmitCompletionWebhooks !== false
         },
-        ctxFor
+        ctxFor,
+        opts.legacyCreativeFormatConverter,
+        opts.canonicalFormatLegacyResolver,
+        defaultCreativeWireMode
       ),
       "creative",
       mergeOpts
@@ -486,10 +1016,15 @@ function createAdcpServerFromPlatform(platform, opts) {
       "sponsoredIntelligence",
       mergeOpts
     ),
-    governance: mergeHandlers(opts.governance, buildGovernanceHandlers(platform, ctxFor), "governance", mergeOpts),
+    governance: mergeHandlers(
+      legacyHandlers.governance,
+      buildGovernanceHandlers(platform, ctxFor),
+      "governance",
+      mergeOpts
+    ),
     accounts: mergeHandlers(opts.accounts, buildAccountHandlers(platform, ctxFor), "accounts", mergeOpts),
     brandRights: mergeHandlers(
-      opts.brandRights,
+      legacyHandlers.brandRights,
       buildBrandRightsHandlers(platform, ctxFor, effectiveCtxMetadata, fwLogger),
       "brandRights",
       mergeOpts
@@ -1039,7 +1574,7 @@ function mergeHandlers(custom, platform, domain, opts) {
     if (collisions.length > 0) {
       const dedupeKey = `${domain}|${[...collisions].sort().join(",")}`;
       const shouldLog = opts.mode !== "log-once" || !mergeSeamLoggedKeys.has(dedupeKey);
-      const message = `[adcp/decisioning] opts.${domain}.{${collisions.join(", ")}} ${collisions.length === 1 ? "is" : "are"} shadowed by platform-derived handlers. The merge seam is for tools the platform doesn't model yet \u2014 once a tool has a native platform method, move the logic there and remove the opts override.`;
+      const message = `[adcp/decisioning] opts.legacyHandlers.${domain}.{${collisions.join(", ")}} ${collisions.length === 1 ? "is" : "are"} shadowed by platform-derived handlers. The merge seam is for tools the platform doesn't model yet \u2014 once a tool has a native platform method, move the logic there and remove the opts override.`;
       if (opts.mode === "strict") {
         throw new import_validate_platform.PlatformConfigError(message);
       }
@@ -1551,7 +2086,7 @@ async function backfillTargetingOverlay(store, accountId, result, logger) {
     logger.warn(`[adcp/decisioning] mediaBuyStore.backfill failed: ${msg}`);
   }
 }
-async function hydratePackagesWithProducts(store, accountId, packages, logger) {
+async function hydratePackagesWithProducts(store, accountId, packages, logger, legacyFormatConverter) {
   if (!store || !accountId || !packages || packages.length === 0) return;
   const refs = [];
   for (const pkg of packages) {
@@ -1576,7 +2111,15 @@ async function hydratePackagesWithProducts(store, accountId, packages, logger) {
     if (typeof productId !== "string") continue;
     const entry = entries.get(`product:${productId}`);
     if (!entry?.resource || typeof entry.resource !== "object") continue;
-    const hydrated = { ...entry.resource };
+    let hydrated;
+    try {
+      hydrated = asCanonicalSemanticServerRequest(entry.resource, "hydrate_product", legacyFormatConverter);
+    } catch {
+      logger.warn(
+        `[adcp/decisioning] auto-hydrate product:${productId} skipped: stored creative format has no canonical representation`
+      );
+      continue;
+    }
     if (entry.value !== null && entry.value !== void 0) {
       hydrated["ctx_metadata"] = entry.value;
     }
@@ -1594,7 +2137,7 @@ async function hydratePackagesWithProducts(store, accountId, packages, logger) {
     });
   }
 }
-async function hydrateSingleResource(store, accountId, kind, id, attachField, target, logger) {
+async function hydrateSingleResource(store, accountId, kind, id, attachField, target, logger, legacyFormatConverter) {
   if (!store || !accountId || !id || target == null || typeof target !== "object") return;
   let entry;
   try {
@@ -1605,7 +2148,19 @@ async function hydrateSingleResource(store, accountId, kind, id, attachField, ta
     return;
   }
   if (!entry?.resource || typeof entry.resource !== "object") return;
-  const hydrated = { ...entry.resource };
+  let hydrated;
+  if (legacyFormatConverter !== void 0 || kind === "media_buy" || kind === "package" || kind === "creative") {
+    try {
+      hydrated = asCanonicalSemanticServerRequest(entry.resource, `hydrate_${kind}`, legacyFormatConverter);
+    } catch {
+      logger.warn(
+        `[adcp/decisioning] auto-hydrate ${kind}:${id} skipped: stored creative format has no canonical representation`
+      );
+      return;
+    }
+  } else {
+    hydrated = { ...entry.resource };
+  }
   if (entry.value !== null && entry.value !== void 0) {
     hydrated["ctx_metadata"] = entry.value;
   }
@@ -1679,7 +2234,7 @@ function deriveAttachField(toolName, field) {
   if (override) return override;
   return field.endsWith("_id") ? field.slice(0, -3) : field;
 }
-async function hydrateForTool(store, accountId, toolName, params, logger) {
+async function hydrateForTool(store, accountId, toolName, params, logger, legacyFormatConverter) {
   if (!store || !accountId || params == null || typeof params !== "object") return;
   const fields = import_entity_hydration.TOOL_ENTITY_FIELDS[toolName];
   if (!fields || fields.length === 0) return;
@@ -1690,7 +2245,7 @@ async function hydrateForTool(store, accountId, toolName, params, logger) {
     const kind = ENTITY_TO_RESOURCE_KIND[xEntity];
     if (!kind) continue;
     const attachField = deriveAttachField(toolName, field);
-    await hydrateSingleResource(store, accountId, kind, id, attachField, params, logger);
+    await hydrateSingleResource(store, accountId, kind, id, attachField, params, logger, legacyFormatConverter);
   }
 }
 function extractPushConfig(params, _logger, opts = {}) {
@@ -1837,17 +2392,19 @@ function validatePushNotificationOperationId(operationId) {
   }
   return { ok: true };
 }
-function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observability, logger, pushOpts, ctxFor, ctxMetadataStore, mediaBuyStore, proposalStore) {
+function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observability, logger, pushOpts, ctxFor, ctxMetadataStore, mediaBuyStore, proposalStore, legacyFormatConverter, canonicalFormatLegacyResolver, creativeWireMode) {
   const sales = platform.sales;
   const proposalManager = platform.proposalManager;
   if (!sales && !proposalManager) return void 0;
   return {
     ...(sales?.getProducts || proposalManager) && {
       getProducts: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        const canonicalParams = asCanonicalGetProductsRequest(params);
         const reqCtx = ctxFor(ctx, params);
         if (proposalManager && proposalStore) {
           const intercept = await (0, import_proposal.maybeInterceptFinalize)({
-            request: params,
+            request: canonicalParams,
             manager: proposalManager,
             store: proposalStore,
             ctx: reqCtx
@@ -1892,16 +2449,17 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
             let result;
             if (proposalManager) {
               const useRefine = buyingMode === "refine" && proposalManager.capabilities.refine === true && typeof proposalManager.refineProducts === "function";
-              result = useRefine ? await proposalManager.refineProducts(params, reqCtx) : await proposalManager.getProducts(params, reqCtx);
+              result = useRefine ? await proposalManager.refineProducts(canonicalParams, reqCtx) : await proposalManager.getProducts(canonicalParams, reqCtx);
             } else {
-              result = await sales.getProducts(params, reqCtx);
+              result = await sales.getProducts(canonicalParams, reqCtx);
             }
             const projectProducts = async (terminalResult) => {
+              const canonicalResult = asCanonicalProductResponse(terminalResult, legacyFormatConverter);
               await autoStoreResources(
                 ctxMetadataStore,
                 reqCtx.account?.id,
                 "product",
-                terminalResult?.products,
+                canonicalResult?.products,
                 "product_id",
                 logger
               );
@@ -1912,7 +2470,11 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
                   ctx: reqCtx
                 });
               }
-              return terminalResult;
+              return asProductResponseForWire(
+                canonicalResult,
+                responseWireMode,
+                canonicalFormatLegacyResolver
+              );
             };
             const isHandoff = (0, import_async_outcome2.isTaskHandoff)(result);
             if (buyingMode === "wholesale" && isHandoff) {
@@ -1958,12 +2520,15 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
     },
     ...sales?.createMediaBuy && {
       createMediaBuy: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        params = asCanonicalSemanticServerRequest(params, "create_media_buy", legacyFormatConverter);
         const reqCtx = ctxFor(ctx, params);
         await hydratePackagesWithProducts(
           ctxMetadataStore,
           reqCtx.account?.id,
           params?.packages,
-          logger
+          logger,
+          legacyFormatConverter
         );
         let reservation = null;
         if (proposalStore) {
@@ -2022,7 +2587,13 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               result,
               async (r) => {
                 await persistTargetingOverlayFromCreate(mediaBuyStore, reqCtx.account?.id, params, r, logger);
-                return r;
+                return asSemanticServerResponseForWire(
+                  r,
+                  "create_media_buy",
+                  legacyFormatConverter,
+                  canonicalFormatLegacyResolver,
+                  responseWireMode
+                );
               }
             );
           },
@@ -2032,6 +2603,8 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
     },
     ...sales?.updateMediaBuy && {
       updateMediaBuy: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        params = asCanonicalSemanticServerRequest(params, "update_media_buy", legacyFormatConverter);
         const reqCtx = ctxFor(ctx, params);
         const { media_buy_id } = params;
         if (!media_buy_id) {
@@ -2040,7 +2613,14 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
             field: "media_buy_id"
           });
         }
-        await hydrateForTool(ctxMetadataStore, reqCtx.account?.id, "update_media_buy", params, logger);
+        await hydrateForTool(
+          ctxMetadataStore,
+          reqCtx.account?.id,
+          "update_media_buy",
+          params,
+          logger,
+          legacyFormatConverter
+        );
         if (proposalStore) {
           const record = await (0, import_proposal.maybeHydrateRecipesForMediaBuyId)({
             mediaBuyId: media_buy_id,
@@ -2057,7 +2637,11 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
             const push = extractPushConfig(params, logger, {
               allowPrivateWebhookUrls: pushOpts.allowPrivateWebhookUrls
             });
-            const result = await sales.updateMediaBuy(media_buy_id, params, reqCtx);
+            const result = await sales.updateMediaBuy(
+              media_buy_id,
+              params,
+              reqCtx
+            );
             return routeIfHandoff(
               taskRegistry,
               {
@@ -2081,7 +2665,13 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
                   params,
                   logger
                 );
-                return r;
+                return asSemanticServerResponseForWire(
+                  r,
+                  "update_media_buy",
+                  legacyFormatConverter,
+                  canonicalFormatLegacyResolver,
+                  responseWireMode
+                );
               }
             );
           },
@@ -2090,6 +2680,8 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
       }
     },
     syncCreatives: async (params, ctx) => {
+      const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+      params = asCanonicalSemanticServerRequest(params, "sync_creatives", legacyFormatConverter);
       const reqCtx = ctxFor(ctx, params);
       const creatives = params.creatives ?? [];
       if (!sales?.syncCreatives) {
@@ -2116,7 +2708,13 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               logger
             },
             result,
-            (rows) => ({ creatives: rows.map(normalizeRowErrors) })
+            (rows) => asSemanticServerResponseForWire(
+              { creatives: rows.map(normalizeRowErrors) },
+              "sync_creatives",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver,
+              responseWireMode
+            )
           );
         },
         (r) => r
@@ -2124,6 +2722,7 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
     },
     ...sales?.getMediaBuyDelivery && {
       getMediaBuyDelivery: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const reqCtx = ctxFor(ctx, params);
         if (proposalStore) {
           const ids = params.media_buy_ids;
@@ -2149,7 +2748,13 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               result?.media_buy_deliveries,
               logger
             );
-            return result;
+            return asSemanticServerResponseForWire(
+              result,
+              "get_media_buy_delivery",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver,
+              responseWireMode
+            );
           },
           (actuals) => actuals
         );
@@ -2157,19 +2762,20 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
     },
     // Optional methods — return UNSUPPORTED_FEATURE when the platform omits
     // them. Adopters that haven't migrated to the v6 platform interface for
-    // these specific tools can still pass raw handlers via opts.mediaBuy
+    // these specific tools can still pass raw handlers via opts.legacyHandlers.mediaBuy
     // (merge seam) — the merge runs AFTER buildMediaBuyHandlers, so opts
     // handlers fill in for the methods this platform omits.
     // `getMediaBuys` is REQUIRED at the type level, but we keep a runtime
     // guard for the merge-seam migration path: legacy adopters wire it via
-    // `opts.mediaBuy.getMediaBuys` rather than on the platform interface.
+    // `opts.legacyHandlers.mediaBuy.getMediaBuys` rather than on the platform interface.
     // Once the migration completes (every adopter implements it natively),
     // this conditional spreads can collapse — but for now, omitting the
     // platform-derived handler when absent lets `mergeHandlers` pick up the
-    // adopter's custom handler from `opts.mediaBuy` instead of throwing
+    // adopter's custom handler from `opts.legacyHandlers.mediaBuy` instead of throwing
     // `sales.getMediaBuys is not a function`.
     ...sales?.getMediaBuys && {
       getMediaBuys: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const reqCtx = ctxFor(ctx, params);
         return projectSync(
           async () => {
@@ -2181,16 +2787,29 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               result?.media_buys,
               logger
             );
+            const canonicalResult = asCanonicalSemanticServerResponse(
+              result,
+              "get_media_buys",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver
+            );
             await autoStoreResources(
               ctxMetadataStore,
               reqCtx.account?.id,
               "media_buy",
-              result?.media_buys,
+              canonicalResult?.media_buys,
               "media_buy_id",
               logger
             );
-            await backfillTargetingOverlay(mediaBuyStore, reqCtx.account?.id, result, logger);
-            return result;
+            const wireResult = responseWireMode === "canonical" ? attachCanonicalCustomFormatWireRefs(canonicalResult, canonicalFormatLegacyResolver, "get_media_buys") : asSemanticServerResponseForWire(
+              result,
+              "get_media_buys",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver,
+              responseWireMode
+            );
+            await backfillTargetingOverlay(mediaBuyStore, reqCtx.account?.id, wireResult, logger);
+            return wireResult;
           },
           (r) => r
         );
@@ -2198,37 +2817,64 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
     },
     ...sales?.providePerformanceFeedback && {
       providePerformanceFeedback: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        params = asCanonicalSemanticServerRequest(params, "provide_performance_feedback", legacyFormatConverter);
         const reqCtx = ctxFor(ctx, params);
-        await hydrateForTool(ctxMetadataStore, reqCtx.account?.id, "provide_performance_feedback", params, logger);
+        await hydrateForTool(
+          ctxMetadataStore,
+          reqCtx.account?.id,
+          "provide_performance_feedback",
+          params,
+          logger,
+          legacyFormatConverter
+        );
         return projectSync(
           () => sales.providePerformanceFeedback(params, reqCtx),
-          (r) => r
+          (result) => asSemanticServerResponseForWire(
+            result,
+            "provide_performance_feedback",
+            legacyFormatConverter,
+            canonicalFormatLegacyResolver,
+            responseWireMode
+          )
         );
       }
     },
-    ...sales?.listCreativeFormats && {
+    ...sales?.listCreativeFormatsLegacy && {
       listCreativeFormats: async (params, ctx) => {
         const reqCtx = ctxFor(ctx, params);
         return projectSync(
-          () => sales.listCreativeFormats(params, reqCtx),
+          () => sales.listCreativeFormatsLegacy(params, reqCtx),
           (r) => r
         );
       }
     },
     ...sales?.listCreatives && {
       listCreatives: async (params, ctx) => {
-        const reqCtx = ctxFor(ctx, params);
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        const canonicalParams = asCanonicalListCreativesRequest(
+          params,
+          legacyFormatConverter
+        );
+        const reqCtx = ctxFor(ctx, canonicalParams);
         return projectSync(
           async () => {
-            const result = await sales.listCreatives(params, reqCtx);
+            const result = await sales.listCreatives(canonicalParams, reqCtx);
+            const canonicalResult = asSemanticServerResponseForWire(
+              result,
+              "list_creatives",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver,
+              responseWireMode
+            );
             warnIfTruncatedMultiIdResponse(
               "listCreatives",
               "creative_ids",
               params.creative_ids,
-              result?.creatives,
+              canonicalResult?.creatives,
               logger
             );
-            return result;
+            return canonicalResult;
           },
           (r) => r
         );
@@ -2246,26 +2892,26 @@ function projectBuildCreativeReturn(ret) {
   }
   return { creative_manifest: ret };
 }
-function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observability, logger, pushOpts, ctxFor) {
+function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observability, logger, pushOpts, ctxFor, legacyFormatConverter, canonicalFormatLegacyResolver, creativeWireMode) {
   const creative = platform.creative;
   if (!creative) return void 0;
   return {
     buildCreative: async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => creative.buildCreative(params, reqCtx),
+        () => creative.buildCreativeLegacy(params, reqCtx),
         (ret) => projectBuildCreativeReturn(ret)
       );
     },
     previewCreative: async (params, ctx) => {
-      if (!("previewCreative" in creative) || creative.previewCreative == null) {
+      if (!("previewCreativeLegacy" in creative) || creative.previewCreativeLegacy == null) {
         return (0, import_errors.adcpError)("UNSUPPORTED_FEATURE", {
-          message: "preview_creative: this creative platform did not implement previewCreative. Add `previewCreative(req, ctx)` to your CreativeBuilderPlatform / CreativeAdServerPlatform literal."
+          message: "preview_creative: this creative platform did not implement previewCreativeLegacy. Add `previewCreativeLegacy(req, ctx)` to your CreativeBuilderPlatform / CreativeAdServerPlatform literal."
         });
       }
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => creative.previewCreative(params, reqCtx),
+        () => creative.previewCreativeLegacy(params, reqCtx),
         (preview) => preview
       );
     },
@@ -2275,14 +2921,14 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
     // undefined per `NoAccountCtx`. Wired identically on both
     // `CreativeBuilderPlatform` and `CreativeAdServerPlatform`.
     listCreativeFormats: async (params, ctx) => {
-      if (!("listCreativeFormats" in creative) || creative.listCreativeFormats == null) {
+      if (!("listCreativeFormatsLegacy" in creative) || creative.listCreativeFormatsLegacy == null) {
         return (0, import_errors.adcpError)("UNSUPPORTED_FEATURE", {
-          message: "list_creative_formats: this creative platform did not implement listCreativeFormats. Add `listCreativeFormats(req, ctx)` to your CreativeBuilderPlatform / CreativeAdServerPlatform literal, or delegate via `capabilities.creative_agents`."
+          message: "list_creative_formats: this creative platform did not implement listCreativeFormatsLegacy. Add `listCreativeFormatsLegacy(req, ctx)` to your CreativeBuilderPlatform / CreativeAdServerPlatform literal, or delegate via `capabilities.creative_agents`."
         });
       }
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => creative.listCreativeFormats(params, reqCtx),
+        () => creative.listCreativeFormatsLegacy(params, reqCtx),
         (r) => r
       );
     },
@@ -2293,6 +2939,8 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
     // buildAccountHandlers — see comment at line 4544.
     ...creative.syncCreatives != null && {
       syncCreatives: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        params = asCanonicalSemanticServerRequest(params, "sync_creatives", legacyFormatConverter);
         const reqCtx = ctxFor(ctx, params);
         const creatives = params.creatives ?? [];
         return projectSync(
@@ -2316,7 +2964,13 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
                 logger
               },
               result,
-              (rows) => ({ creatives: rows.map(normalizeRowErrors) })
+              (rows) => asSemanticServerResponseForWire(
+                { creatives: rows.map(normalizeRowErrors) },
+                "sync_creatives",
+                legacyFormatConverter,
+                canonicalFormatLegacyResolver,
+                responseWireMode
+              )
             );
           },
           (r) => r
@@ -2330,18 +2984,30 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
     // every call. Only emit handlers when the platform method is present.
     ..."listCreatives" in creative && creative.listCreatives != null && {
       listCreatives: async (params, ctx) => {
-        const reqCtx = ctxFor(ctx, params);
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        const canonicalParams = asCanonicalListCreativesRequest(
+          params,
+          legacyFormatConverter
+        );
+        const reqCtx = ctxFor(ctx, canonicalParams);
         return projectSync(
           async () => {
-            const result = await creative.listCreatives(params, reqCtx);
+            const result = await creative.listCreatives(canonicalParams, reqCtx);
+            const canonicalResult = asSemanticServerResponseForWire(
+              result,
+              "list_creatives",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver,
+              responseWireMode
+            );
             warnIfTruncatedMultiIdResponse(
               "listCreatives",
               "creative_ids",
               params.creative_ids,
-              result?.creatives,
+              canonicalResult?.creatives,
               logger
             );
-            return result;
+            return canonicalResult;
           },
           (r) => r
         );
@@ -2349,6 +3015,7 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
     },
     ..."getCreativeDelivery" in creative && creative.getCreativeDelivery != null && {
       getCreativeDelivery: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const reqCtx = ctxFor(ctx, params);
         return projectSync(
           async () => {
@@ -2360,7 +3027,13 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
               result?.creative_deliveries,
               logger
             );
-            return result;
+            return asSemanticServerResponseForWire(
+              result,
+              "get_creative_delivery",
+              legacyFormatConverter,
+              canonicalFormatLegacyResolver,
+              responseWireMode
+            );
           },
           (r) => r
         );
@@ -2606,7 +3279,7 @@ function buildBrandRightsHandlers(platform, ctxFor, ctxMetadataStore, logger) {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
         async () => {
-          const result = await br.getRights(params, reqCtx);
+          const result = await br.getRightsLegacy(params, reqCtx);
           await autoStoreResources(
             ctxMetadataStore,
             reqCtx.account?.id,
@@ -2629,7 +3302,7 @@ function buildBrandRightsHandlers(platform, ctxFor, ctxMetadataStore, logger) {
       const reqCtx = ctxFor(ctx, params);
       await hydrateForTool(ctxMetadataStore, reqCtx.account?.id, "acquire_rights", params, logger);
       return projectSync(
-        () => br.acquireRights(params, reqCtx),
+        () => br.acquireRightsLegacy(params, reqCtx),
         (r) => r
       );
     },
@@ -2647,7 +3320,7 @@ function buildBrandRightsHandlers(platform, ctxFor, ctxMetadataStore, logger) {
       const reqCtx = ctxFor(ctx, params);
       await hydrateForTool(ctxMetadataStore, reqCtx.account?.id, "update_rights", params, logger);
       return projectSync(
-        () => br.updateRights(params, reqCtx),
+        () => br.updateRightsLegacy(params, reqCtx),
         (r) => r
       );
     }
@@ -2768,59 +3441,59 @@ function buildGovernanceHandlers(platform, ctxFor) {
     handlers.listContentStandards = async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => cs.listContentStandards(params, reqCtx),
+        () => cs.listContentStandardsLegacy(params, reqCtx),
         (r) => r
       );
     };
     handlers.getContentStandards = async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => cs.getContentStandards(params, reqCtx),
+        () => cs.getContentStandardsLegacy(params, reqCtx),
         (r) => r
       );
     };
     handlers.createContentStandards = async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => cs.createContentStandards(params, reqCtx),
+        () => cs.createContentStandardsLegacy(params, reqCtx),
         (r) => r
       );
     };
     handlers.updateContentStandards = async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => cs.updateContentStandards(params, reqCtx),
+        () => cs.updateContentStandardsLegacy(params, reqCtx),
         (r) => r
       );
     };
     handlers.calibrateContent = async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => cs.calibrateContent(params, reqCtx),
+        () => cs.calibrateContentLegacy(params, reqCtx),
         (r) => r
       );
     };
     handlers.validateContentDelivery = async (params, ctx) => {
       const reqCtx = ctxFor(ctx, params);
       return projectSync(
-        () => cs.validateContentDelivery(params, reqCtx),
+        () => cs.validateContentDeliveryLegacy(params, reqCtx),
         (r) => r
       );
     };
-    if (cs.getMediaBuyArtifacts) {
+    if (cs.getMediaBuyArtifactsLegacy) {
       handlers.getMediaBuyArtifacts = async (params, ctx) => {
         const reqCtx = ctxFor(ctx, params);
         return projectSync(
-          () => cs.getMediaBuyArtifacts(params, reqCtx),
+          () => cs.getMediaBuyArtifactsLegacy(params, reqCtx),
           (r) => r
         );
       };
     }
-    if (cs.getCreativeFeatures) {
+    if (cs.getCreativeFeaturesLegacy) {
       handlers.getCreativeFeatures = async (params, ctx) => {
         const reqCtx = ctxFor(ctx, params);
         return projectSync(
-          () => cs.getCreativeFeatures(params, reqCtx),
+          () => cs.getCreativeFeaturesLegacy(params, reqCtx),
           (r) => r
         );
       };