@adcp/sdk 17.0.0-beta.5 → 17.0.0-beta.7

package/dist/lib/identity-3.3/validation.js

@@ -81,7 +81,9 @@ function validateIdentity33Payload(tool, direction, payload, version) {
     };
     var walk = walk2;
     const document = (0, import_schema_loader.getToolSchemaDocument)(tool, direction === "request" ? "request" : "sync", version)?.schema ?? stable.schema;
-    const schema = structuredClone(direction === "response" ? (0, import_schema_loader.relaxResponseRoot)(document) : document);
+    const schema = structuredClone(
+      direction === "response" ? (0, import_schema_loader.acceptEnvelopeOnClosedResponseRootForVersion)(document, version) : document
+    );
     const relationship = import_schemas.default.find((s) => s.$id === "/schemas/core/principal-relationship.json");
     const onboarding = import_schemas.default.find((s) => s.$id === "/schemas/core/agent-onboarding.json");
     walk2(schema);

package/dist/lib/identity-3.3/validation.mjs

@@ -1,6 +1,10 @@
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { getValidator, getToolSchemaDocument, relaxResponseRoot } from "../validation/schema-loader.mjs";
+import {
+  getValidator,
+  getToolSchemaDocument,
+  acceptEnvelopeOnClosedResponseRootForVersion
+} from "../validation/schema-loader.mjs";
 import { compactSchemaForValidation } from "../validation/compact-schema.mjs";
 import schemas from "./schemas.draft.mjs";
 const validators = /* @__PURE__ */ new WeakMap();
@@ -48,7 +52,9 @@ function validateIdentity33Payload(tool, direction, payload, version) {
     };
     var walk = walk2;
     const document = getToolSchemaDocument(tool, direction === "request" ? "request" : "sync", version)?.schema ?? stable.schema;
-    const schema = structuredClone(direction === "response" ? relaxResponseRoot(document) : document);
+    const schema = structuredClone(
+      direction === "response" ? acceptEnvelopeOnClosedResponseRootForVersion(document, version) : document
+    );
     const relationship = schemas.find((s) => s.$id === "/schemas/core/principal-relationship.json");
     const onboarding = schemas.find((s) => s.$id === "/schemas/core/agent-onboarding.json");
     walk2(schema);

package/dist/lib/schemas/index.d.mts

@@ -81,8 +81,8 @@ export declare function getToolResponseSchema(toolName: string, options?: ToolRe
 /**
  * Compile the exact protocol-authored JSON Schema for offline conformance and
  * CI validation. Unlike the SDK's live-wire response validation, this does not
- * apply `relaxResponseRoot`, so extensible envelope fields can be rejected when
- * the selected normative schema does not declare them.
+ * widen closed roots for envelope fields, so a release whose normative schema
+ * does not declare an envelope field rejects it.
  *
  * This validator is not intended for validating live wire responses, whose
  * transport envelope can carry extension fields. It uses `allErrors: true`, so

package/dist/lib/schemas/index.d.ts

@@ -81,8 +81,8 @@ export declare function getToolResponseSchema(toolName: string, options?: ToolRe
 /**
  * Compile the exact protocol-authored JSON Schema for offline conformance and
  * CI validation. Unlike the SDK's live-wire response validation, this does not
- * apply `relaxResponseRoot`, so extensible envelope fields can be rejected when
- * the selected normative schema does not declare them.
+ * widen closed roots for envelope fields, so a release whose normative schema
+ * does not declare an envelope field rejects it.
  *
  * This validator is not intended for validating live wire responses, whose
  * transport envelope can carry extension fields. It uses `allErrors: true`, so

package/dist/lib/server/create-adcp-server.js

@@ -363,7 +363,6 @@ function buildIdempotencyPayload(toolName, params, account, sessionKey) {
 }
 function genericResponse(toolName, data, summary) {
   const structuredContent = { ...(0, import_responses.toStructuredContent)(data) };
-  if (import_envelope_status_compat.STATUS_FREE_SYNC_RESPONSE_TOOLS.has(toolName)) delete structuredContent.status;
   return {
     content: [{ type: "text", text: summary ?? `${toolName} completed` }],
     structuredContent
@@ -1407,8 +1406,15 @@ function injectEnvelopeStatusIntoResponse(response, toolName, servedVersion) {
     return;
   const sc = response.structuredContent;
   if (!sc || typeof sc !== "object") return;
+  if ((0, import_envelope_status_compat.omitsEnvelopeStatusForRelease)(toolName, servedVersion)) {
+    if ("status" in sc) {
+      const mirrorsStructuredContent2 = contentTextMirrorsStructuredContent(response, sc);
+      delete sc.status;
+      syncContentJsonText(response, sc, mirrorsStructuredContent2);
+    }
+    return;
+  }
   if ("status" in sc) return;
-  if (import_envelope_status_compat.STATUS_FREE_SYNC_RESPONSE_TOOLS.has(toolName)) return;
   const status = response.isError === true ? "failed" : "completed";
   const mirrorsStructuredContent = contentTextMirrorsStructuredContent(response, sc);
   sc.status = status;

package/dist/lib/server/create-adcp-server.mjs

@@ -133,7 +133,7 @@ const IDEMPOTENCY_CLAIM_RENEW_INTERVAL_MS = 6e4;
 import { isAccountProvisioningTask } from "./account-provisioning.mjs";
 import { warnAccountReferenceDeprecation } from "./account-reference-warnings.mjs";
 import { isMutatingTask, requestUsesIdempotency, IDEMPOTENCY_KEY_PATTERN, MUTATING_TASKS } from "../utils/idempotency.mjs";
-import { STATUS_FREE_SYNC_RESPONSE_TOOLS } from "../utils/envelope-status-compat.mjs";
+import { omitsEnvelopeStatusForRelease } from "../utils/envelope-status-compat.mjs";
 import { validateRequest, validateResponse, formatIssues } from "../validation/schema-validator.mjs";
 import { validateSyncReportingStatusEnvelope } from "../validation/sync-reporting-status-envelope.mjs";
 import { buildAdcpValidationErrorPayload } from "../validation/schema-errors.mjs";
@@ -465,7 +465,6 @@ function buildIdempotencyPayload(toolName, params, account, sessionKey) {
 }
 function genericResponse(toolName, data, summary) {
   const structuredContent = { ...toStructuredContent(data) };
-  if (STATUS_FREE_SYNC_RESPONSE_TOOLS.has(toolName)) delete structuredContent.status;
   return {
     content: [{ type: "text", text: summary ?? `${toolName} completed` }],
     structuredContent
@@ -1509,8 +1508,15 @@ function injectEnvelopeStatusIntoResponse(response, toolName, servedVersion) {
     return;
   const sc = response.structuredContent;
   if (!sc || typeof sc !== "object") return;
+  if (omitsEnvelopeStatusForRelease(toolName, servedVersion)) {
+    if ("status" in sc) {
+      const mirrorsStructuredContent2 = contentTextMirrorsStructuredContent(response, sc);
+      delete sc.status;
+      syncContentJsonText(response, sc, mirrorsStructuredContent2);
+    }
+    return;
+  }
   if ("status" in sc) return;
-  if (STATUS_FREE_SYNC_RESPONSE_TOOLS.has(toolName)) return;
   const status = response.isError === true ? "failed" : "completed";
   const mirrorsStructuredContent = contentTextMirrorsStructuredContent(response, sc);
   sc.status = status;

package/dist/lib/testing/storyboard/default-invariants.js

@@ -28,6 +28,8 @@ var import_media_buy_status = require('../../utils/media-buy-status.js');
 var import_state_machine = require('../../server/state-machine.js');
 var import_assertions = require('./assertions.js');
 var import_account_sync_contract = require('./account-sync-contract.js');
+var import_pricing_currency_filter = require('./pricing-currency-filter.js');
+var import_required_metric_filters = require('./required-metric-filters.js');
 const REGISTERED = /* @__PURE__ */ new Set();
 function registerOnce(id, spec) {
   if (REGISTERED.has(id)) return;
@@ -36,6 +38,8 @@ function registerOnce(id, spec) {
 }
 function registerDefaultInvariants() {
   registerOnce(import_account_sync_contract.accountSyncContractAssertion.id, import_account_sync_contract.accountSyncContractAssertion);
+  registerOnce(import_pricing_currency_filter.pricingCurrencyFilterAssertion.id, import_pricing_currency_filter.pricingCurrencyFilterAssertion);
+  registerOnce(import_required_metric_filters.requiredMetricFiltersAssertion.id, import_required_metric_filters.requiredMetricFiltersAssertion);
   registerOnce("idempotency.conflict_no_payload_leak", {
     id: "idempotency.conflict_no_payload_leak",
     default: true,

package/dist/lib/testing/storyboard/default-invariants.mjs

@@ -8,6 +8,8 @@ import {
 } from "../../server/state-machine.mjs";
 import { registerAssertion } from "./assertions.mjs";
 import { accountSyncContractAssertion } from "./account-sync-contract.mjs";
+import { pricingCurrencyFilterAssertion } from "./pricing-currency-filter.mjs";
+import { requiredMetricFiltersAssertion } from "./required-metric-filters.mjs";
 const REGISTERED = /* @__PURE__ */ new Set();
 function registerOnce(id, spec) {
   if (REGISTERED.has(id)) return;
@@ -16,6 +18,8 @@ function registerOnce(id, spec) {
 }
 function registerDefaultInvariants() {
   registerOnce(accountSyncContractAssertion.id, accountSyncContractAssertion);
+  registerOnce(pricingCurrencyFilterAssertion.id, pricingCurrencyFilterAssertion);
+  registerOnce(requiredMetricFiltersAssertion.id, requiredMetricFiltersAssertion);
   registerOnce("idempotency.conflict_no_payload_leak", {
     id: "idempotency.conflict_no_payload_leak",
     default: true,

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

@@ -96,6 +96,37 @@ function validateStoryboardShape(storyboard) {
     validateBranchSet(storyboard.id, phase);
     if (!phase.steps) continue;
     for (const step of phase.steps) {
+      if (step.collect_product_pages !== void 0) {
+        if (step.collect_product_pages !== true || step.task !== "get_products" || step.sample_request?.buying_mode !== "wholesale") {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages requires get_products with buying_mode: wholesale`
+          );
+        }
+        if (!storyboard.requires?.includes("collect_product_pages_runner")) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages requires the collect_product_pages_runner runtime requirement`
+          );
+        }
+        const functionalAuth = typeof step.auth === "object" && (step.auth.type === "web_bot_auth" || step.auth.type === "api_key" && step.auth.from_test_kit === true && step.auth.value_strategy === void 0);
+        if (step.expect_error || step.parallel_dispatch || step.auth && !functionalAuth || step.not_applicable_if) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages cannot be combined with error, parallel, auth-probe, or response-skip steps`
+          );
+        }
+        if (Object.hasOwn(step.sample_request, "idempotency_key")) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages requires fresh reads without idempotency_key`
+          );
+        }
+        const pagination = step.sample_request.pagination;
+        if (pagination && typeof pagination === "object" && "cursor" in pagination || ["if_none_match", "if_wholesale_feed_version", "if_pricing_version"].some(
+          (field) => step.sample_request?.[field] !== void 0
+        )) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages starts with an unconditional first page, without a cursor`
+          );
+        }
+      }
       if (step.enrich_request !== void 0 && (step.enrich_request !== true || !step.expect_error || step.negative_path !== "payload_well_formed")) {
         throw new Error(
           `[${storyboard.id}] ${step.id}: enrich_request requires expect_error: true and negative_path: payload_well_formed`

package/dist/lib/testing/storyboard/loader.mjs

@@ -68,6 +68,37 @@ function validateStoryboardShape(storyboard) {
     validateBranchSet(storyboard.id, phase);
     if (!phase.steps) continue;
     for (const step of phase.steps) {
+      if (step.collect_product_pages !== void 0) {
+        if (step.collect_product_pages !== true || step.task !== "get_products" || step.sample_request?.buying_mode !== "wholesale") {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages requires get_products with buying_mode: wholesale`
+          );
+        }
+        if (!storyboard.requires?.includes("collect_product_pages_runner")) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages requires the collect_product_pages_runner runtime requirement`
+          );
+        }
+        const functionalAuth = typeof step.auth === "object" && (step.auth.type === "web_bot_auth" || step.auth.type === "api_key" && step.auth.from_test_kit === true && step.auth.value_strategy === void 0);
+        if (step.expect_error || step.parallel_dispatch || step.auth && !functionalAuth || step.not_applicable_if) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages cannot be combined with error, parallel, auth-probe, or response-skip steps`
+          );
+        }
+        if (Object.hasOwn(step.sample_request, "idempotency_key")) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages requires fresh reads without idempotency_key`
+          );
+        }
+        const pagination = step.sample_request.pagination;
+        if (pagination && typeof pagination === "object" && "cursor" in pagination || ["if_none_match", "if_wholesale_feed_version", "if_pricing_version"].some(
+          (field) => step.sample_request?.[field] !== void 0
+        )) {
+          throw new Error(
+            `[${storyboard.id}] ${step.id}: collect_product_pages starts with an unconditional first page, without a cursor`
+          );
+        }
+      }
       if (step.enrich_request !== void 0 && (step.enrich_request !== true || !step.expect_error || step.negative_path !== "payload_well_formed")) {
         throw new Error(
           `[${storyboard.id}] ${step.id}: enrich_request requires expect_error: true and negative_path: payload_well_formed`

package/dist/lib/testing/storyboard/pricing-currency-filter.d.mts

@@ -0,0 +1,13 @@
+import type { AssertionSpec } from './assertions.mjs';
+/**
+ * Validate the observable currency contract on the effective discovery result.
+ * This does not compare against fixture rate-card IDs or source currencies:
+ * account-specific FX may legally change both media and compulsory signal prices.
+ * Normative basis: ProductFilters.pricing_currencies requires every returned
+ * product-level pricing option to use a requested currency. Product eligibility
+ * (one matching alternative) and pruning returned media options are distinct;
+ * optional signal add-ons retain their separate alternative-pricing semantics.
+ * https://adcontextprotocol.org/schemas/3.1.29/core/product-filters.json#/properties/pricing_currencies
+ * https://docs.adcontextprotocol.org/docs/media-buy/task-reference/get_products#currency-filtering
+ */
+export declare const pricingCurrencyFilterAssertion: AssertionSpec;

package/dist/lib/testing/storyboard/pricing-currency-filter.d.ts

@@ -0,0 +1,13 @@
+import type { AssertionSpec } from './assertions';
+/**
+ * Validate the observable currency contract on the effective discovery result.
+ * This does not compare against fixture rate-card IDs or source currencies:
+ * account-specific FX may legally change both media and compulsory signal prices.
+ * Normative basis: ProductFilters.pricing_currencies requires every returned
+ * product-level pricing option to use a requested currency. Product eligibility
+ * (one matching alternative) and pruning returned media options are distinct;
+ * optional signal add-ons retain their separate alternative-pricing semantics.
+ * https://adcontextprotocol.org/schemas/3.1.29/core/product-filters.json#/properties/pricing_currencies
+ * https://docs.adcontextprotocol.org/docs/media-buy/task-reference/get_products#currency-filtering
+ */
+export declare const pricingCurrencyFilterAssertion: AssertionSpec;

package/dist/lib/testing/storyboard/pricing-currency-filter.js

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pricing_currency_filter_exports = {};
+__export(pricing_currency_filter_exports, {
+  pricingCurrencyFilterAssertion: () => pricingCurrencyFilterAssertion
+});
+module.exports = __toCommonJS(pricing_currency_filter_exports);
+const AMOUNT_KEYS = {
+  cpm: "cpm",
+  percent_of_media: "percent",
+  flat_fee: "amount",
+  per_unit: "unit_price"
+};
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function records(value) {
+  return Array.isArray(value) ? value.filter((entry) => record(entry) !== void 0) : [];
+}
+function signalCompatibility(signal, currencies) {
+  if (signal.pricing_options === void 0) return "compatible";
+  const prices = records(signal.pricing_options);
+  if (prices.length === 0) return "indeterminate";
+  let indeterminate = false;
+  for (const price of prices) {
+    const amountKey = AMOUNT_KEYS[String(price.model)];
+    const amount = amountKey ? price[amountKey] : void 0;
+    if (amount === 0 || price.model === "percent_of_media" && price.max_cpm === 0) return "compatible";
+    if (typeof price.currency === "string" && currencies.has(price.currency)) return "compatible";
+    if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0 || typeof price.currency !== "string") {
+      indeterminate = true;
+    }
+  }
+  return indeterminate ? "indeterminate" : "incompatible";
+}
+function groupRulesFor(signal, rules) {
+  const modes = Array.isArray(signal.allowed_targeting_modes) ? signal.allowed_targeting_modes : ["include"];
+  return records(rules.selection_group_rules).filter(
+    (group) => group.selection_group === signal.selection_group && (group.targeting_mode === void 0 || modes.includes(group.targeting_mode))
+  );
+}
+function isFixedSelection(signal, rules) {
+  if (signal.default_selected !== true) return false;
+  const overrides = groupRulesFor(signal, rules);
+  return overrides.length > 0 ? overrides.some((group) => (group.selection_mode ?? rules.selection_mode) === "fixed") : rules.selection_mode === "fixed";
+}
+function selectionCapacity(options, compatible, rules, possible) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [index, option] of options.entries()) {
+    if (compatible[index] !== "compatible" && !(possible && compatible[index] === "indeterminate")) continue;
+    const group = option.selection_group ?? option;
+    grouped.set(group, (grouped.get(group) ?? 0) + 1);
+  }
+  const perGroup = typeof rules.max_selected_per_group === "number" ? rules.max_selected_per_group : Infinity;
+  const capacity = [...grouped.values()].reduce((sum, count) => sum + Math.min(count, perGroup), 0);
+  return typeof rules.max_selected_signals === "number" ? Math.min(capacity, rules.max_selected_signals) : capacity;
+}
+const pricingCurrencyFilterAssertion = {
+  id: "discovery.pricing_currency_filter",
+  default: true,
+  description: "Returned media prices and compulsory product-scoped signal charges satisfy filters.pricing_currencies.",
+  onStep(_ctx, step) {
+    if (step.skipped || step.task !== "get_products") return [];
+    const request = record(step.request?.payload);
+    const requested = record(request?.filters)?.pricing_currencies;
+    if (!Array.isArray(requested) || requested.length === 0 || !requested.every((currency) => typeof currency === "string")) {
+      return [];
+    }
+    const raw = record(step.response ?? step.response_record?.payload);
+    const response = Array.isArray(raw?.products) ? raw : record(raw?.data) ?? raw;
+    if (!Array.isArray(response?.products)) return [];
+    if (response.products.length === 0) {
+      return [
+        {
+          passed: true,
+          status: "not_applicable",
+          step_id: step.step_id,
+          description: "No currency-compatible products were returned; positive media-pricing coverage is unproven"
+        }
+      ];
+    }
+    const currencies = new Set(requested);
+    const findings = [];
+    const add = (path, compatibility) => {
+      findings.push({
+        passed: compatibility !== "incompatible",
+        step_id: step.step_id,
+        description: compatibility === "indeterminate" ? `${path}: pricing currency compatibility is unproven for custom or incomplete signal pricing` : `${path}: pricing must be satisfiable in a requested currency`,
+        ...compatibility === "indeterminate" && { status: "not_applicable" },
+        ...compatibility === "incompatible" && {
+          error: `${path} cannot be satisfied in filters.pricing_currencies ${JSON.stringify(requested)}`
+        }
+      });
+    };
+    for (const [productIndex, product] of records(response.products).entries()) {
+      const productPath = `products[${productIndex}]`;
+      for (const [priceIndex, price] of records(product.pricing_options).entries()) {
+        add(
+          `${productPath}.pricing_options[${priceIndex}].currency`,
+          typeof price.currency === "string" && currencies.has(price.currency) ? "compatible" : "incompatible"
+        );
+      }
+      const rules = record(product.signal_targeting_rules) ?? {};
+      const signals = records(product.signal_targeting_options);
+      const groups = records(rules.selection_group_rules);
+      if (product.signal_targeting_options === void 0 && (rules.selection_mode === "fixed" || rules.selection_mode === "required" || groups.some((group) => ["fixed", "required"].includes(String(group.selection_mode))))) {
+        add(`${productPath}.signal_targeting_options: mandatory inline menu is unavailable`, "indeterminate");
+      }
+      for (const [signalIndex, signal] of signals.entries()) {
+        if (isFixedSelection(signal, rules)) {
+          add(`${productPath}.signal_targeting_options[${signalIndex}]`, signalCompatibility(signal, currencies));
+        }
+      }
+      const requiredGroups = records(rules.selection_group_rules).map((group, index) => ({ group, index })).filter(({ group }) => (group.selection_mode ?? rules.selection_mode) === "required");
+      const requirements = requiredGroups.map(({ group, index }) => ({
+        path: `${productPath}.signal_targeting_rules.selection_group_rules[${index}]`,
+        minimum: group.min_selected_signals ?? 1,
+        options: signals.filter((signal) => groupRulesFor(signal, rules).includes(group)),
+        bounds: {
+          ...rules,
+          max_selected_signals: Math.min(
+            typeof rules.max_selected_signals === "number" ? rules.max_selected_signals : Infinity,
+            typeof group.max_selected_signals === "number" ? group.max_selected_signals : Infinity
+          )
+        }
+      }));
+      if (rules.selection_mode === "required" && records(rules.selection_group_rules).length === 0) {
+        requirements.push({
+          path: `${productPath}.signal_targeting_rules`,
+          minimum: rules.min_selected_signals ?? 1,
+          options: signals,
+          bounds: rules
+        });
+      } else if (rules.selection_mode === "required") {
+        findings.push({
+          passed: true,
+          status: "not_applicable",
+          step_id: step.step_id,
+          description: `${productPath}.signal_targeting_rules: aggregate required-selection feasibility with group overrides is unproven`
+        });
+      }
+      for (const requirement of requirements) {
+        if (product.signal_targeting_options === void 0 || typeof requirement.minimum !== "number") continue;
+        const compatible = requirement.options.map((signal) => signalCompatibility(signal, currencies));
+        const proven = selectionCapacity(requirement.options, compatible, requirement.bounds, false);
+        const possible = selectionCapacity(requirement.options, compatible, requirement.bounds, true);
+        add(
+          requirement.path,
+          proven >= requirement.minimum ? "compatible" : possible >= requirement.minimum ? "indeterminate" : "incompatible"
+        );
+      }
+    }
+    return findings;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pricingCurrencyFilterAssertion
+});

package/dist/lib/testing/storyboard/pricing-currency-filter.mjs

@@ -0,0 +1,151 @@
+const AMOUNT_KEYS = {
+  cpm: "cpm",
+  percent_of_media: "percent",
+  flat_fee: "amount",
+  per_unit: "unit_price"
+};
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function records(value) {
+  return Array.isArray(value) ? value.filter((entry) => record(entry) !== void 0) : [];
+}
+function signalCompatibility(signal, currencies) {
+  if (signal.pricing_options === void 0) return "compatible";
+  const prices = records(signal.pricing_options);
+  if (prices.length === 0) return "indeterminate";
+  let indeterminate = false;
+  for (const price of prices) {
+    const amountKey = AMOUNT_KEYS[String(price.model)];
+    const amount = amountKey ? price[amountKey] : void 0;
+    if (amount === 0 || price.model === "percent_of_media" && price.max_cpm === 0) return "compatible";
+    if (typeof price.currency === "string" && currencies.has(price.currency)) return "compatible";
+    if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0 || typeof price.currency !== "string") {
+      indeterminate = true;
+    }
+  }
+  return indeterminate ? "indeterminate" : "incompatible";
+}
+function groupRulesFor(signal, rules) {
+  const modes = Array.isArray(signal.allowed_targeting_modes) ? signal.allowed_targeting_modes : ["include"];
+  return records(rules.selection_group_rules).filter(
+    (group) => group.selection_group === signal.selection_group && (group.targeting_mode === void 0 || modes.includes(group.targeting_mode))
+  );
+}
+function isFixedSelection(signal, rules) {
+  if (signal.default_selected !== true) return false;
+  const overrides = groupRulesFor(signal, rules);
+  return overrides.length > 0 ? overrides.some((group) => (group.selection_mode ?? rules.selection_mode) === "fixed") : rules.selection_mode === "fixed";
+}
+function selectionCapacity(options, compatible, rules, possible) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [index, option] of options.entries()) {
+    if (compatible[index] !== "compatible" && !(possible && compatible[index] === "indeterminate")) continue;
+    const group = option.selection_group ?? option;
+    grouped.set(group, (grouped.get(group) ?? 0) + 1);
+  }
+  const perGroup = typeof rules.max_selected_per_group === "number" ? rules.max_selected_per_group : Infinity;
+  const capacity = [...grouped.values()].reduce((sum, count) => sum + Math.min(count, perGroup), 0);
+  return typeof rules.max_selected_signals === "number" ? Math.min(capacity, rules.max_selected_signals) : capacity;
+}
+const pricingCurrencyFilterAssertion = {
+  id: "discovery.pricing_currency_filter",
+  default: true,
+  description: "Returned media prices and compulsory product-scoped signal charges satisfy filters.pricing_currencies.",
+  onStep(_ctx, step) {
+    if (step.skipped || step.task !== "get_products") return [];
+    const request = record(step.request?.payload);
+    const requested = record(request?.filters)?.pricing_currencies;
+    if (!Array.isArray(requested) || requested.length === 0 || !requested.every((currency) => typeof currency === "string")) {
+      return [];
+    }
+    const raw = record(step.response ?? step.response_record?.payload);
+    const response = Array.isArray(raw?.products) ? raw : record(raw?.data) ?? raw;
+    if (!Array.isArray(response?.products)) return [];
+    if (response.products.length === 0) {
+      return [
+        {
+          passed: true,
+          status: "not_applicable",
+          step_id: step.step_id,
+          description: "No currency-compatible products were returned; positive media-pricing coverage is unproven"
+        }
+      ];
+    }
+    const currencies = new Set(requested);
+    const findings = [];
+    const add = (path, compatibility) => {
+      findings.push({
+        passed: compatibility !== "incompatible",
+        step_id: step.step_id,
+        description: compatibility === "indeterminate" ? `${path}: pricing currency compatibility is unproven for custom or incomplete signal pricing` : `${path}: pricing must be satisfiable in a requested currency`,
+        ...compatibility === "indeterminate" && { status: "not_applicable" },
+        ...compatibility === "incompatible" && {
+          error: `${path} cannot be satisfied in filters.pricing_currencies ${JSON.stringify(requested)}`
+        }
+      });
+    };
+    for (const [productIndex, product] of records(response.products).entries()) {
+      const productPath = `products[${productIndex}]`;
+      for (const [priceIndex, price] of records(product.pricing_options).entries()) {
+        add(
+          `${productPath}.pricing_options[${priceIndex}].currency`,
+          typeof price.currency === "string" && currencies.has(price.currency) ? "compatible" : "incompatible"
+        );
+      }
+      const rules = record(product.signal_targeting_rules) ?? {};
+      const signals = records(product.signal_targeting_options);
+      const groups = records(rules.selection_group_rules);
+      if (product.signal_targeting_options === void 0 && (rules.selection_mode === "fixed" || rules.selection_mode === "required" || groups.some((group) => ["fixed", "required"].includes(String(group.selection_mode))))) {
+        add(`${productPath}.signal_targeting_options: mandatory inline menu is unavailable`, "indeterminate");
+      }
+      for (const [signalIndex, signal] of signals.entries()) {
+        if (isFixedSelection(signal, rules)) {
+          add(`${productPath}.signal_targeting_options[${signalIndex}]`, signalCompatibility(signal, currencies));
+        }
+      }
+      const requiredGroups = records(rules.selection_group_rules).map((group, index) => ({ group, index })).filter(({ group }) => (group.selection_mode ?? rules.selection_mode) === "required");
+      const requirements = requiredGroups.map(({ group, index }) => ({
+        path: `${productPath}.signal_targeting_rules.selection_group_rules[${index}]`,
+        minimum: group.min_selected_signals ?? 1,
+        options: signals.filter((signal) => groupRulesFor(signal, rules).includes(group)),
+        bounds: {
+          ...rules,
+          max_selected_signals: Math.min(
+            typeof rules.max_selected_signals === "number" ? rules.max_selected_signals : Infinity,
+            typeof group.max_selected_signals === "number" ? group.max_selected_signals : Infinity
+          )
+        }
+      }));
+      if (rules.selection_mode === "required" && records(rules.selection_group_rules).length === 0) {
+        requirements.push({
+          path: `${productPath}.signal_targeting_rules`,
+          minimum: rules.min_selected_signals ?? 1,
+          options: signals,
+          bounds: rules
+        });
+      } else if (rules.selection_mode === "required") {
+        findings.push({
+          passed: true,
+          status: "not_applicable",
+          step_id: step.step_id,
+          description: `${productPath}.signal_targeting_rules: aggregate required-selection feasibility with group overrides is unproven`
+        });
+      }
+      for (const requirement of requirements) {
+        if (product.signal_targeting_options === void 0 || typeof requirement.minimum !== "number") continue;
+        const compatible = requirement.options.map((signal) => signalCompatibility(signal, currencies));
+        const proven = selectionCapacity(requirement.options, compatible, requirement.bounds, false);
+        const possible = selectionCapacity(requirement.options, compatible, requirement.bounds, true);
+        add(
+          requirement.path,
+          proven >= requirement.minimum ? "compatible" : possible >= requirement.minimum ? "indeterminate" : "incompatible"
+        );
+      }
+    }
+    return findings;
+  }
+};
+export {
+  pricingCurrencyFilterAssertion
+};

package/dist/lib/testing/storyboard/required-metric-filters.d.mts

@@ -0,0 +1,9 @@
+import type { AssertionSpec } from './assertions.mjs';
+/**
+ * Optional discovery filters have binding semantics when a buyer supplies them.
+ * Normative basis: ProductFilters.required_metrics and required_vendor_metrics
+ * require every returned product to satisfy the supplied metric predicates.
+ * https://adcontextprotocol.org/schemas/3.1.29/core/product-filters.json#/properties/required_metrics
+ * https://adcontextprotocol.org/schemas/3.1.29/core/product-filters.json#/properties/required_vendor_metrics
+ */
+export declare const requiredMetricFiltersAssertion: AssertionSpec;

package/dist/lib/testing/storyboard/required-metric-filters.d.ts

@@ -0,0 +1,9 @@
+import type { AssertionSpec } from './assertions';
+/**
+ * Optional discovery filters have binding semantics when a buyer supplies them.
+ * Normative basis: ProductFilters.required_metrics and required_vendor_metrics
+ * require every returned product to satisfy the supplied metric predicates.
+ * https://adcontextprotocol.org/schemas/3.1.29/core/product-filters.json#/properties/required_metrics
+ * https://adcontextprotocol.org/schemas/3.1.29/core/product-filters.json#/properties/required_vendor_metrics
+ */
+export declare const requiredMetricFiltersAssertion: AssertionSpec;