@adcp/sdk 14.0.0-beta.5 → 14.0.0-beta.6

package/dist/lib/media-buy/compatibility.mjs

@@ -135,6 +135,7 @@ const CONTROL_MEDIA_BUY_FIELDS = /* @__PURE__ */ new Set([
   "governance_context",
   "idempotency_key",
   "media_buy_id",
+  "name",
   "pacing",
   "packages",
   "paused",
@@ -449,18 +450,14 @@ function containsCredentialShapedKey(value, seen = /* @__PURE__ */ new WeakSet()
 function containsPresignedUrl(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value === "string") {
     try {
-      const url = new URL(value);
-      const sensitiveQueryKeys = /* @__PURE__ */ new Set([
-        "x-amz-credential",
-        "x-amz-signature",
-        "x-goog-credential",
-        "x-goog-signature",
-        "signature",
-        "sig",
-        "token",
-        "access_token"
-      ]);
-      return [...url.searchParams.keys()].some((key) => sensitiveQueryKeys.has(key.toLowerCase()));
+      const url = new URL(value, "https://adcp-relative.invalid");
+      const signedUrlAliases = /* @__PURE__ */ new Set(["xamzcredential", "xamzsignature", "xgoogcredential", "xgoogsignature", "sig"]);
+      const isSensitiveUrlKey = (key) => {
+        const normalized = key.replace(/[-_]/g, "").toLowerCase();
+        return isCredentialShapedKey(key) || signedUrlAliases.has(normalized);
+      };
+      const fragmentParams = new URLSearchParams(url.hash.startsWith("#") ? url.hash.slice(1) : url.hash);
+      return url.username.length > 0 || url.password.length > 0 || [...url.searchParams.keys()].some(isSensitiveUrlKey) || [...fragmentParams.keys()].some(isSensitiveUrlKey);
     } catch {
       return false;
     }
@@ -538,7 +535,6 @@ function negotiatedVersion(capabilities, clientVersion) {
 }
 const MAX_PROPOSAL_TRAVERSAL_NODES = 4096;
 const LEGACY_PROPOSAL_RAW = /* @__PURE__ */ Symbol("legacyProposalRaw");
-const LEGACY_PURCHASE_CLIENT_SCOPES = /* @__PURE__ */ new WeakMap();
 const COMPACT_REQUEST_PROPOSALS_RESPONSE_FIELDS = /* @__PURE__ */ new Set([
   "adcp_version",
   "outcome",
@@ -1632,7 +1628,7 @@ class MediaBuyLifecycleCoordinator {
     return [
       "feed_version_not_atomic",
       "pricing_version_not_atomic",
-      ...sourceVersion === "2.5" ? ["mutation_idempotency_not_guaranteed"] : []
+      ...sourceVersion === "2.5" || this.idempotencyReplayTtlMs === void 0 ? ["mutation_idempotency_not_guaranteed"] : []
     ];
   }
   legacyPurchaseBinding(accountScope) {
@@ -1640,18 +1636,11 @@ class MediaBuyLifecycleCoordinator {
     const contextId = this.agent.getContextId();
     if (this.resolvedLegacyPurchaseSellerSessionScope === void 0) {
       let sessionScope = this.configuredLegacyPurchaseSellerSessionScope ?? contextId;
-      if (sessionScope === void 0 && this.legacyPurchaseSourceVersion() === "2.5") {
+      if (sessionScope === void 0) {
         throw new ConfigurationError(
-          "Products-only AdCP 2.5 purchase continuations require mediaBuy.legacyPurchaseSellerSessionScope when the seller provides no context ID."
+          "Products-only legacy purchase continuations require legacyPurchaseSellerSessionScope in negotiateMediaBuyLifecycle() when the seller provides no context ID."
         );
       }
-      if (sessionScope === void 0) {
-        sessionScope = LEGACY_PURCHASE_CLIENT_SCOPES.get(this.agent);
-        if (sessionScope === void 0) {
-          sessionScope = randomBytes(32).toString("base64url");
-          LEGACY_PURCHASE_CLIENT_SCOPES.set(this.agent, sessionScope);
-        }
-      }
       this.resolvedLegacyPurchaseSellerSessionScope = sessionScope;
     }
     return {
@@ -3152,10 +3141,11 @@ class MediaBuyLifecycleCoordinator {
     }
     const packages = array(legacyRequest.packages);
     const packageProductIds = packages.map((pkg) => optionalString(record(pkg).product_id));
-    if (packages.length === 0 || packageProductIds.some((productId) => productId === void 0) || new Set(packageProductIds).size !== packageProductIds.length || !exactSet(packageProductIds, selectedProductIds)) {
+    const distinctPackageProductIds = [...new Set(packageProductIds)];
+    if (packages.length === 0 || packageProductIds.some((productId) => productId === void 0) || !exactSet(distinctPackageProductIds, selectedProductIds)) {
       throw new LegacyPurchaseContinuationError(
         "selection_mismatch",
-        "The distinct legacy_create_request package product IDs must exactly match selected_product_ids."
+        "The legacy_create_request package product ID set must exactly match selected_product_ids."
       );
     }
     const observedPricingOptions = /* @__PURE__ */ new Map();
@@ -3198,7 +3188,7 @@ class MediaBuyLifecycleCoordinator {
         `legacy_create_request is invalid for AdCP ${continuation.sourceAdcpVersion}: ${formatIssues(validation.issues)}`
       );
     }
-    const claim = {
+    let claim = {
       idempotencyKey,
       inputFingerprint: requestFingerprint(input),
       operationKey: requestFingerprint({
@@ -3227,7 +3217,8 @@ class MediaBuyLifecycleCoordinator {
       const finalRequest = record(effectiveParams);
       const finalPackages = array(finalRequest.packages);
       const finalProductIds = finalPackages.map((pkg) => optionalString(record(pkg).product_id));
-      if (finalPackages.length === 0 || finalProductIds.some((productId) => productId === void 0) || new Set(finalProductIds).size !== finalProductIds.length || !exactSet(finalProductIds, selectedProductIds)) {
+      const distinctFinalProductIds = [...new Set(finalProductIds)];
+      if (finalPackages.length === 0 || finalProductIds.some((productId) => productId === void 0) || !exactSet(distinctFinalProductIds, selectedProductIds)) {
         throw new LegacyPurchaseContinuationError(
           "selection_mismatch",
           "The final seller payload product IDs must exactly match the continuation selection."
@@ -3257,6 +3248,11 @@ class MediaBuyLifecycleCoordinator {
           "The final seller payload mutation key must match the continuation request."
         );
       }
+      claim = {
+        ...claim,
+        claimedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        replayExpiresAt: new Date(Date.now() + this.legacyPurchaseOperationTtlMs).toISOString()
+      };
       let claimed;
       try {
         claimed = await this.legacyPurchaseContinuationStore.claim(token, {
@@ -3328,8 +3324,37 @@ class MediaBuyLifecycleCoordinator {
         );
       }
       claimedForDispatch = true;
-      return { action: "dispatch_committed" };
+      return {
+        action: "dispatch_committed",
+        onResult: async (result) => {
+          const settled = await this.trackLegacyPurchaseResult(
+            token,
+            claim,
+            result,
+            context.publishSettledTaskStatus,
+            context.registerExternalTaskSettlement,
+            options?.transport
+          );
+          settledInsideExecutor = true;
+          return settled;
+        },
+        onError: async (error) => {
+          settledInsideExecutor = true;
+          if (error instanceof LegacyPurchaseContinuationError) {
+            if (error.code === "ambiguous") {
+              await this.markLegacyPurchaseAmbiguous(token, claim, "create_media_buy_result_invalid");
+            }
+            throw error;
+          }
+          await this.markLegacyPurchaseAmbiguous(token, claim, "create_media_buy_transport_uncertain");
+          throw this.legacyPurchaseAmbiguousError(
+            "The legacy create transport failed after the token was claimed.",
+            error
+          );
+        }
+      };
     };
+    let settledInsideExecutor = false;
     try {
       const result = await this.agent.createMediaBuyLegacyWithPreDispatch(
         legacyRequest,
@@ -3342,9 +3367,11 @@ class MediaBuyLifecycleCoordinator {
         }
       );
       if (!claimedForDispatch) return result;
-      return this.trackLegacyPurchaseResult(token, claim, result);
+      if (settledInsideExecutor) return result;
+      return this.trackLegacyPurchaseResult(token, claim, result, void 0, void 0, options?.transport);
     } catch (error) {
       if (!claimedForDispatch) throw error;
+      if (settledInsideExecutor) throw error;
       if (error instanceof LegacyPurchaseContinuationError) {
         if (error.code === "ambiguous") {
           await this.markLegacyPurchaseAmbiguous(token, claim, "create_media_buy_result_invalid");
@@ -3438,21 +3465,96 @@ class MediaBuyLifecycleCoordinator {
     } catch {
     }
   }
-  async trackLegacyPurchaseResult(token, claim, result) {
+  async trackLegacyPurchaseResult(token, claim, result, publishSettledTaskStatus, registerExternalTaskSettlement, settlementTransport) {
     if (result.status === "completed" || result.status === "failed" || result.status === "governance-denied") {
-      if (result.status === "failed" && result.adcpError === void 0) {
+      if (result.status === "failed" && (result.adcpError === void 0 || result.adcpError.synthetic === true)) {
         await this.markLegacyPurchaseAmbiguous(token, claim, "create_media_buy_failure_not_authoritative");
         throw this.legacyPurchaseAmbiguousError(
           "The legacy create failure was not an authoritative structured AdCP error."
         );
       }
-      const terminal = this.assertLegacyPurchaseTerminalResult(result, this.legacyPurchaseSourceVersion());
+      let terminal;
+      try {
+        terminal = this.assertLegacyPurchaseTerminalResult(result, this.legacyPurchaseSourceVersion());
+      } catch (error) {
+        if (error instanceof LegacyPurchaseContinuationError && error.code === "ambiguous") {
+          await this.markLegacyPurchaseAmbiguous(token, claim, "create_media_buy_result_invalid");
+        }
+        throw error;
+      }
       return attachMatch(await this.completeLegacyPurchase(token, claim, terminal));
     }
-    if (result.submitted) {
-      const submitted = result.submitted;
+    const settlementMetadata = {
+      taskId: result.metadata.taskId,
+      taskName: result.metadata.taskName,
+      agent: { ...result.metadata.agent },
+      responseTimeMs: result.metadata.responseTimeMs,
+      timestamp: result.metadata.timestamp,
+      clarificationRounds: result.metadata.clarificationRounds,
+      status: result.metadata.status,
+      ...result.metadata.contextId !== void 0 && { contextId: result.metadata.contextId },
+      ...(result.submitted?.taskId ?? result.metadata.serverTaskId ?? claim.sellerTaskId) !== void 0 && {
+        serverTaskId: result.submitted?.taskId ?? result.metadata.serverTaskId ?? claim.sellerTaskId
+      },
+      ...result.metadata.idempotency_key !== void 0 && { idempotency_key: result.metadata.idempotency_key },
+      ...result.metadata.replayed !== void 0 && { replayed: result.metadata.replayed },
+      ...result.metadata.adcpVersion !== void 0 && { adcpVersion: result.metadata.adcpVersion }
+    };
+    const failureFieldsFromTask = (task) => {
+      const extracted = extractAdcpErrorInfo(task.result);
+      const adcpError = extracted?.synthetic === true ? void 0 : extracted;
+      const correlationId = extractCorrelationId(task.result);
+      return {
+        // tasks/get and webhook free text are not durable-safe boundaries.
+        // Preserve a structured AdCP message when present; otherwise replay a
+        // generic error while retaining the seller payload for inspection.
+        error: adcpError?.message ?? "Legacy create failed.",
+        ...adcpError !== void 0 && { adcpError },
+        ...correlationId !== void 0 && { correlationId }
+      };
+    };
+    const resultFromTask = (task) => {
+      const metadata = {
+        ...settlementMetadata,
+        taskName: task.taskType,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (task.status === "completed" && task.result !== void 0 && isAdcpOperationSuccess(task.result, task.taskType)) {
+        return attachMatch({
+          success: true,
+          status: "completed",
+          data: task.result,
+          metadata: { ...metadata, status: "completed" }
+        });
+      }
+      if (task.status === "unknown") {
+        throw this.legacyPurchaseAmbiguousError(
+          "tasks/get returned an unrecognizable response for the submitted legacy purchase."
+        );
+      }
+      if (["completed", "failed", "rejected", "canceled", "governance-denied"].includes(task.status)) {
+        const status = task.status === "governance-denied" ? "governance-denied" : "failed";
+        return attachMatch({
+          success: false,
+          status,
+          ...failureFieldsFromTask(task),
+          ...task.result !== void 0 && { data: task.result },
+          metadata: { ...metadata, status }
+        });
+      }
+      if (task.status === "input-required" || task.status === "auth-required") {
+        return attachMatch({
+          success: true,
+          status: task.status,
+          ...task.result !== void 0 && { data: task.result },
+          metadata: { ...metadata, status: task.status }
+        });
+      }
+      return void 0;
+    };
+    const bindSellerTask = async (sellerTaskId) => {
       try {
-        const recorded = await this.legacyPurchaseContinuationStore.recordSubmittedTask(token, claim, submitted.taskId);
+        const recorded = await this.legacyPurchaseContinuationStore.recordSubmittedTask(token, claim, sellerTaskId);
         if (!recorded) {
           await this.markLegacyPurchaseAmbiguous(token, claim, "submitted_task_persistence_failed");
           throw this.legacyPurchaseAmbiguousError("Could not durably bind the submitted seller task.");
@@ -3462,32 +3564,128 @@ class MediaBuyLifecycleCoordinator {
         await this.markLegacyPurchaseAmbiguous(token, claim, "submitted_task_persistence_failed");
         throw this.legacyPurchaseAmbiguousError("Could not durably bind the submitted seller task.", error);
       }
-      const failureFieldsFromTask = (task) => {
-        const adcpError = extractAdcpErrorInfo(task.result);
-        const correlationId = extractCorrelationId(task.result);
-        return {
-          // tasks/get free text is not a durable-safe boundary. Preserve a
-          // structured AdCP message when present; otherwise replay a generic
-          // error while retaining the seller payload in data for inspection.
-          error: adcpError?.message ?? "Legacy create failed.",
-          ...adcpError !== void 0 && { adcpError },
-          ...correlationId !== void 0 && { correlationId }
-        };
-      };
+      registerExternalTaskSettlement?.(async (observation) => {
+        try {
+          if (observation.serverTaskId !== sellerTaskId) {
+            throw this.legacyPurchaseAmbiguousError(
+              "The pushed seller task ID does not match the durably recorded submitted task."
+            );
+          }
+          if (observation.taskType !== "create_media_buy") {
+            throw this.legacyPurchaseAmbiguousError("The pushed seller task has the wrong task identity.");
+          }
+          const task = {
+            taskId: sellerTaskId,
+            taskType: observation.taskType,
+            status: observation.status,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            ...observation.result !== void 0 && { result: observation.result }
+          };
+          const observed = resultFromTask(task);
+          if (!observed || !["completed", "failed", "governance-denied"].includes(observed.status)) {
+            throw this.legacyPurchaseAmbiguousError(
+              "The pushed legacy create status was not an authoritative terminal result."
+            );
+          }
+          return await this.trackLegacyPurchaseResult(
+            token,
+            claim,
+            observed,
+            publishSettledTaskStatus,
+            registerExternalTaskSettlement,
+            settlementTransport
+          );
+        } catch (error) {
+          if (error instanceof LegacyPurchaseContinuationError && error.code === "ambiguous") {
+            await this.markLegacyPurchaseAmbiguous(token, claim, "pushed_task_result_invalid");
+          }
+          throw error;
+        }
+      });
+    };
+    if (result.status === "working" || result.status === "input-required" || result.status === "auth-required") {
+      const sellerTaskId = result.metadata.serverTaskId;
+      if (!sellerTaskId) {
+        await this.markLegacyPurchaseAmbiguous(token, claim, "paused_task_identity_missing");
+        throw this.legacyPurchaseAmbiguousError(
+          "The non-terminal legacy create response did not provide a durable seller task identity."
+        );
+      }
+      await bindSellerTask(sellerTaskId);
+      if (result.status !== "working") return attachMatch(result);
+      const watchSignal = AbortSignal.timeout(Math.min(this.legacyPurchaseOperationTtlMs, 5 * 60 * 1e3));
+      const waitForWorkingPoll = () => new Promise((resolve, reject) => {
+        if (watchSignal.aborted) {
+          reject(createAbortError(watchSignal.reason));
+          return;
+        }
+        const timer = setTimeout(finish, 6e4);
+        const abort = () => finish(createAbortError(watchSignal.reason));
+        watchSignal.addEventListener("abort", abort, { once: true });
+        function finish(error) {
+          clearTimeout(timer);
+          watchSignal.removeEventListener("abort", abort);
+          if (error) reject(error);
+          else resolve();
+        }
+      });
+      void new Promise((resolve) => setTimeout(resolve, 0)).then(async () => {
+        while (!watchSignal.aborted) {
+          const task = await this.agent.getTaskStatus(sellerTaskId, settlementTransport, watchSignal);
+          if (task.taskId !== sellerTaskId || task.taskType !== "create_media_buy") {
+            throw this.legacyPurchaseAmbiguousError(
+              "The polled working seller task does not match the durably recorded create_media_buy task."
+            );
+          }
+          const observed = resultFromTask(task);
+          if (observed) {
+            return this.trackLegacyPurchaseResult(
+              token,
+              claim,
+              observed,
+              publishSettledTaskStatus,
+              registerExternalTaskSettlement,
+              settlementTransport
+            );
+          }
+          await waitForWorkingPoll();
+        }
+        throw createAbortError(watchSignal.reason);
+      }).then((completion) => {
+        publishSettledTaskStatus?.(completion.status, completion.data, completion.error);
+      }).catch(async (error) => {
+        if (watchSignal.aborted || isAbortOrTimeoutError(error)) return;
+        await this.markLegacyPurchaseAmbiguous(token, claim, "non_terminal_completion_watch_uncertain");
+        void error;
+      });
+      return attachMatch(result);
+    }
+    if (result.submitted) {
+      const submitted = result.submitted;
+      await bindSellerTask(submitted.taskId);
       const observeTask = async (transport, observationSignal) => {
         try {
           const task = observationSignal ? await withAbortSignal([observationSignal], void 0, () => submitted.track(transport)) : await submitted.track(transport);
+          if (task.taskId !== submitted.taskId) {
+            throw this.legacyPurchaseAmbiguousError(
+              "The tracked seller task ID does not match the durably recorded submitted task."
+            );
+          }
+          if (task.taskType !== "create_media_buy") {
+            throw this.legacyPurchaseAmbiguousError("The tracked seller task has the wrong task identity.");
+          }
           if (["completed", "failed", "rejected", "canceled", "governance-denied"].includes(task.status)) {
-            if (task.taskType !== "create_media_buy") {
-              throw this.legacyPurchaseAmbiguousError("The tracked seller task has the wrong task identity.");
-            }
             if (task.status === "completed" && task.result === void 0) {
               throw this.legacyPurchaseAmbiguousError(
                 "The tracked seller task reported completion without a create_media_buy result."
               );
             }
             const completedSuccessfully = task.status === "completed" && isAdcpOperationSuccess(task.result, task.taskType);
-            if (!completedSuccessfully && task.status !== "governance-denied" && extractAdcpErrorInfo(task.result) === void 0) {
+            if (!completedSuccessfully && task.status !== "governance-denied" && (() => {
+              const adcpError = extractAdcpErrorInfo(task.result);
+              return adcpError === void 0 || adcpError.synthetic === true;
+            })()) {
               throw this.legacyPurchaseAmbiguousError(
                 "The tracked legacy create failure was not an authoritative structured AdCP error."
               );
@@ -3501,7 +3699,7 @@ class MediaBuyLifecycleCoordinator {
                   ...task.result !== void 0 && { data: task.result }
                 },
                 metadata: {
-                  ...result.metadata,
+                  ...settlementMetadata,
                   status: completedSuccessfully ? "completed" : task.status === "governance-denied" ? "governance-denied" : "failed",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 }
@@ -3531,45 +3729,6 @@ class MediaBuyLifecycleCoordinator {
           throw this.legacyPurchaseAmbiguousError("Legacy create task tracking failed after claim.", error);
         }
       };
-      const resultFromTask = (task) => {
-        const metadata = {
-          ...result.metadata,
-          taskName: task.taskType,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (task.status === "completed" && task.result !== void 0 && isAdcpOperationSuccess(task.result, task.taskType)) {
-          return attachMatch({
-            success: true,
-            status: "completed",
-            data: task.result,
-            metadata: { ...metadata, status: "completed" }
-          });
-        }
-        if (task.status === "unknown") {
-          throw this.legacyPurchaseAmbiguousError(
-            "tasks/get returned an unrecognizable response for the submitted legacy purchase."
-          );
-        }
-        if (["completed", "failed", "rejected", "canceled", "governance-denied"].includes(task.status)) {
-          const status = task.status === "governance-denied" ? "governance-denied" : "failed";
-          return attachMatch({
-            success: false,
-            status,
-            ...failureFieldsFromTask(task),
-            ...task.result !== void 0 && { data: task.result },
-            metadata: { ...metadata, status }
-          });
-        }
-        if (task.status === "input-required" || task.status === "auth-required") {
-          return attachMatch({
-            success: true,
-            status: task.status,
-            ...task.result !== void 0 && { data: task.result },
-            metadata: { ...metadata, status: task.status }
-          });
-        }
-        return void 0;
-      };
       const waitForNextPoll = (state, signal) => new Promise((resolve, reject) => {
         if (signal.aborted) {
           reject(createAbortError(signal.reason));
@@ -3591,9 +3750,18 @@ class MediaBuyLifecycleCoordinator {
       const pollTrackedCompletion = async (state, signal) => {
         while (true) {
           if (signal.aborted) throw createAbortError(signal.reason);
-          const task = await observeTask(void 0, signal);
+          const task = await observeTask(settlementTransport, signal);
           const observed = resultFromTask(task);
-          if (observed) return this.trackLegacyPurchaseResult(token, claim, observed);
+          if (observed) {
+            return this.trackLegacyPurchaseResult(
+              token,
+              claim,
+              observed,
+              publishSettledTaskStatus,
+              registerExternalTaskSettlement,
+              settlementTransport
+            );
+          }
           await waitForNextPoll(state, signal);
         }
       };
@@ -3669,7 +3837,9 @@ class MediaBuyLifecycleCoordinator {
         }
       };
       const watchSignal = AbortSignal.timeout(Math.min(this.legacyPurchaseOperationTtlMs, 5 * 60 * 1e3));
-      void new Promise((resolve) => setTimeout(resolve, 0)).then(() => waitForSharedCompletion(void 0, watchSignal)).catch(async (error) => {
+      void new Promise((resolve) => setTimeout(resolve, 0)).then(() => waitForSharedCompletion(void 0, watchSignal)).then((completion) => {
+        publishSettledTaskStatus?.(completion.status, completion.data, completion.error);
+      }).catch(async (error) => {
         if (watchSignal.aborted || isAbortOrTimeoutError(error)) return;
         await this.markLegacyPurchaseAmbiguous(token, claim, "background_completion_watch_uncertain");
         void error;
@@ -3681,7 +3851,14 @@ class MediaBuyLifecycleCoordinator {
         ...deferred,
         resume: async (resumeInput) => {
           try {
-            return await this.trackLegacyPurchaseResult(token, claim, await deferred.resume(resumeInput));
+            return await this.trackLegacyPurchaseResult(
+              token,
+              claim,
+              await deferred.resume(resumeInput),
+              publishSettledTaskStatus,
+              registerExternalTaskSettlement,
+              settlementTransport
+            );
           } catch (error) {
             if (error instanceof LegacyPurchaseContinuationError) {
               if (error.code === "ambiguous") {
@@ -4639,6 +4816,25 @@ class MediaBuyLifecycleCoordinator {
     const input = record(params);
     const lifecycle = this.selectLifecycle("control_media_buy");
     this.assertLegacyReferenceShapes("controlMediaBuy", input);
+    const canceledControlConflicts = [
+      "name",
+      "paused",
+      "total_budget",
+      "daily_budget_cap",
+      "budget_cap_timezone",
+      "budget_allocation",
+      "pacing",
+      "bidding",
+      "packages",
+      "reporting_webhook"
+    ];
+    if (Object.hasOwn(input, "canceled") && canceledControlConflicts.some((field) => Object.hasOwn(input, field))) {
+      throw this.unsupported(
+        "controlMediaBuy",
+        "canceled",
+        "Compact media-buy cancellation cannot be combined with other operational controls."
+      );
+    }
     if (lifecycle === "compact") {
       this.assertValidCompactRequest("control_media_buy", params, lifecycle, true);
       const result2 = await this.agent.controlMediaBuy(params, inputHandler, options);
@@ -4656,6 +4852,9 @@ class MediaBuyLifecycleCoordinator {
       "bidding",
       "governance_context"
     ]);
+    if (!isCompactRelease(this.negotiated_version)) {
+      this.assertCompactWireFieldsAbsent("controlMediaBuy", input, ["name"]);
+    }
     if (compareRelease(this.negotiated_version, "3.0") < 0) {
       this.assertCompactWireFieldsAbsent("controlMediaBuy", input, ["reporting_webhook"]);
     }
@@ -4851,29 +5050,12 @@ class MediaBuyLifecycleCoordinator {
         "Compact media-buy cancellation_reason requires canceled=true."
       );
     }
-    const canceledControlConflicts = [
-      "paused",
-      "total_budget",
-      "daily_budget_cap",
-      "budget_cap_timezone",
-      "budget_allocation",
-      "pacing",
-      "bidding",
-      "packages",
-      "reporting_webhook"
-    ];
-    if (Object.hasOwn(input, "canceled") && canceledControlConflicts.some((field) => Object.hasOwn(input, field))) {
-      throw this.unsupported(
-        "controlMediaBuy",
-        "canceled",
-        "Compact media-buy cancellation cannot be combined with other operational controls."
-      );
-    }
     const request = {
       account: input.account,
       media_buy_id: input.media_buy_id,
       ...input.idempotency_key !== void 0 && { idempotency_key: input.idempotency_key },
       revision: input.revision,
+      ...input.name !== void 0 && { name: input.name },
       ...input.paused !== void 0 && { paused: input.paused },
       ...input.canceled !== void 0 && { canceled: input.canceled },
       ...input.cancellation_reason !== void 0 && { cancellation_reason: input.cancellation_reason },