@adcp/sdk 16.4.0 → 16.6.0

package/dist/lib/testing/storyboard/seeding.d.mts

@@ -72,6 +72,8 @@ export interface ControllerSeedingResult {
     seedUnsupported?: boolean;
     /** At least one declared strategy ladder exhausted without a binding. */
     fixtureUnsatisfied?: boolean;
+    /** Runner exhausted its bounded attempts to enumerate a stable feed. */
+    fixtureUnavailable?: string;
     /** Run-scoped bindings pinned for all subsequent storyboard phases. */
     bindings?: FixtureBindingRegistry;
     /** Machine-readable AdCP 3.2 resolution evidence. */

package/dist/lib/testing/storyboard/seeding.d.ts

@@ -72,6 +72,8 @@ export interface ControllerSeedingResult {
     seedUnsupported?: boolean;
     /** At least one declared strategy ladder exhausted without a binding. */
     fixtureUnsatisfied?: boolean;
+    /** Runner exhausted its bounded attempts to enumerate a stable feed. */
+    fixtureUnavailable?: string;
     /** Run-scoped bindings pinned for all subsequent storyboard phases. */
     bindings?: FixtureBindingRegistry;
     /** Machine-readable AdCP 3.2 resolution evidence. */

package/dist/lib/testing/storyboard/seeding.js

@@ -27,12 +27,16 @@ var import_client = require('../client.js');
 var import_schema_loader = require('../../validation/schema-loader.js');
 var import_version = require('../../version.js');
 var import_envelope_status_compat = require('../../utils/envelope-status-compat.js');
+var import_response_unwrapper = require('../../utils/response-unwrapper.js');
 var import_test_controller = require('../test-controller.js');
 var import_task_map = require('./task-map.js');
+var import_rawResponseCapture = require('../../protocols/rawResponseCapture.js');
 var import_fixture_resolution = require('./fixture-resolution.js');
 var import_collection_selection = require('./collection-selection.js');
 var import_path = require('./path.js');
 var import_redact_secrets = require('../../utils/redact-secrets.js');
+var import_discovery_evidence = require('../discovery-evidence.js');
+var import_redact_credential_patterns = require('../../utils/redact-credential-patterns.js');
 const CONTROLLER_SEEDING_PHASE_ID = "__controller_seeding__";
 function buildSeedCalls(fixtures) {
   if (!fixtures) return [];
@@ -482,6 +486,8 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
   let passedCount = 0;
   let failedCount = 0;
   let fixtureUnsatisfied = false;
+  let fixtureUnavailable;
+  const unavailableResolutions = /* @__PURE__ */ new Set();
   for (const call of orderedCalls) {
     const spec = resolutionSpecForCall(call, specByKey);
     if (!spec) {
@@ -510,6 +516,9 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
     const attempts = [];
     let boundIds;
     let chosenStrategy;
+    let attemptedStrategy;
+    let discoveryFailureEvidence;
+    let discoverySchemaFailure;
     let failure;
     const stepStart = Date.now();
     const parentStatus = spec.parentProductHandle ? productStatuses.get(spec.parentProductHandle) : void 0;
@@ -518,7 +527,13 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
       const strategy = spec.strategies[0];
       const detail = parentStatus === "failed" ? `parent product handle "${spec.parentProductHandle}" failed resolution` : `parent product handle "${spec.parentProductHandle}" is unavailable`;
       attempts.push({ strategy, disposition: parentStatus === "failed" ? "failed" : "unavailable", detail });
-      if (parentStatus === "failed") failure = detail;
+      if (parentStatus === "failed") {
+        failure = detail;
+        if (spec.parentProductHandle && unavailableResolutions.has(
+          resolutionSpecKey({ ...spec, entityType: "product", handle: spec.parentProductHandle })
+        ))
+          unavailableResolutions.add(resolutionSpecKey(spec));
+      }
     }
     for (const strategy of parentUnavailable ? [] : spec.strategies) {
       if (strategy === "seed") {
@@ -532,6 +547,7 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
           });
           continue;
         }
+        attemptedStrategy = strategy;
         try {
           const controllerRequest = (0, import_fixture_resolution.applyFixtureBindingsToRequest)(
             { scenario: call.scenario, params: call.params },
@@ -632,10 +648,22 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
           });
           continue;
         }
+        attemptedStrategy = strategy;
         const discovered = await catalog();
         if (!discovered.ok) {
           failure = discovered.error;
-          attempts.push({ strategy, disposition: "failed", detail: failure, response: discovered.evidence });
+          if (discovered.unavailable) {
+            fixtureUnavailable = discovered.error;
+            unavailableResolutions.add(resolutionSpecKey(spec));
+          }
+          discoveryFailureEvidence = discovered.exchange;
+          discoverySchemaFailure = discovered.schemaFailure;
+          attempts.push({
+            strategy,
+            disposition: discovered.unavailable ? "unavailable" : "failed",
+            detail: failure,
+            response: discovered.evidence
+          });
           break;
         }
         const selected = selectDiscoveredFixture(
@@ -708,6 +736,9 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
       requirements: spec.clauses,
       strategies_attempted: attempts,
       status,
+      ...unavailableResolutions.has(resolutionSpecKey(spec)) && {
+        unavailable_reason: "runner_budget_exhausted"
+      },
       ...chosenStrategy && { strategy: chosenStrategy },
       ...boundIds && { seller_ids: boundIds }
     };
@@ -719,8 +750,20 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
         step_id: call.step_id,
         phase_id: CONTROLLER_SEEDING_PHASE_ID,
         title: call.title,
-        task: chosenStrategy === "discover" ? "get_products" : "comply_test_controller",
-        passed: status !== "failed",
+        // The task that ACTUALLY ran, else the one this handle declared.
+        // Falling back to the controller whenever no strategy RESOLVED
+        // attributed a failed discover-only handle to a seed call that
+        // never happened — and a handle abandoned because its parent
+        // failed makes no call at all, so it is named by the strategy it
+        // declared rather than by a different tool. Such a step carries
+        // no request record, so nothing implies a call was made.
+        task: (chosenStrategy ?? attemptedStrategy ?? spec.strategies[0]) === "discover" ? "get_products" : "comply_test_controller",
+        passed: status !== "failed" || unavailableResolutions.has(resolutionSpecKey(spec)),
+        ...unavailableResolutions.has(resolutionSpecKey(spec)) && {
+          skipped: true,
+          skip_reason: "not_applicable",
+          skip: { reason: "not_applicable", detail: fixtureUnavailable ?? failure }
+        },
         duration_ms: Date.now() - stepStart,
         // An unbuildable capture gets a `check` discriminator like the other
         // two failure classes, so a report renderer keys on `check` for all
@@ -744,15 +787,41 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
             schema_url: null,
             ...captureFailures.get(spec.handle)?.exchange ?? {}
           }
+        ] : discoverySchemaFailure !== void 0 ? [
+          // A page that parsed but failed its response schema is a
+          // `response_schema` failure, not a capture failure. Using
+          // the contract's own kind keeps the schema identity where
+          // consumers already look for it.
+          {
+            check: "response_schema",
+            passed: false,
+            description: "Fixture discovery response must satisfy the get_products response schema",
+            error: discoverySchemaFailure.detail,
+            json_pointer: null,
+            schema_id: discoverySchemaFailure.schema_id,
+            schema_url: discoverySchemaFailure.schema_url,
+            expected: discoverySchemaFailure.schema_id,
+            actual: "schema_validation_failed",
+            ...discoveryFailureEvidence && {
+              request: discoveryFailureEvidence.request,
+              response: discoveryFailureEvidence.response
+            }
+          }
         ] : [],
         context,
-        extraction: { path: "none" },
+        extraction: discoveryFailureEvidence?.extraction ?? { path: "none" },
+        // The REAL exchange the failing strategy made. Absent rather than
+        // invented when the strategy never reached the wire.
+        ...discoveryFailureEvidence && {
+          request: discoveryFailureEvidence.request,
+          ...discoveryFailureEvidence.response && { response_record: discoveryFailureEvidence.response }
+        },
         ...failure && { error: failure }
       });
     }
-    if (status === "failed") failedCount++;
+    if (status === "failed" && !unavailableResolutions.has(resolutionSpecKey(spec))) failedCount++;
     else if (status === "unsatisfied") fixtureUnsatisfied = true;
-    else passedCount++;
+    else if (status === "resolved") passedCount++;
   }
   const allPassed = failedCount === 0;
   const graphComplete = allPassed && !fixtureUnsatisfied && captureFailure === void 0 && records.every((r) => r.status === "resolved");
@@ -784,6 +853,7 @@ async function runDeclaredFixtureResolution(seedClient, discoveryClient, storybo
     passedCount,
     failedCount,
     fixtureUnsatisfied,
+    ...fixtureUnavailable && { fixtureUnavailable },
     bindings,
     resolutionRecords: records,
     ...preparedCaptures && { preparedCaptures }
@@ -945,6 +1015,29 @@ async function executeLegacySeedCall(client, storyboard, call, options, context,
     };
   }
 }
+function resolveDiscoverySchemaIdentity(adcpVersion) {
+  const schemaId = `/schemas/${adcpVersion}/media-buy/get-products-response.json`;
+  return { schema_id: schemaId, schema_url: `https://adcontextprotocol.org${schemaId}` };
+}
+function describeDiscoverySchemaFailure(data, options) {
+  try {
+    const version = options.adcpVersion ?? import_version.ADCP_VERSION;
+    const validator = (0, import_schema_loader.getValidator)("get_products", "sync", version);
+    let detail;
+    if (validator) {
+      const schemaData = isPlainRecord(data) ? (0, import_envelope_status_compat.injectLegacyEnvelopeStatus)(data, { toolName: "get_products" }) : data;
+      if (validator(schemaData)) return void 0;
+      detail = (validator.errors ?? []).map((error) => `${error.instancePath || "/"} ${error.message ?? error.keyword}`).join("; ");
+    } else {
+      const schema = (0, import_client.validateResponseSchema)("get_products", data, options.adcpVersion);
+      if (schema.passed) return void 0;
+      detail = schema.error ?? schema.details ?? "schema validation failed";
+    }
+    return { error: detail, schemaFailure: { detail, ...resolveDiscoverySchemaIdentity(version) } };
+  } catch (err) {
+    return { error: `response schema unavailable: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
 async function discoverProductCatalog(client, options, context) {
   const contextAccount = isPlainRecord(context.account) ? context.account : void 0;
   const baseAccount = contextAccount ?? (0, import_client.resolveAccount)(options);
@@ -960,89 +1053,212 @@ async function discoverProductCatalog(client, options, context) {
   const seenCursors = /* @__PURE__ */ new Set();
   let cursor;
   let pageCount = 0;
+  let restarts = 0;
+  let feedIdentity;
+  const query = structuredClone({
+    buying_mode: "wholesale",
+    brand,
+    account,
+    ext: { adcp: { creative_wire: "canonical" } }
+  });
+  let lastExchange;
   const exchanges = [];
   const pageOfProduct = /* @__PURE__ */ new Map();
-  do {
+  while (true) {
+    options.signal?.throwIfAborted();
     if (pageCount >= 1e3) {
-      return { ok: false, error: "fixture discovery pagination exceeded the 1,000-page safety limit" };
+      return {
+        ok: false,
+        unavailable: true,
+        evidence: { page_count: pageCount, restart_count: restarts },
+        ...lastExchange && { exchange: lastExchange },
+        error: "fixture discovery pagination exceeded the runner\u2019s 1,000-page safety limit"
+      };
     }
     const request = {
-      buying_mode: "wholesale",
-      brand,
-      account,
-      pagination: { max_results: 100, ...cursor && { cursor } },
-      // Fixture match declarations target the canonical product shape.
-      ext: { adcp: { creative_wire: "canonical" } }
+      ...structuredClone(query),
+      pagination: { max_results: 100, ...cursor && { cursor } }
     };
     let result;
+    let observedResponse;
+    const toolResponse = (captures) => [...captures].reverse().find((capture) => capture.requestAdcpSkill === "get_products");
     const pageStart = Date.now();
+    const requestRecord = {
+      transport: options.protocol === "a2a" ? "a2a" : "mcp",
+      operation: "get_products",
+      payload: (0, import_redact_secrets.redactSecrets)(request)
+    };
     try {
-      result = await (0, import_task_map.executeStoryboardTask)(client, "get_products", request, { signal: options.signal });
+      if (options.protocol === "a2a") {
+        const captured = await (0, import_rawResponseCapture.withRawResponseCapture)(
+          () => (0, import_task_map.executeStoryboardTask)(client, "get_products", request, { signal: options.signal }),
+          { maxBodyBytes: 65536, maxCaptures: 8, maxTotalBodyBytes: 262144 }
+        );
+        result = captured.result;
+        observedResponse = toolResponse(captured.captures);
+      } else {
+        result = await (0, import_task_map.executeStoryboardTask)(client, "get_products", request, { signal: options.signal });
+      }
     } catch (err) {
+      const observed = toolResponse((0, import_rawResponseCapture.getCapturesFromError)(err) ?? []);
       return {
         ok: false,
-        error: `fixture discovery transport failure: ${err instanceof Error ? err.message : String(err)}`
+        error: `fixture discovery transport failure: ${(0, import_redact_credential_patterns.redactCredentialPatterns)(err instanceof Error ? err.message : String(err), false)}`,
+        evidence: { page_count: pageCount + 1, request: requestRecord.payload },
+        // Explicitly null: no response was received. Not a placeholder.
+        exchange: {
+          request: requestRecord,
+          response: observed ? {
+            transport: requestRecord.transport,
+            payload: (0, import_discovery_evidence.redactDiscoveryEvidence)(observed.body),
+            status: observed.status,
+            duration_ms: Date.now() - pageStart
+          } : null
+        }
       };
     }
     pageCount++;
+    let wireResponse = result.debug_logs?.slice().reverse().find(
+      (log) => typeof log.message === "string" && (log.message.startsWith("MCP: Tool get_products response received") || log.message.startsWith("A2A: Response received")) && log.response !== void 0
+    )?.response;
+    if (wireResponse === void 0 && observedResponse && !observedResponse.bodyTruncated) {
+      try {
+        wireResponse = JSON.parse(observedResponse.body);
+      } catch {
+      }
+    }
+    if ((!result.success || result.data === void 0) && result._extraction_path === void 0 && observedResponse === void 0 && wireResponse === void 0) {
+      return {
+        ok: false,
+        error: `fixture discovery get_products rejected: ${(0, import_redact_credential_patterns.redactCredentialPatterns)(result.error ?? result.adcp_error?.code ?? "unknown error", false)}`,
+        evidence: { page_count: pageCount, request: requestRecord.payload },
+        exchange: { request: requestRecord, response: null }
+      };
+    }
+    const extraction = {
+      path: result._extraction_path ?? "none",
+      ...observedResponse?.bodyTruncated && { note: "Raw HTTP response capture was truncated at its body budget." }
+    };
+    const failedExchange = {
+      request: requestRecord,
+      extraction,
+      response: {
+        transport: requestRecord.transport,
+        payload: (0, import_discovery_evidence.redactDiscoveryEvidence)(wireResponse ?? observedResponse?.body ?? result.data),
+        ...observedResponse && { status: observedResponse.status },
+        duration_ms: Date.now() - pageStart
+      }
+    };
+    lastExchange = failedExchange;
     const retainResponse = exchanges.length < DISCOVERY_RETAINED_RESPONSE_PAGES;
     const pageIndex = exchanges.push({
-      request: { transport: "mcp", operation: "get_products", payload: (0, import_redact_secrets.redactSecrets)(request) },
-      response: {
-        transport: "mcp",
-        payload: retainResponse ? (0, import_redact_secrets.redactSecrets)(
-          result.data ?? (result.adcp_error ? { adcp_error: result.adcp_error } : void 0) ?? result.error ?? null
-        ) : {
+      request: requestRecord,
+      response: retainResponse ? { ...failedExchange.response, payload: (0, import_redact_secrets.redactSecrets)(result.data) } : {
+        transport: requestRecord.transport,
+        payload: {
           response_not_retained: `page ${exchanges.length + 1} is past the runner's ${DISCOVERY_RETAINED_RESPONSE_PAGES}-page discovery-evidence budget; the request for this page is recorded in full`
         },
         duration_ms: Date.now() - pageStart
       }
     }) - 1;
+    let schemaData = result.success ? result.data : void 0;
+    if (!result.success && wireResponse !== void 0 && result._extraction_path !== "error") {
+      try {
+        schemaData = (0, import_response_unwrapper.unwrapProtocolResponse)(wireResponse, void 0, options.protocol === "a2a" ? "a2a" : "mcp");
+        extraction.path = (0, import_response_unwrapper.readExtractionPath)(schemaData) ?? extraction.path;
+      } catch {
+        schemaData = void 0;
+      }
+    }
+    const nativeResult = isPlainRecord(wireResponse) && isPlainRecord(wireResponse.result) ? wireResponse.result : void 0;
+    const nativeState = nativeResult && isPlainRecord(nativeResult.status) ? nativeResult.status.state : void 0;
+    const sellerRejected = result._extraction_path === "error" || isPlainRecord(schemaData) && (schemaData.adcp_error !== void 0 || schemaData.status === "failed" || schemaData.status === "rejected") || nativeState === "failed" || nativeState === "rejected" || nativeState === "canceled";
+    const schemaCheck = sellerRejected || schemaData === void 0 ? void 0 : describeDiscoverySchemaFailure(schemaData, options);
     if (!result.success) {
       return {
         ok: false,
-        error: `fixture discovery get_products rejected: ${result.error ?? result.adcp_error?.code ?? "unknown error"}`,
-        evidence: { page_count: pageCount, request }
+        error: `fixture discovery get_products rejected: ${(0, import_redact_credential_patterns.redactCredentialPatterns)(result.error ?? result.adcp_error?.code ?? "unknown error", false)}`,
+        evidence: { page_count: pageCount, request: requestRecord.payload },
+        exchange: failedExchange,
+        ...schemaCheck?.schemaFailure && { schemaFailure: schemaCheck.schemaFailure }
       };
     }
-    let schemaFailure;
-    try {
-      const validator = (0, import_schema_loader.getValidator)("get_products", "sync", options.adcpVersion ?? import_version.ADCP_VERSION);
-      if (validator) {
-        const responseData = result.data;
-        const schemaData = isPlainRecord(responseData) ? (0, import_envelope_status_compat.injectLegacyEnvelopeStatus)(responseData, { toolName: "get_products" }) : responseData;
-        if (!validator(schemaData)) {
-          schemaFailure = (validator.errors ?? []).map((error) => `${error.instancePath || "/"} ${error.message ?? error.keyword}`).join("; ");
-        }
-      } else {
-        const schema = (0, import_client.validateResponseSchema)("get_products", result.data, options.adcpVersion);
-        if (!schema.passed) schemaFailure = schema.error ?? schema.details ?? "schema validation failed";
-      }
-    } catch (err) {
-      schemaFailure = `response schema unavailable: ${err instanceof Error ? err.message : String(err)}`;
-    }
-    if (schemaFailure) {
+    if (schemaCheck) {
       return {
         ok: false,
-        error: `fixture discovery returned malformed get_products response: ${schemaFailure}`,
-        evidence: { page_count: pageCount }
+        error: `fixture discovery get_products validation failed: ${schemaCheck.error}`,
+        evidence: { page_count: pageCount },
+        exchange: failedExchange,
+        ...schemaCheck.schemaFailure && { schemaFailure: schemaCheck.schemaFailure }
       };
     }
     if (!isPlainRecord(result.data)) {
-      return { ok: false, error: "fixture discovery returned a non-object get_products response" };
+      return {
+        ...{ ok: false, error: "fixture discovery returned a non-object get_products response" },
+        exchange: failedExchange
+      };
+    }
+    if (result.data.unchanged === true) {
+      return {
+        ok: false,
+        error: "fixture discovery received unchanged without sending a conditional feed token",
+        exchange: failedExchange
+      };
+    }
+    const pagination = isPlainRecord(result.data.pagination) ? result.data.pagination : void 0;
+    if (pagination?.has_more === true && (typeof pagination.cursor !== "string" || pagination.cursor.length === 0)) {
+      return {
+        ok: false,
+        error: "fixture discovery pagination is broken: has_more=true without cursor",
+        exchange: failedExchange
+      };
+    }
+    const identity = JSON.stringify([
+      result.data.cache_scope,
+      result.data.wholesale_feed_version,
+      result.data.pricing_version
+    ]);
+    if (feedIdentity !== void 0 && identity !== feedIdentity) {
+      if (restarts >= 3) {
+        return {
+          ok: false,
+          unavailable: true,
+          error: "fixture discovery could not enumerate a stable feed within the runner\u2019s 3-restart budget",
+          evidence: { page_count: pageCount, restart_count: restarts },
+          exchange: failedExchange
+        };
+      }
+      restarts++;
+      products.length = 0;
+      seenProductIds.clear();
+      cursors.length = 0;
+      seenCursors.clear();
+      exchanges.length = 0;
+      pageOfProduct.clear();
+      cursor = void 0;
+      feedIdentity = void 0;
+      continue;
     }
+    feedIdentity = identity;
     const pageProducts = result.data.products;
     if (pageProducts !== void 0 && !Array.isArray(pageProducts)) {
-      return { ok: false, error: "fixture discovery get_products.products is not an array" };
+      return {
+        ...{ ok: false, error: "fixture discovery get_products.products is not an array" },
+        exchange: failedExchange
+      };
     }
     for (const product of pageProducts ?? []) {
       if (!isPlainRecord(product) || typeof product.product_id !== "string" || product.product_id.length === 0) {
-        return { ok: false, error: "fixture discovery returned a product without a non-empty product_id" };
+        return {
+          ...{ ok: false, error: "fixture discovery returned a product without a non-empty product_id" },
+          exchange: failedExchange
+        };
       }
       if (seenProductIds.has(product.product_id)) {
         return {
           ok: false,
-          error: `fixture discovery returned duplicate product_id "${product.product_id}"; response order cannot resolve duplicate identities`
+          error: `fixture discovery returned duplicate product_id "${product.product_id}"; response order cannot resolve duplicate identities`,
+          exchange: failedExchange
         };
       }
       seenProductIds.add(product.product_id);
@@ -1053,7 +1269,8 @@ async function discoverProductCatalog(client, options, context) {
           if (seenPricingIds.has(option.pricing_option_id)) {
             return {
               ok: false,
-              error: `fixture discovery returned duplicate pricing option identity "${product.product_id}\0${option.pricing_option_id}"`
+              error: `fixture discovery returned duplicate pricing option identity "${product.product_id}\0${option.pricing_option_id}"`,
+              exchange: failedExchange
             };
           }
           seenPricingIds.add(option.pricing_option_id);
@@ -1062,17 +1279,19 @@ async function discoverProductCatalog(client, options, context) {
       pageOfProduct.set(product.product_id, pageIndex);
       products.push(product);
       if (products.length > 1e5) {
-        return { ok: false, error: "fixture discovery exceeded the 100,000-product safety limit" };
+        return {
+          ...{ ok: false, error: "fixture discovery exceeded the 100,000-product safety limit" },
+          exchange: failedExchange
+        };
       }
     }
-    const pagination = isPlainRecord(result.data.pagination) ? result.data.pagination : void 0;
     if (pagination?.has_more === true) {
       const next = pagination.cursor;
-      if (typeof next !== "string" || next.length === 0) {
-        return { ok: false, error: "fixture discovery pagination is broken: has_more=true without cursor" };
-      }
       if (seenCursors.has(next)) {
-        return { ok: false, error: `fixture discovery pagination is broken: repeated cursor "${next}"` };
+        return {
+          ...{ ok: false, error: `fixture discovery pagination is broken: repeated cursor "${next}"` },
+          exchange: failedExchange
+        };
       }
       seenCursors.add(next);
       cursors.push(next);
@@ -1080,12 +1299,18 @@ async function discoverProductCatalog(client, options, context) {
     } else {
       cursor = void 0;
     }
-  } while (cursor);
+    if (!cursor) break;
+  }
   return {
     ok: true,
     catalog: {
       products,
-      evidence: { page_count: pageCount, product_count: products.length, cursors },
+      evidence: {
+        page_count: pageCount,
+        product_count: products.length,
+        cursors,
+        ...restarts > 0 && { restart_count: restarts }
+      },
       exchanges,
       pageOfProduct
     }