@adcp/sdk 13.0.0-rc.10 → 13.0.0-rc.13

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

@@ -71,6 +71,7 @@ import {
   projectMediaBuyCreativesForDelivery,
   stripLegacyCreativeIdentity
 } from "../../../v2/projection/creative-delivery.mjs";
+import { projectV1ProductToV2 } from "../../../v2/projection/v1-to-v2.mjs";
 import { toCanonicalOnlyResponse } from "../../../v2/projection/augment-response.mjs";
 import {
   CanonicalFormatLegacyResolutionError,
@@ -78,6 +79,7 @@ import {
   resolveCanonicalFormatLegacyRefs
 } from "../../../v2/projection/v2-to-v1.mjs";
 import { legacyFormatRefsForDeclaration } from "../../../v2/projection/legacy-metadata.mjs";
+import { canonicalizeAgentUrl } from "../../../discovery/resolve-agent-properties.mjs";
 import { ADCP_VERSION } from "../../../version.mjs";
 function supportsCanonicalCreativeCapability(version) {
   if (typeof version !== "string") return false;
@@ -95,6 +97,21 @@ function requiresCanonicalCreativeWire(version) {
   const minor = Number(match[2]);
   return major > 3 || major === 3 && minor >= 2;
 }
+function supportsTransitionalDualCreativeWire(version) {
+  if (typeof version !== "string") return false;
+  const match = /^v?(\d+)\.(\d+)(?:\.|-|$)/.exec(version.trim());
+  if (!match) return false;
+  return Number(match[1]) === 3 && Number(match[2]) === 1;
+}
+function shouldEmitTransitionalDualCreativeWire(version, request) {
+  if (!supportsTransitionalDualCreativeWire(version)) return false;
+  if (request === null || typeof request !== "object") return true;
+  const fields = Object.getOwnPropertyDescriptor(request, "fields");
+  if (!fields || !("value" in fields) || !Array.isArray(fields.value)) return true;
+  return Object.values(Object.getOwnPropertyDescriptors(fields.value)).some(
+    (descriptor) => descriptor.enumerable && "value" in descriptor && descriptor.value === "format_ids"
+  );
+}
 function creativeWireEvidenceForRequest(request) {
   let canonical = false;
   let legacy = false;
@@ -366,7 +383,7 @@ function asCanonicalSemanticServerResponse(response, operation, legacyFormatConv
 }
 function asSemanticServerResponseForWire(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver, wireMode) {
   if (wireMode === "canonical") {
-    return attachCanonicalCustomFormatWireRefs(
+    return attachCanonicalFormatWireRefs(
       asCanonicalSemanticServerResponse(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver),
       canonicalFormatLegacyResolver,
       operation
@@ -470,10 +487,10 @@ function asCanonicalGetProductsRequest(request) {
   ];
   return { ...request, fields };
 }
-function asCanonicalListCreativesRequest(request, legacyFormatConverter) {
+function asCanonicalListCreativesRequest(request, legacyFormatConverter, responseWireMode) {
   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) {
+  if (Array.isArray(legacyFormatIds) && legacyFormatIds.length > 0 && responseWireMode !== "legacy") {
     throw new AdcpError("INVALID_REQUEST", {
       message: "list_creatives legacy format_ids filters are unavailable on the canonical platform surface.",
       field: "filters.format_ids",
@@ -488,15 +505,22 @@ function asCanonicalListCreativesRequest(request, legacyFormatConverter) {
     "list_creatives",
     legacyFormatConverter
   );
-  if (!Array.isArray(projected["fields"])) return projected;
+  const withLegacyFilter = responseWireMode === "legacy" && Array.isArray(legacyFormatIds) && legacyFormatIds.length > 0 ? {
+    ...projected,
+    filters: {
+      ...projected["filters"] ?? {},
+      format_ids: legacyFormatIds
+    }
+  } : projected;
+  if (!Array.isArray(withLegacyFilter["fields"])) return withLegacyFilter;
   const fields = [
     ...new Set(
-      projected["fields"].flatMap(
+      withLegacyFilter["fields"].flatMap(
         (field) => field === "format_id" ? ["format_kind"] : typeof field === "string" ? [field] : []
       )
     )
   ];
-  return { ...projected, fields };
+  return { ...withLegacyFilter, fields };
 }
 function asCanonicalProductResponse(response, legacyFormatConverter) {
   try {
@@ -509,41 +533,324 @@ function asCanonicalProductResponse(response, legacyFormatConverter) {
       suggestion: "Return an acyclic data-only product response without enumerable accessors."
     });
   }
+  validateDualProductFormatDeclarations(response, legacyFormatConverter);
   const projected = toCanonicalOnlyResponse(response, {
     legacyFormatConverter
   });
-  if (projected.diagnostics.length > 0) {
-    const first = projected.diagnostics[0];
+  const blockingDiagnostics = projected.diagnostics.filter(
+    (diagnostic) => diagnostic.code !== "LEGACY_FORMAT_ID_DROPPED_UNMAPPED"
+  );
+  if (blockingDiagnostics.length > 0) {
+    const first = blockingDiagnostics[0];
     throw new 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);
+  const canonicalResponse = asCanonicalServerResponse(projected.response);
+  const resolvedDropDiagnostics = projected.diagnostics.filter(
+    (diagnostic) => diagnostic.code === "LEGACY_FORMAT_ID_DROPPED_UNMAPPED"
+  );
+  if (resolvedDropDiagnostics.length > 0 && canonicalResponse !== null && typeof canonicalResponse === "object") {
+    resolvedLegacyDropDiagnosticsByResponse.set(canonicalResponse, resolvedDropDiagnostics);
+  }
+  preserveAuthoredFormatIds(response, canonicalResponse);
+  return canonicalResponse;
+}
+const authoredFormatIdsByOwner = /* @__PURE__ */ new WeakMap();
+const resolvedLegacyDropDiagnosticsByResponse = /* @__PURE__ */ new WeakMap();
+function ownArrayDataValues(value) {
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+  const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : 0;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0) return [];
+  const values = [];
+  for (let index = 0; index < length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (descriptor?.enumerable && "value" in descriptor) values.push(descriptor.value);
+  }
+  return values;
+}
+function cloneWireData(value) {
+  if (Array.isArray(value)) {
+    const cloned2 = [];
+    for (const entry of ownArrayDataValues(value)) cloned2.push(cloneWireData(entry));
+    return cloned2;
+  }
+  if (value === null || typeof value !== "object") return value;
+  const cloned = {};
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (descriptor.enumerable && "value" in descriptor) cloned[key] = cloneWireData(descriptor.value);
+  }
+  return cloned;
+}
+function preserveAuthoredFormatIds(source, target) {
+  if (source === null || target === null || typeof source !== "object" || typeof target !== "object") return;
+  const sourceProducts = Object.getOwnPropertyDescriptor(source, "products");
+  const targetProducts = Object.getOwnPropertyDescriptor(target, "products");
+  if (!sourceProducts || !sourceProducts.enumerable || !("value" in sourceProducts) || !Array.isArray(sourceProducts.value) || !targetProducts || !targetProducts.enumerable || !("value" in targetProducts) || !Array.isArray(targetProducts.value)) {
+    return;
+  }
+  const sourceValues = ownArrayDataValues(sourceProducts.value);
+  const targetValues = ownArrayDataValues(targetProducts.value);
+  const count = Math.min(sourceValues.length, targetValues.length);
+  for (let index = 0; index < count; index++)
+    preserveAuthoredFormatIdsForOwner(sourceValues[index], targetValues[index]);
+}
+function preserveAuthoredFormatIdsForOwner(source, target) {
+  if (source === null || target === null || typeof source !== "object" || typeof target !== "object") return;
+  const sourceProductId = Object.getOwnPropertyDescriptor(source, "product_id");
+  const sourcePlacementId = Object.getOwnPropertyDescriptor(source, "placement_id");
+  const recognizedOwner = sourceProductId?.enumerable && "value" in sourceProductId && typeof sourceProductId.value === "string" || sourcePlacementId?.enumerable && "value" in sourcePlacementId && typeof sourcePlacementId.value === "string";
+  if (!recognizedOwner) return;
+  const sourceFormatIds = Object.getOwnPropertyDescriptor(source, "format_ids");
+  const targetFormatOptions = Object.getOwnPropertyDescriptor(target, "format_options");
+  if (sourceFormatIds && sourceFormatIds.enumerable && "value" in sourceFormatIds && Array.isArray(sourceFormatIds.value) && targetFormatOptions && targetFormatOptions.enumerable && "value" in targetFormatOptions && Array.isArray(targetFormatOptions.value)) {
+    authoredFormatIdsByOwner.set(
+      target,
+      ownArrayDataValues(sourceFormatIds.value).map((ref) => cloneWireData(ref))
+    );
+  }
+  const sourcePlacements = Object.getOwnPropertyDescriptor(source, "placements");
+  const targetPlacements = Object.getOwnPropertyDescriptor(target, "placements");
+  if (sourcePlacements && sourcePlacements.enumerable && "value" in sourcePlacements && Array.isArray(sourcePlacements.value) && targetPlacements && targetPlacements.enumerable && "value" in targetPlacements && Array.isArray(targetPlacements.value)) {
+    const sourceValues = ownArrayDataValues(sourcePlacements.value);
+    const targetValues = ownArrayDataValues(targetPlacements.value);
+    const count = Math.min(sourceValues.length, targetValues.length);
+    for (let index = 0; index < count; index++) {
+      preserveAuthoredFormatIdsForOwner(sourceValues[index], targetValues[index]);
+    }
+  }
 }
-function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolver, operation) {
+function removeResolvedLegacyDropErrors(response, diagnostics) {
+  if (response === null || typeof response !== "object") return response;
+  const resolved = diagnostics.filter((diagnostic) => diagnostic.code === "LEGACY_FORMAT_ID_DROPPED_UNMAPPED");
+  if (resolved.length === 0) return response;
+  const record = response;
+  if (!Array.isArray(record.errors)) return response;
+  const retained = [];
+  for (const value of ownArrayDataValues(record.errors)) {
+    let matchesResolvedDiagnostic = false;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const error = value;
+      for (const diagnostic of resolved) {
+        if (error.code === diagnostic.code && error.field === diagnostic.field && error.source === diagnostic.source && error.sdk_id === diagnostic.sdk_id && jsonValuesEqual(error.details, diagnostic.error.details)) {
+          matchesResolvedDiagnostic = true;
+          break;
+        }
+      }
+    }
+    if (!matchesResolvedDiagnostic) retained.push(value);
+  }
+  if (retained.length > 0) return { ...record, errors: retained };
+  const { errors: _resolvedErrors, ...withoutErrors } = record;
+  void _resolvedErrors;
+  return withoutErrors;
+}
+function legacyFormatRefKey(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const ref = value;
+  if (typeof ref.agent_url !== "string" || typeof ref.id !== "string") return void 0;
+  const agentUrl = canonicalizeAgentUrl(ref.agent_url) ?? ref.agent_url;
+  return `${agentUrl}::${ref.id}::${String(ref.width ?? "")}x${String(ref.height ?? "")}::${String(ref.duration_ms ?? "")}`;
+}
+function jsonValuesEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    const leftValues = ownArrayDataValues(left);
+    const rightValues = ownArrayDataValues(right);
+    if (leftValues.length !== rightValues.length) return false;
+    for (let index = 0; index < leftValues.length; index++) {
+      if (!jsonValuesEqual(leftValues[index], rightValues[index])) return false;
+    }
+    return true;
+  }
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(rightRecord, key) && jsonValuesEqual(leftRecord[key], rightRecord[key]));
+}
+function matchLegacyRefToDeclaration(declaration, ref, ownerId, legacyFormatConverter) {
+  const projected = projectV1ProductToV2(
+    {
+      product_id: ownerId,
+      name: ownerId,
+      description: ownerId,
+      format_ids: [ref]
+    },
+    { legacyFormatConverter }
+  );
+  if (projected.diagnostics.length > 0 || projected.v2.format_options.length !== 1) return "unresolved";
+  const expected = projected.v2.format_options[0];
+  if (declaration.format_kind !== expected.format_kind) return "kind_mismatch";
+  const params = declaration.params !== null && typeof declaration.params === "object" && !Array.isArray(declaration.params) ? declaration.params : {};
+  for (const [key, expectedValue] of Object.entries(expected.params)) {
+    if (!Object.hasOwn(params, key) || !jsonValuesEqual(params[key], expectedValue)) return "params_mismatch";
+  }
+  return "match";
+}
+function validateLegacyRefNarrowing(declaration, ref, ownerId, field, legacyFormatConverter) {
+  const match = matchLegacyRefToDeclaration(declaration, ref, ownerId, legacyFormatConverter);
+  if (match === "kind_mismatch") {
+    throw new AdcpError("INVALID_REQUEST", {
+      message: "get_products returned divergent legacy and canonical format declarations.",
+      field,
+      suggestion: "Make format_ids and format_options.v1_format_ref describe the same canonical format."
+    });
+  }
+  if (match === "params_mismatch") {
+    throw new AdcpError("INVALID_REQUEST", {
+      message: "get_products returned a canonical declaration that does not narrow its v1_format_ref.",
+      field: `${field}.params`,
+      suggestion: "Align canonical format parameters with the referenced legacy format requirements."
+    });
+  }
+}
+function validateDualProductFormatDeclarations(value, legacyFormatConverter) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (current, path) => {
+    if (current === null || typeof current !== "object" || seen.has(current)) return;
+    seen.add(current);
+    if (Array.isArray(current)) {
+      const entries = ownArrayDataValues(current);
+      for (let index = 0; index < entries.length; index++) visit(entries[index], `${path}[${index}]`);
+      return;
+    }
+    const record = current;
+    const formatOptions = Array.isArray(record.format_options) ? record.format_options : void 0;
+    const ownerId = typeof record.product_id === "string" ? record.product_id : typeof record.placement_id === "string" ? record.placement_id : void 0;
+    if (formatOptions && ownerId !== void 0) {
+      const declarationRefs = [];
+      const declarations = ownArrayDataValues(formatOptions);
+      for (let index = 0; index < declarations.length; index++) {
+        const value2 = declarations[index];
+        if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) continue;
+        const declaration = value2;
+        const refs = ownArrayDataValues(
+          legacyFormatRefsForDeclaration(declaration)
+        );
+        const field = `${path}.format_options[${index}]`;
+        if (declaration.canonical_formats_only === true && refs.length > 0) {
+          throw new AdcpError("INVALID_REQUEST", {
+            message: "get_products returned canonical_formats_only together with v1_format_ref.",
+            field,
+            suggestion: "Remove v1_format_ref or set canonical_formats_only to false."
+          });
+        }
+        declarationRefs.push(...refs);
+        for (const ref of refs) {
+          validateLegacyRefNarrowing(declaration, ref, ownerId, field, legacyFormatConverter);
+        }
+      }
+      if (Array.isArray(record.format_ids)) {
+        const formatIds = ownArrayDataValues(record.format_ids);
+        const formatIdKeys = /* @__PURE__ */ new Set();
+        for (const ref of formatIds) {
+          const key = legacyFormatRefKey(ref);
+          if (key !== void 0) formatIdKeys.add(key);
+        }
+        const declarationRefKeys = /* @__PURE__ */ new Set();
+        for (const ref of declarationRefs) {
+          const key = legacyFormatRefKey(ref);
+          if (key !== void 0) declarationRefKeys.add(key);
+        }
+        let divergent = false;
+        for (const key of declarationRefKeys) {
+          if (!formatIdKeys.has(key)) divergent = true;
+        }
+        for (const ref of formatIds) {
+          const key = legacyFormatRefKey(ref);
+          if (key !== void 0 && declarationRefKeys.has(key)) continue;
+          let matched = false;
+          for (const value2 of declarations) {
+            if (value2 !== null && typeof value2 === "object" && !Array.isArray(value2) && value2.canonical_formats_only !== true && matchLegacyRefToDeclaration(value2, ref, ownerId, legacyFormatConverter) === "match") {
+              matched = true;
+              break;
+            }
+          }
+          if (!matched) divergent = true;
+        }
+        if (divergent) {
+          throw new AdcpError("INVALID_REQUEST", {
+            message: "get_products returned divergent format_ids and format_options.v1_format_ref values.",
+            field: path,
+            suggestion: "Dual-emitted product declarations must carry the same legacy format references."
+          });
+        }
+      }
+    }
+    for (const [key, child] of Object.entries(record)) {
+      if (key === "format_options") continue;
+      visit(child, `${path}.${key}`);
+    }
+  };
+  visit(value, "$");
+}
+function attachCanonicalFormatWireRefs(value, canonicalFormatLegacyResolver, operation, emitTransitionalLegacyRefs = false) {
   const visit = (current) => {
-    if (Array.isArray(current)) return current.map(visit);
+    if (Array.isArray(current)) {
+      const mapped = [];
+      for (const entry of ownArrayDataValues(current)) mapped.push(visit(entry));
+      return mapped;
+    }
     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 wireLegacyRefs = [];
+      const wireLegacyRefKeys = /* @__PURE__ */ new Set();
+      const appendWireLegacyRefs = (refs) => {
+        for (const ref of refs) {
+          const key = legacyFormatRefKey(ref);
+          if (key === void 0 || wireLegacyRefKeys.has(key)) continue;
+          wireLegacyRefKeys.add(key);
+          wireLegacyRefs.push(cloneWireData(ref));
+        }
+      };
+      if (emitTransitionalLegacyRefs) {
+        const authoredRefs = authoredFormatIdsByOwner.get(record);
+        if (authoredRefs) appendWireLegacyRefs(authoredRefs);
+      }
+      const formatOptions = [];
+      const declarations = ownArrayDataValues(record.format_options);
+      for (let index = 0; index < declarations.length; index++) {
+        const value2 = declarations[index];
+        if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) {
+          formatOptions.push(value2);
+          continue;
+        }
         const declaration = value2;
-        if (declaration.format_kind !== "custom" || declaration.canonical_formats_only === true) return declaration;
-        let refs = [...legacyFormatRefsForDeclaration(declaration)];
+        if (declaration.canonical_formats_only === true) {
+          formatOptions.push(declaration);
+          continue;
+        }
+        let refs = ownArrayDataValues(
+          legacyFormatRefsForDeclaration(declaration)
+        );
+        if (emitTransitionalLegacyRefs && refs.length > 0) {
+          const clonedRefs2 = refs.map((ref) => cloneWireData(ref));
+          appendWireLegacyRefs(clonedRefs2);
+          formatOptions.push({ ...declaration, v1_format_ref: clonedRefs2 });
+          continue;
+        }
+        if (declaration.format_kind !== "custom") {
+          formatOptions.push(declaration);
+          continue;
+        }
         if (refs.length === 0) {
           try {
-            refs = resolveCanonicalFormatLegacyRefs(canonicalFormatLegacyResolver, {
+            const resolved = resolveCanonicalFormatLegacyRefs(canonicalFormatLegacyResolver, {
               source: "product",
               declaration,
               productId: declarationOwner,
               field: `${declarationOwner}.format_options[${index}]`
-            }) ?? [];
+            });
+            refs = resolved ? ownArrayDataValues(resolved) : [];
           } catch (error) {
             if (!(error instanceof CanonicalFormatLegacyResolutionError)) throw error;
             throw new CreativeFormatProjectionError(
@@ -560,9 +867,15 @@ function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolve
             "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 };
+        const clonedRefs = refs.map((ref) => cloneWireData(ref));
+        if (emitTransitionalLegacyRefs) appendWireLegacyRefs(clonedRefs);
+        formatOptions.push({ ...declaration, v1_format_ref: clonedRefs });
+      }
+      projected = {
+        ...record,
+        format_options: formatOptions,
+        ...emitTransitionalLegacyRefs && wireLegacyRefs.length > 0 && { format_ids: wireLegacyRefs }
+      };
     }
     let changed = projected !== record;
     const next = { ...projected };
@@ -578,9 +891,18 @@ function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolve
   };
   return visit(value);
 }
-function asProductResponseForWire(canonicalResponse, wireMode, canonicalFormatLegacyResolver) {
+function asProductResponseForWire(canonicalResponse, wireMode, canonicalFormatLegacyResolver, emitTransitionalLegacyRefs = false) {
   if (wireMode === "canonical") {
-    return attachCanonicalCustomFormatWireRefs(canonicalResponse, canonicalFormatLegacyResolver, "get_products");
+    const responseForWire = emitTransitionalLegacyRefs && canonicalResponse !== null && typeof canonicalResponse === "object" ? removeResolvedLegacyDropErrors(
+      canonicalResponse,
+      resolvedLegacyDropDiagnosticsByResponse.get(canonicalResponse) ?? []
+    ) : canonicalResponse;
+    return attachCanonicalFormatWireRefs(
+      responseForWire,
+      canonicalFormatLegacyResolver,
+      "get_products",
+      emitTransitionalLegacyRefs
+    );
   }
   if (!Array.isArray(canonicalResponse.products)) return canonicalResponse;
   const products = canonicalResponse.products.map((product) => {
@@ -2492,7 +2814,8 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               return asProductResponseForWire(
                 canonicalResult,
                 responseWireMode,
-                canonicalFormatLegacyResolver
+                canonicalFormatLegacyResolver,
+                shouldEmitTransitionalDualCreativeWire(ctx.servedAdcpVersion, params)
               );
             };
             const isHandoff = isTaskHandoff(result);
@@ -2714,46 +3037,45 @@ 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) {
-        return adcpError("UNSUPPORTED_FEATURE", {
-          message: "sync_creatives not supported by this sales platform"
-        });
+    ...sales?.syncCreatives && {
+      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(
+          async () => {
+            const push = extractPushConfig(params, logger, {
+              allowPrivateWebhookUrls: pushOpts.allowPrivateWebhookUrls
+            });
+            const result = await sales.syncCreatives(creatives, reqCtx);
+            return routeIfHandoff(
+              taskRegistry,
+              {
+                tool: "sync_creatives",
+                accountId: reqCtx.account.id,
+                ownerScope: taskOwnerScopeFor(ctx, reqCtx.account.id),
+                pushNotificationUrl: push.url,
+                pushNotificationToken: push.token,
+                pushNotificationOperationId: push.operationId,
+                emitWebhook: taskWebhookEmit ?? ctx.emitWebhook,
+                autoEmitCompletion: pushOpts.autoEmitCompletionWebhooks,
+                observability,
+                logger
+              },
+              result,
+              (rows) => asSemanticServerResponseForWire(
+                { creatives: rows.map(normalizeRowErrors) },
+                "sync_creatives",
+                legacyFormatConverter,
+                canonicalFormatLegacyResolver,
+                responseWireMode
+              )
+            );
+          },
+          (r) => r
+        );
       }
-      return projectSync(
-        async () => {
-          const push = extractPushConfig(params, logger, { allowPrivateWebhookUrls: pushOpts.allowPrivateWebhookUrls });
-          const result = await sales.syncCreatives(creatives, reqCtx);
-          return routeIfHandoff(
-            taskRegistry,
-            {
-              tool: "sync_creatives",
-              accountId: reqCtx.account.id,
-              ownerScope: taskOwnerScopeFor(ctx, reqCtx.account.id),
-              pushNotificationUrl: push.url,
-              pushNotificationToken: push.token,
-              pushNotificationOperationId: push.operationId,
-              emitWebhook: taskWebhookEmit ?? ctx.emitWebhook,
-              autoEmitCompletion: pushOpts.autoEmitCompletionWebhooks,
-              observability,
-              logger
-            },
-            result,
-            (rows) => asSemanticServerResponseForWire(
-              { creatives: rows.map(normalizeRowErrors) },
-              "sync_creatives",
-              legacyFormatConverter,
-              canonicalFormatLegacyResolver,
-              responseWireMode
-            )
-          );
-        },
-        (r) => r
-      );
     },
     ...sales?.getMediaBuyDelivery && {
       getMediaBuyDelivery: async (params, ctx) => {
@@ -2836,7 +3158,7 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               "media_buy_id",
               logger
             );
-            const wireResult = responseWireMode === "canonical" ? attachCanonicalCustomFormatWireRefs(canonicalResult, canonicalFormatLegacyResolver, "get_media_buys") : asSemanticServerResponseForWire(
+            const wireResult = responseWireMode === "canonical" ? attachCanonicalFormatWireRefs(canonicalResult, canonicalFormatLegacyResolver, "get_media_buys") : asSemanticServerResponseForWire(
               result,
               "get_media_buys",
               legacyFormatConverter,
@@ -2889,7 +3211,8 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
         const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const canonicalParams = asCanonicalListCreativesRequest(
           params,
-          legacyFormatConverter
+          legacyFormatConverter,
+          responseWireMode
         );
         const reqCtx = ctxFor(ctx, canonicalParams);
         return projectSync(
@@ -3022,7 +3345,8 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
         const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const canonicalParams = asCanonicalListCreativesRequest(
           params,
-          legacyFormatConverter
+          legacyFormatConverter,
+          responseWireMode
         );
         const reqCtx = ctxFor(ctx, canonicalParams);
         return projectSync(