@adcp/sdk 5.23.0

package/dist/lib/testing/scenarios/media-buy.js

@@ -0,0 +1,1655 @@
+"use strict";
+/**
+ * Media Buy Testing Scenarios
+ *
+ * Tests sales agent media buy capabilities including:
+ * - create_media_buy
+ * - update_media_buy
+ * - get_media_buy_delivery
+ * - sync_creatives
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectProduct = selectProduct;
+exports.selectPricingOption = selectPricingOption;
+exports.buildCreateMediaBuyRequest = buildCreateMediaBuyRequest;
+exports.testCreateMediaBuy = testCreateMediaBuy;
+exports.testFullSalesFlow = testFullSalesFlow;
+exports.testReportingFlow = testReportingFlow;
+exports.testCreativeSync = testCreativeSync;
+exports.testCreativeInline = testCreativeInline;
+exports.testCreativeReference = testCreativeReference;
+exports.resolveAccountForAudiences = resolveAccountForAudiences;
+exports.testSyncAudiences = testSyncAudiences;
+exports.testMediaBuyLifecycle = testMediaBuyLifecycle;
+exports.testTerminalStateEnforcement = testTerminalStateEnforcement;
+exports.testPackageLifecycle = testPackageLifecycle;
+const client_1 = require("../client");
+const discovery_1 = require("./discovery");
+/**
+ * Find a suitable product for testing based on options
+ */
+function selectProduct(products, options) {
+    // If channels specified, filter to matching products
+    let candidates = products;
+    if (options.channels?.length) {
+        candidates = products.filter(p => p.channels?.some(ch => options.channels.includes(ch)));
+    }
+    // If pricing models specified, filter further
+    if (options.pricing_models?.length) {
+        candidates = candidates.filter(p => p.pricing_options?.some((po) => options.pricing_models.includes(po.pricing_model)));
+    }
+    // Return first matching or first product
+    return candidates[0] || products[0] || null;
+}
+/**
+ * Select a pricing option from a product
+ */
+function selectPricingOption(product, preferredModels) {
+    const options = product.pricing_options || [];
+    if (preferredModels?.length) {
+        const preferred = options.find((po) => preferredModels.includes(po.pricing_model));
+        if (preferred)
+            return preferred;
+    }
+    return options[0] || null;
+}
+/**
+ * Build a create_media_buy request
+ */
+function buildCreateMediaBuyRequest(product, pricingOption, options, extras = {}) {
+    const minSpend = pricingOption.min_spend_per_package || 0;
+    const budget = options.budget || Math.max(1000, minSpend);
+    const now = new Date();
+    const startTime = new Date(now.getTime() + 24 * 60 * 60 * 1000); // Tomorrow
+    const endTime = new Date(startTime.getTime() + 7 * 24 * 60 * 60 * 1000); // 7 days later
+    const isAuction = !('fixed_price' in pricingOption) &&
+        (pricingOption.floor_price !== undefined || pricingOption.price_guidance !== undefined);
+    const packageRequest = {
+        product_id: product.product_id,
+        budget,
+        pricing_option_id: pricingOption.pricing_option_id,
+    };
+    // Add bid_price if auction-based
+    if (isAuction && pricingOption.floor_price) {
+        packageRequest.bid_price = pricingOption.floor_price * 1.5;
+    }
+    // Add inline creatives if provided
+    if (extras.inline_creatives?.length) {
+        packageRequest.creatives = extras.inline_creatives;
+    }
+    // Add creative references if provided
+    if (extras.creative_ids?.length) {
+        packageRequest.creative_ids = extras.creative_ids;
+    }
+    return {
+        account: (0, client_1.resolveAccount)(options),
+        brand: (0, client_1.resolveBrand)(options),
+        start_time: startTime.toISOString(),
+        end_time: endTime.toISOString(),
+        packages: [packageRequest],
+    };
+}
+function getDefaultFormatId() {
+    return { agent_url: 'https://creative.adcontextprotocol.org', id: 'display_300x250' };
+}
+function formatIdToString(formatId) {
+    return formatId.id;
+}
+function selectFormatId(product, fallback = getDefaultFormatId()) {
+    if (!product?.format_ids?.length) {
+        return fallback;
+    }
+    const format = product.format_ids[0];
+    if (typeof format === 'string') {
+        return { ...fallback, id: format };
+    }
+    const nested = format;
+    if (nested.format_id) {
+        return nested.format_id;
+    }
+    const direct = format;
+    if (typeof direct.agent_url === 'string' && typeof direct.id === 'string') {
+        return direct;
+    }
+    return fallback;
+}
+function buildStaticInlineCreative(formatId) {
+    const ts = Date.now();
+    return {
+        creative_id: `test-inline-${ts}`,
+        name: `Inline Test Creative ${ts}`,
+        format_id: formatId,
+        assets: {
+            primary: {
+                url: 'https://via.placeholder.com/300x250?text=Inline+Creative',
+                width: 300,
+                height: 250,
+                format: 'png',
+            },
+        },
+    };
+}
+function extractCreativeManifest(data) {
+    return data?.creative_manifest || data?.creative_manifests?.[0];
+}
+function buildSyncCreativeFromManifest(manifest, fallbackFormatId) {
+    const creativeId = manifest?.creative_id || `test-creative-${Date.now()}`;
+    return {
+        creative_id: creativeId,
+        name: manifest?.name || `Generated Creative ${creativeId}`,
+        format_id: manifest?.format_id || fallbackFormatId,
+        assets: manifest?.assets || buildStaticInlineCreative(fallbackFormatId).assets,
+    };
+}
+/**
+ * Test: Create Media Buy
+ * Discovers products, then creates a test media buy
+ */
+async function testCreateMediaBuy(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // First run discovery
+    const { steps: discoverySteps, profile } = await (0, discovery_1.testDiscovery)(agentUrl, options);
+    steps.push(...discoverySteps);
+    if (!profile?.tools.includes('create_media_buy')) {
+        steps.push({
+            step: 'Create media buy',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent does not support create_media_buy',
+        });
+        return { steps, profile };
+    }
+    // Get products
+    const { result: productsResult } = await (0, client_1.runStep)('Fetch products for media buy', 'get_products', async () => client.getProducts({
+        buying_mode: 'brief',
+        brief: options.brief || 'Looking for display advertising products',
+        brand: (0, client_1.resolveBrand)(options),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    const productsData = productsResult?.data;
+    const products = productsData?.products;
+    if (!productsResult?.success || !products?.length) {
+        steps.push({
+            step: 'Create media buy',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'No products available to create media buy',
+        });
+        return { steps, profile };
+    }
+    const product = selectProduct(products, options);
+    if (!product) {
+        steps.push({
+            step: 'Create media buy',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'No suitable product found',
+        });
+        return { steps, profile };
+    }
+    const pricingOption = selectPricingOption(product, options.pricing_models);
+    if (!pricingOption) {
+        steps.push({
+            step: 'Create media buy',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: `Product "${product.name}" has no pricing options`,
+        });
+        return { steps, profile };
+    }
+    const createRequest = buildCreateMediaBuyRequest(product, pricingOption, options);
+    // Create the media buy
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create media buy', 'create_media_buy', 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    async () => client.createMediaBuy(createRequest));
+    let mediaBuyId;
+    if (createResult?.success && createResult?.data) {
+        steps.push((0, client_1.validateResponseSchema)('create_media_buy', createResult.data));
+        const mediaBuy = createResult.data;
+        const nested = mediaBuy.media_buy;
+        mediaBuyId = (mediaBuy.media_buy_id || nested?.media_buy_id);
+        const status = (mediaBuy.status || nested?.status);
+        const packages = (mediaBuy.packages || nested?.packages);
+        createStep.details = `Created media buy: ${mediaBuyId}, status: ${status}`;
+        createStep.created_id = mediaBuyId;
+        const confirmedAt = (mediaBuy.confirmed_at ?? nested?.confirmed_at);
+        const revision = (mediaBuy.revision ?? nested?.revision);
+        const validActions = (mediaBuy.valid_actions ?? nested?.valid_actions);
+        createStep.response_preview = JSON.stringify({
+            media_buy_id: mediaBuyId,
+            status,
+            confirmed_at: confirmedAt,
+            revision,
+            valid_actions: validActions,
+            packages_count: packages?.length,
+            pricing_model: pricingOption.pricing_model,
+            product_name: product.name,
+        }, null, 2);
+        createStep.observation_data = { confirmed_at: confirmedAt, revision };
+    }
+    else if (createResult && !createResult.success) {
+        createStep.passed = false;
+        createStep.error = createResult.error || 'create_media_buy returned unsuccessful result';
+    }
+    steps.push(createStep);
+    return { steps, profile, mediaBuyId };
+}
+/**
+ * Test: Full Sales Flow
+ * Complete lifecycle: discovery -> create -> update -> delivery
+ */
+async function testFullSalesFlow(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Run create media buy flow first
+    const { steps: createSteps, profile, mediaBuyId } = await testCreateMediaBuy(agentUrl, options);
+    steps.push(...createSteps);
+    if (!mediaBuyId) {
+        return { steps, profile };
+    }
+    // Test update_media_buy if available
+    if (profile?.tools.includes('update_media_buy')) {
+        const { result: updateResult, step: updateStep } = await (0, client_1.runStep)('Update media buy (increase budget)', 'update_media_buy', async () => client.updateMediaBuy({
+            media_buy_id: mediaBuyId,
+            packages: [
+                {
+                    package_id: 'pkg-0',
+                    budget: (options.budget || 1000) * 1.5,
+                },
+            ],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+        }));
+        if (updateResult?.success && updateResult?.data) {
+            const data = updateResult.data;
+            const nested = data.media_buy;
+            const status = (data.status || nested?.status);
+            updateStep.details = `Updated media buy, status: ${status}`;
+            updateStep.response_preview = JSON.stringify({
+                media_buy_id: (data.media_buy_id || nested?.media_buy_id),
+                status,
+            }, null, 2);
+        }
+        else if (updateResult && !updateResult.success) {
+            updateStep.passed = false;
+            updateStep.error = updateResult.error || 'update_media_buy returned unsuccessful result';
+        }
+        steps.push(updateStep);
+    }
+    if (profile?.tools.includes('get_media_buys')) {
+        const { result: snapshotResult, step: snapshotStep } = await (0, client_1.runStep)('Get media buy status with delivery snapshots', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+            media_buy_ids: [mediaBuyId],
+            include_snapshot: true,
+        }));
+        if (snapshotResult?.success && snapshotResult?.data) {
+            steps.push((0, client_1.validateResponseSchema)('get_media_buys', snapshotResult.data));
+            const mediaBuys = snapshotResult.data.media_buys || [];
+            const mediaBuy = mediaBuys.find((item) => item.media_buy_id === mediaBuyId) || mediaBuys[0];
+            const packages = mediaBuy?.packages || [];
+            const invalidPackages = packages.filter((pkg) => {
+                if (pkg.snapshot) {
+                    return !pkg.snapshot.as_of || pkg.snapshot.staleness_seconds === undefined;
+                }
+                return !pkg.snapshot_unavailable_reason;
+            });
+            if (!mediaBuy) {
+                snapshotStep.passed = false;
+                snapshotStep.error = 'get_media_buys did not return the created media buy';
+            }
+            else if (invalidPackages.length > 0) {
+                snapshotStep.passed = false;
+                snapshotStep.error =
+                    'include_snapshot=true must return either snapshot data or snapshot_unavailable_reason for each package';
+            }
+            else {
+                snapshotStep.details = `Retrieved ${packages.length} package snapshot(s)`;
+                snapshotStep.response_preview = JSON.stringify({
+                    media_buy_id: mediaBuy.media_buy_id,
+                    package_count: packages.length,
+                    snapshots_returned: packages.filter((pkg) => !!pkg.snapshot).length,
+                    snapshot_unavailable: packages
+                        .filter((pkg) => !!pkg.snapshot_unavailable_reason)
+                        .map((pkg) => ({ package_id: pkg.package_id, reason: pkg.snapshot_unavailable_reason })),
+                }, null, 2);
+                // Provide observation data so collectObservations can check valid_actions/sandbox
+                // even when media_buy_lifecycle doesn't run (e.g., agent lacks update_media_buy).
+                snapshotStep.observation_data = {
+                    valid_actions: mediaBuy.valid_actions,
+                    sandbox: mediaBuy.sandbox,
+                    status: mediaBuy.status,
+                    has_creative_deadline: packages.some((p) => p.creative_deadline) || !!mediaBuy.creative_deadline,
+                };
+            }
+        }
+        else if (snapshotResult && !snapshotResult.success) {
+            snapshotStep.passed = false;
+            snapshotStep.error = snapshotResult.error || 'get_media_buys returned unsuccessful result';
+        }
+        steps.push(snapshotStep);
+    }
+    // Test get_media_buy_delivery if available
+    if (profile?.tools.includes('get_media_buy_delivery')) {
+        const { result: deliveryResult, step: deliveryStep } = await (0, client_1.runStep)('Get delivery metrics', 'get_media_buy_delivery', async () => client.getMediaBuyDelivery({
+            media_buy_ids: [mediaBuyId],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+        }));
+        if (deliveryResult?.success && deliveryResult?.data) {
+            const delivery = deliveryResult.data;
+            const deliveries = delivery.deliveries;
+            const mediaBuys = delivery.media_buys;
+            deliveryStep.details = `Retrieved delivery metrics`;
+            deliveryStep.response_preview = JSON.stringify({
+                has_deliveries: !!(deliveries?.length || mediaBuys?.length),
+            }, null, 2);
+        }
+        else if (deliveryResult && !deliveryResult.success) {
+            deliveryStep.passed = false;
+            deliveryStep.error = deliveryResult.error || 'get_media_buy_delivery returned unsuccessful result';
+        }
+        steps.push(deliveryStep);
+    }
+    return { steps, profile };
+}
+/**
+ * Test: Reporting Flow
+ * Validates reporting capabilities:
+ * - Agent has get_media_buy_delivery tool
+ * - Products declare reporting_capabilities (frequencies, webhook support)
+ * - get_media_buy_delivery returns valid structure or reporting_delayed with expected_availability
+ * - Currency field is present in delivery data
+ *
+ * The protocol favors async webhook-based report delivery over buyer polling.
+ * This scenario checks that the agent advertises webhook support and properly
+ * handles the reporting_delayed status for data not yet available.
+ */
+async function testReportingFlow(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Discover profile
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
+    steps.push(profileStep);
+    if (!profile.tools.includes('get_media_buy_delivery')) {
+        steps.push({
+            step: 'Check get_media_buy_delivery tool',
+            task: 'get_media_buy_delivery',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent does not support get_media_buy_delivery',
+        });
+        return { steps, profile };
+    }
+    // Check supported_protocols includes 'reporting'
+    const hasReporting = profile.supported_protocols?.includes('reporting') ?? false;
+    steps.push({
+        step: 'Check reporting protocol declaration',
+        passed: true,
+        duration_ms: 0,
+        details: hasReporting
+            ? 'Agent declares reporting in supported_protocols'
+            : 'Agent does not declare reporting in supported_protocols (tool is present but protocol not declared)',
+        warnings: hasReporting
+            ? undefined
+            : ['Agent has get_media_buy_delivery but does not declare reporting in supported_protocols'],
+    });
+    // Discover products to check reporting_capabilities
+    const { result: productsResult, step: productsStep } = await (0, client_1.runStep)('Check product reporting capabilities', 'get_products', async () => client.getProducts({
+        buying_mode: 'brief',
+        brief: options.brief || 'Looking for advertising products with reporting',
+        brand: (0, client_1.resolveBrand)(options),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    const productsData = productsResult?.data;
+    const products = (productsData?.products ?? []);
+    // Evaluate reporting_capabilities on discovered products
+    const withReporting = products.filter(p => p.reporting_capabilities);
+    const withWebhooks = withReporting.filter(p => {
+        const rc = p.reporting_capabilities;
+        return rc?.supports_webhooks === true;
+    });
+    if (products.length > 0) {
+        const webhookWarnings = [];
+        if (withReporting.length === 0) {
+            webhookWarnings.push('No products declare reporting_capabilities — buyers cannot discover reporting frequency or webhook support');
+        }
+        else if (withWebhooks.length === 0) {
+            webhookWarnings.push('No products declare supports_webhooks: true — buyers must poll get_media_buy_delivery instead of receiving async reports');
+        }
+        // Check for available_reporting_frequencies
+        const withFrequencies = withReporting.filter(p => {
+            const rc = p.reporting_capabilities;
+            const freqs = rc?.available_reporting_frequencies;
+            return freqs && freqs.length > 0;
+        });
+        productsStep.details = [
+            `${products.length} product(s) discovered`,
+            `${withReporting.length} with reporting_capabilities`,
+            `${withWebhooks.length} with webhook support`,
+            `${withFrequencies.length} with reporting frequencies`,
+        ].join(', ');
+        productsStep.response_preview = JSON.stringify({
+            product_count: products.length,
+            with_reporting_capabilities: withReporting.length,
+            with_webhook_support: withWebhooks.length,
+            with_frequencies: withFrequencies.length,
+            sample_capabilities: withReporting.slice(0, 2).map(p => ({
+                product_id: p.product_id,
+                reporting_capabilities: p.reporting_capabilities,
+            })),
+        }, null, 2);
+        productsStep.warnings = webhookWarnings.length > 0 ? webhookWarnings : undefined;
+    }
+    steps.push(productsStep);
+    // Create a media buy to report on
+    const { steps: createSteps, mediaBuyId } = await testCreateMediaBuy(agentUrl, options);
+    steps.push(...createSteps);
+    if (!mediaBuyId) {
+        steps.push({
+            step: 'Find media buy for delivery report',
+            passed: false,
+            duration_ms: 0,
+            error: 'No media_buy_id — cannot test delivery reporting',
+        });
+        return { steps, profile };
+    }
+    // Call get_media_buy_delivery
+    const { result: deliveryResult, step: deliveryStep } = await (0, client_1.runStep)('Get delivery metrics', 'get_media_buy_delivery', async () => client.getMediaBuyDelivery({
+        media_buy_ids: [mediaBuyId],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (deliveryResult?.success && deliveryResult?.data) {
+        const delivery = deliveryResult.data;
+        const deliveries = delivery.deliveries;
+        const mediaBuys = delivery.media_buys;
+        const mediaBuyDeliveries = delivery.media_buy_deliveries;
+        const allEntries = (mediaBuyDeliveries ?? mediaBuys ?? deliveries ?? []);
+        const hasData = allEntries.length > 0;
+        // Split entries: some may be delayed while others have actual data
+        const delayedEntries = allEntries.filter(e => e.status === 'reporting_delayed');
+        const readyEntries = allEntries.filter(e => e.status !== 'reporting_delayed');
+        // Check for currency on entry objects (not via string search)
+        const hasCurrency = readyEntries.some(e => 'currency' in e || e.totals?.currency !== undefined);
+        // Extract metrics info for diagnostics
+        const firstReady = readyEntries[0];
+        const totals = (firstReady?.totals ?? undefined);
+        const summary = delivery.summary;
+        const impressions = (totals?.impressions ?? delivery.impressions ?? summary?.impressions);
+        const clicks = (totals?.clicks ?? delivery.clicks ?? summary?.clicks);
+        const details = [];
+        const warnings = [];
+        // Validate delayed entries
+        if (delayedEntries.length > 0) {
+            const withAvailability = delayedEntries.filter(e => e.expected_availability);
+            details.push(`${delayedEntries.length} media buy(s) reporting_delayed`);
+            if (withAvailability.length < delayedEntries.length) {
+                warnings.push('reporting_delayed entries should include expected_availability so buyers know when to expect data');
+            }
+        }
+        // Validate ready entries
+        if (readyEntries.length > 0) {
+            details.push(`${readyEntries.length} media buy(s) with delivery data`);
+            if (!hasCurrency) {
+                warnings.push('No currency field found in delivery entries');
+            }
+        }
+        if (!hasData) {
+            deliveryStep.passed = false;
+            deliveryStep.error = 'Expected delivery data or reporting_delayed status in response but found neither';
+        }
+        else {
+            deliveryStep.details = details.join(', ');
+        }
+        if (warnings.length > 0) {
+            deliveryStep.warnings = [...(deliveryStep.warnings || []), ...warnings];
+        }
+        const KNOWN_DELIVERY_KEYS = [
+            'media_buy_deliveries',
+            'media_buys',
+            'deliveries',
+            'currency',
+            'summary',
+            'reporting_period',
+            'notification_type',
+            'partial_data',
+        ];
+        deliveryStep.response_preview = JSON.stringify({
+            has_data: hasData,
+            delayed_count: delayedEntries.length,
+            ready_count: readyEntries.length,
+            has_currency: hasCurrency,
+            impressions,
+            clicks,
+            known_keys: Object.keys(delivery).filter(k => KNOWN_DELIVERY_KEYS.includes(k)),
+        }, null, 2);
+    }
+    else if (deliveryResult && !deliveryResult.success) {
+        deliveryStep.passed = false;
+        deliveryStep.error = deliveryResult.error || 'get_media_buy_delivery returned unsuccessful result';
+    }
+    else if (!deliveryResult) {
+        deliveryStep.passed = false;
+        deliveryStep.error = 'get_media_buy_delivery returned no result';
+    }
+    steps.push(deliveryStep);
+    return { steps, profile };
+}
+/**
+ * Test: Creative Sync Flow
+ * Tests sync_creatives separately from create_media_buy
+ */
+async function testCreativeSync(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Discover profile
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
+    steps.push(profileStep);
+    if (!profile.tools.includes('sync_creatives')) {
+        steps.push({
+            step: 'Sync creatives',
+            task: 'sync_creatives',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent does not support sync_creatives',
+        });
+        return { steps, profile };
+    }
+    // Get format info first
+    let formatId = {
+        agent_url: 'https://creative.adcontextprotocol.org',
+        id: 'display_300x250',
+    };
+    if (profile.tools.includes('list_creative_formats')) {
+        const { result: formatsResult } = await (0, client_1.runStep)('Get formats for creative', 'list_creative_formats', async () => client.listCreativeFormats({}));
+        if (formatsResult?.success && formatsResult?.data) {
+            const data = formatsResult.data;
+            const formatIds = data.format_ids;
+            const formats = data.formats;
+            const firstFormat = formatIds?.[0] || formats?.[0];
+            if (firstFormat) {
+                if (typeof firstFormat === 'string') {
+                    formatId = { id: firstFormat };
+                }
+                else {
+                    const formatObj = firstFormat;
+                    formatId = formatObj.format_id || formatObj;
+                }
+            }
+        }
+    }
+    // Test sync_creatives with a simple creative
+    // Assets must be an object keyed by asset_role, not an array
+    const testCreative = {
+        creative_id: `test-creative-${Date.now()}`,
+        name: 'E2E Test Creative',
+        format_id: formatId,
+        assets: {
+            primary: {
+                url: 'https://via.placeholder.com/300x250',
+                width: 300,
+                height: 250,
+                format: 'png',
+            },
+        },
+    };
+    const { result: syncResult, step: syncStep } = await (0, client_1.runStep)('Sync creative to library', 'sync_creatives', async () => client.syncCreatives({
+        account: (0, client_1.resolveAccount)(options),
+        creatives: [testCreative],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (syncResult?.success && syncResult?.data) {
+        const data = syncResult.data;
+        const creatives = data.creatives || [];
+        const actions = creatives.map(c => c.action);
+        syncStep.details = `Synced ${creatives.length} creative(s), actions: ${actions.join(', ')}`;
+        syncStep.response_preview = JSON.stringify({
+            creatives_count: creatives.length,
+            actions: actions,
+            creative_ids: creatives.map(c => c.creative_id),
+        }, null, 2);
+    }
+    else if (syncResult && !syncResult.success) {
+        syncStep.passed = false;
+        syncStep.error = syncResult.error || 'sync_creatives returned unsuccessful result';
+    }
+    steps.push(syncStep);
+    // Test list_creatives if available
+    if (profile.tools.includes('list_creatives')) {
+        const { result: listResult, step: listStep } = await (0, client_1.runStep)('List creatives in library', 'list_creatives', async () => client.listCreatives({}));
+        if (listResult?.success && listResult?.data) {
+            const data = listResult.data;
+            const creatives = data.creatives || [];
+            const querySummary = data.query_summary;
+            const totalMatching = querySummary?.total_matching;
+            const returned = querySummary?.returned ?? creatives.length;
+            // Check for pagination bug: total_matching > 0 but returned = 0
+            if (totalMatching !== undefined && totalMatching > 0 && returned === 0) {
+                listStep.passed = false;
+                listStep.error = `Pagination bug: query_summary shows ${totalMatching} total_matching but returned ${returned} creatives`;
+                listStep.response_preview = JSON.stringify({
+                    total_matching: totalMatching,
+                    returned,
+                    creatives_count: creatives.length,
+                    pagination: data.pagination,
+                }, null, 2);
+            }
+            else {
+                listStep.details = `Found ${creatives.length} creative(s) in library`;
+                listStep.response_preview = JSON.stringify({
+                    creatives_count: creatives.length,
+                    total_matching: totalMatching,
+                    statuses: Array.from(new Set(creatives.map(c => c.status))),
+                }, null, 2);
+            }
+        }
+        else if (listResult && !listResult.success) {
+            listStep.passed = false;
+            listStep.error = listResult.error || 'list_creatives returned unsuccessful result';
+        }
+        steps.push(listStep);
+    }
+    return { steps, profile };
+}
+/**
+ * Test: Creative Inline Flow
+ * Tests providing creatives inline in create_media_buy
+ */
+async function testCreativeInline(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Discovery first
+    const { steps: discoverySteps, profile } = await (0, discovery_1.testDiscovery)(agentUrl, options);
+    steps.push(...discoverySteps);
+    if (!profile?.tools.includes('create_media_buy')) {
+        steps.push({
+            step: 'Create media buy with inline creatives',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent does not support create_media_buy',
+        });
+        return { steps, profile };
+    }
+    // Check if agent declares inline creative support via capabilities
+    if (profile.tools.includes('get_adcp_capabilities')) {
+        try {
+            const capResult = (await client.getAdcpCapabilities({}));
+            const capData = capResult?.data;
+            if (capData?.media_buy?.features?.inline_creative_management === false) {
+                steps.push({
+                    step: 'Create media buy with inline creative',
+                    task: 'create_media_buy',
+                    passed: true,
+                    duration_ms: 0,
+                    details: 'Skipped: agent declares inline_creative_management: false',
+                });
+                return { steps, profile };
+            }
+        }
+        catch {
+            // If capabilities check fails, proceed with the test
+        }
+    }
+    // Get products
+    const { result: productsResult } = await (0, client_1.runStep)('Fetch products for inline creative test', 'get_products', async () => client.getProducts({
+        buying_mode: 'brief',
+        brief: options.brief || 'Looking for display advertising products',
+        brand: (0, client_1.resolveBrand)(options),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    const inlineProductsData = productsResult?.data;
+    const products = inlineProductsData?.products;
+    if (!productsResult?.success || !products?.length) {
+        steps.push({
+            step: 'Create media buy with inline creatives',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'No products available to test inline creatives',
+        });
+        return { steps, profile };
+    }
+    const product = selectProduct(products, options);
+    if (!product) {
+        steps.push({
+            step: 'Create media buy with inline creatives',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'No suitable product found',
+        });
+        return { steps, profile };
+    }
+    const pricingOption = selectPricingOption(product, options.pricing_models);
+    if (!pricingOption) {
+        steps.push({
+            step: 'Create media buy with inline creatives',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: `Product "${product.name}" has no pricing options`,
+        });
+        return { steps, profile };
+    }
+    const formatId = selectFormatId(product);
+    let inlineCreative = buildStaticInlineCreative(formatId);
+    if (profile.tools.includes('build_creative')) {
+        const { result: buildResult, step: buildStep } = await (0, client_1.runStep)(`Build creative for inline flow (${formatIdToString(formatId)})`, 'build_creative', async () => client.executeTask('build_creative', {
+            target_format_id: formatId,
+            brand: (0, client_1.resolveBrand)(options),
+            message: `Create an ad creative for the ${formatIdToString(formatId)} format that can be attached to a media buy`,
+            quality: 'draft',
+        }));
+        if (buildResult?.success && buildResult?.data) {
+            const manifest = extractCreativeManifest(buildResult.data);
+            if (manifest?.assets) {
+                inlineCreative = buildSyncCreativeFromManifest(manifest, formatId);
+                buildStep.details = `Built creative manifest for ${inlineCreative.format_id}`;
+                buildStep.response_preview = JSON.stringify({
+                    format_id: inlineCreative.format_id,
+                    asset_keys: Object.keys(inlineCreative.assets || {}),
+                }, null, 2);
+            }
+            else {
+                buildStep.passed = false;
+                buildStep.error = 'build_creative succeeded but returned no creative_manifest';
+            }
+        }
+        else if (buildResult && !buildResult.success) {
+            buildStep.passed = false;
+            buildStep.error = buildResult.error || 'build_creative failed';
+        }
+        steps.push(buildStep);
+    }
+    const createRequest = buildCreateMediaBuyRequest(product, pricingOption, options, {
+        inline_creatives: [inlineCreative],
+    });
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create media buy with inline creative', 'create_media_buy', 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    async () => client.createMediaBuy(createRequest));
+    if (createResult?.success && createResult?.data) {
+        steps.push((0, client_1.validateResponseSchema)('create_media_buy', createResult.data));
+        const mediaBuy = createResult.data;
+        const nested = mediaBuy.media_buy;
+        const mediaBuyId = (mediaBuy.media_buy_id || nested?.media_buy_id);
+        const status = (mediaBuy.status || nested?.status);
+        const packages = (mediaBuy.packages || nested?.packages);
+        const hasCreatives = packages?.some(p => {
+            const creatives = p.creatives;
+            const creativeIds = p.creative_ids;
+            return creatives?.length || creativeIds?.length;
+        });
+        createStep.details = `Created media buy with inline creative: ${mediaBuyId}`;
+        createStep.created_id = mediaBuyId;
+        createStep.response_preview = JSON.stringify({
+            media_buy_id: mediaBuyId,
+            status,
+            has_creatives: hasCreatives,
+            packages_count: packages?.length,
+        }, null, 2);
+    }
+    else if (createResult && !createResult.success) {
+        createStep.passed = false;
+        createStep.error = createResult.error || 'create_media_buy with inline creatives failed';
+    }
+    steps.push(createStep);
+    return { steps, profile };
+}
+/**
+ * Test: Creative Reference Flow
+ * Builds a creative manifest, syncs it into the seller's library, then references it in create_media_buy.
+ */
+async function testCreativeReference(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    const { steps: discoverySteps, profile } = await (0, discovery_1.testDiscovery)(agentUrl, options);
+    steps.push(...discoverySteps);
+    if (!profile?.tools.includes('build_creative') || !profile.tools.includes('sync_creatives')) {
+        steps.push({
+            step: 'Build and reference creative',
+            task: 'build_creative',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent must support both build_creative and sync_creatives',
+        });
+        return { steps, profile };
+    }
+    const { result: productsResult } = await (0, client_1.runStep)('Fetch products for creative reference test', 'get_products', async () => client.executeTask('get_products', {
+        buying_mode: 'brief',
+        brief: options.brief || 'Looking for products that support generated creative attachments',
+        brand: (0, client_1.resolveBrand)(options),
+    }));
+    const products = productsResult?.data?.products;
+    if (!productsResult?.success || !products?.length) {
+        steps.push({
+            step: 'Build and reference creative',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'No products available to test creative references',
+        });
+        return { steps, profile };
+    }
+    const product = selectProduct(products, options);
+    if (!product) {
+        steps.push({
+            step: 'Build and reference creative',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: 'No suitable product found for creative reference test',
+        });
+        return { steps, profile };
+    }
+    const pricingOption = selectPricingOption(product, options.pricing_models);
+    const formatId = selectFormatId(product);
+    if (!pricingOption) {
+        steps.push({
+            step: 'Build and reference creative',
+            task: 'create_media_buy',
+            passed: false,
+            duration_ms: 0,
+            error: `Product "${product.name}" has no pricing options`,
+        });
+        return { steps, profile };
+    }
+    const { result: buildResult, step: buildStep } = await (0, client_1.runStep)(`Build creative for reference flow (${formatIdToString(formatId)})`, 'build_creative', async () => client.executeTask('build_creative', {
+        target_format_id: formatId,
+        brand: (0, client_1.resolveBrand)(options),
+        message: `Create a reusable ad creative for the ${formatIdToString(formatId)} format`,
+        quality: 'draft',
+    }));
+    if (!buildResult?.success || !buildResult?.data) {
+        buildStep.passed = false;
+        buildStep.error = buildResult?.error || 'build_creative failed';
+        steps.push(buildStep);
+        return { steps, profile };
+    }
+    const manifest = extractCreativeManifest(buildResult.data);
+    if (!manifest?.assets) {
+        buildStep.passed = false;
+        buildStep.error = 'build_creative returned no creative_manifest';
+        steps.push(buildStep);
+        return { steps, profile };
+    }
+    const syncedCreative = buildSyncCreativeFromManifest(manifest, formatId);
+    buildStep.details = `Built creative manifest for ${syncedCreative.format_id}`;
+    buildStep.response_preview = JSON.stringify({
+        creative_id: syncedCreative.creative_id,
+        format_id: syncedCreative.format_id,
+        asset_keys: Object.keys(syncedCreative.assets || {}),
+    }, null, 2);
+    steps.push(buildStep);
+    const { result: syncResult, step: syncStep } = await (0, client_1.runStep)('Sync generated creative to library', 'sync_creatives', async () => client.executeTask('sync_creatives', {
+        creatives: [syncedCreative],
+    }));
+    if (!syncResult?.success || !syncResult?.data) {
+        syncStep.passed = false;
+        syncStep.error = syncResult?.error || 'sync_creatives failed';
+        steps.push(syncStep);
+        return { steps, profile };
+    }
+    syncStep.details = `Synced creative ${syncedCreative.creative_id} to seller library`;
+    syncStep.created_id = syncedCreative.creative_id;
+    syncStep.response_preview = JSON.stringify({
+        creative_id: syncedCreative.creative_id,
+        synced_count: (syncResult.data.creatives || []).length,
+    }, null, 2);
+    steps.push(syncStep);
+    const createRequest = buildCreateMediaBuyRequest(product, pricingOption, options, {
+        creative_ids: [syncedCreative.creative_id],
+    });
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create media buy with referenced creative', 'create_media_buy', async () => client.executeTask('create_media_buy', createRequest));
+    if (createResult?.success && createResult?.data) {
+        steps.push((0, client_1.validateResponseSchema)('create_media_buy', createResult.data));
+        const mediaBuy = createResult.data;
+        const mediaBuyId = mediaBuy.media_buy_id || mediaBuy.media_buy?.media_buy_id;
+        const packages = mediaBuy.packages || mediaBuy.media_buy?.packages;
+        const referenced = packages?.some((pkg) => pkg.creative_ids?.includes(syncedCreative.creative_id));
+        createStep.details = `Created media buy with referenced creative ${syncedCreative.creative_id}`;
+        createStep.created_id = mediaBuyId;
+        createStep.response_preview = JSON.stringify({
+            media_buy_id: mediaBuyId,
+            creative_id: syncedCreative.creative_id,
+            referenced,
+        }, null, 2);
+    }
+    else if (createResult && !createResult.success) {
+        createStep.passed = false;
+        createStep.error = createResult.error || 'create_media_buy with creative_ids failed';
+    }
+    steps.push(createStep);
+    return { steps, profile };
+}
+// SHA-256 lookalike placeholder for test email/phone hashes (not a real hash)
+const TEST_HASHED_EMAIL = 'a' + '0'.repeat(63);
+const TEST_HASHED_PHONE = 'b' + '0'.repeat(63);
+/**
+ * Resolve which account reference to use for audience sync.
+ *
+ * Priority: explicit account_id > sandbox discovery > sandbox natural key > list_accounts discovery.
+ *
+ * Extracted for testability — the listAccounts callback abstracts the client call.
+ */
+async function resolveAccountForAudiences(options, tools, listAccounts) {
+    const steps = [];
+    if (options.audience_account_id) {
+        return { accountRef: { account_id: options.audience_account_id }, steps };
+    }
+    if (options.sandbox && tools.includes('list_accounts')) {
+        // Sandbox with list_accounts: try explicit sandbox path first (discover pre-existing test accounts)
+        const { result: sandboxResult, step: sandboxStep } = await (0, client_1.runStep)('Discover sandbox accounts', 'list_accounts', async () => listAccounts({ sandbox: true }));
+        const sandboxData = sandboxResult?.success
+            ? sandboxResult.data
+            : undefined;
+        const sandboxAccounts = sandboxData?.accounts ?? [];
+        if (sandboxAccounts[0]?.account_id) {
+            sandboxStep.details = `Using sandbox account: ${sandboxAccounts[0].account_id}`;
+            steps.push(sandboxStep);
+            return { accountRef: { account_id: sandboxAccounts[0].account_id }, steps };
+        }
+        // Fall back to natural key — mark step as informational, not a failure
+        const brand = (0, client_1.resolveBrand)(options);
+        if (!sandboxResult?.success) {
+            sandboxStep.details = 'list_accounts failed; falling back to natural key';
+        }
+        else {
+            sandboxStep.details = 'No explicit sandbox accounts found; falling back to natural key';
+        }
+        sandboxStep.passed = true;
+        sandboxStep.error = undefined;
+        steps.push(sandboxStep);
+        return { accountRef: { brand, operator: brand.domain, sandbox: true }, steps };
+    }
+    if (options.sandbox) {
+        // Sandbox without list_accounts: implicit account model, use natural key
+        const brand = (0, client_1.resolveBrand)(options);
+        return { accountRef: { brand, operator: brand.domain, sandbox: true }, steps };
+    }
+    if (tools.includes('list_accounts')) {
+        const { result: accountsResult, step: accountsStep } = await (0, client_1.runStep)('Discover accounts for audience sync', 'list_accounts', async () => listAccounts({}));
+        if (accountsResult?.success && accountsResult?.data) {
+            const accountsData = accountsResult.data;
+            const accounts = accountsData.accounts ?? [];
+            if (accounts[0]?.account_id) {
+                accountsStep.details = `Using account: ${accounts[0].account_id}`;
+                steps.push(accountsStep);
+                return { accountRef: { account_id: accounts[0].account_id }, steps };
+            }
+            accountsStep.details = 'list_accounts returned no accounts';
+        }
+        else {
+            accountsStep.details = 'list_accounts call failed';
+        }
+        steps.push(accountsStep);
+    }
+    return { accountRef: undefined, steps };
+}
+/**
+ * Test: Audience Sync
+ * Tests sync_audiences: discovery -> create audience -> delete audience
+ */
+async function testSyncAudiences(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Discover agent profile
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
+    steps.push(profileStep);
+    if (!profileStep.passed) {
+        return { steps, profile };
+    }
+    if (!profile.tools.includes('sync_audiences')) {
+        steps.push({
+            step: 'Sync audiences',
+            task: 'sync_audiences',
+            passed: false,
+            duration_ms: 0,
+            error: 'Agent does not support sync_audiences',
+        });
+        return { steps, profile };
+    }
+    const { accountRef, steps: accountSteps } = await resolveAccountForAudiences(options, profile.tools, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    async (params) => client.listAccounts(params));
+    steps.push(...accountSteps);
+    if (!accountRef) {
+        steps.push({
+            step: 'Sync audiences',
+            task: 'sync_audiences',
+            passed: false,
+            duration_ms: 0,
+            error: 'No account available. Provide audience_account_id, use sandbox: true, or ensure list_accounts is supported.',
+        });
+        return { steps, profile };
+    }
+    // Step 1: Discovery call — list existing audiences without modification
+    const { result: discoveryResult, step: discoveryStep } = await (0, client_1.runStep)('Discover existing audiences (discovery-only)', 'sync_audiences', async () => client.syncAudiences({
+        account: accountRef,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (discoveryResult?.success && discoveryResult?.data) {
+        const discoveryData = discoveryResult.data;
+        const audiences = discoveryData.audiences ?? [];
+        discoveryStep.details = `Found ${audiences.length} existing audience(s)`;
+        discoveryStep.response_preview = JSON.stringify({
+            existing_audiences: audiences.length,
+            audience_ids: audiences.map(a => a.audience_id).slice(0, 5),
+        }, null, 2);
+    }
+    else if (discoveryResult && !discoveryResult.success) {
+        discoveryStep.passed = false;
+        discoveryStep.error = discoveryResult.error || 'sync_audiences discovery call failed';
+    }
+    steps.push(discoveryStep);
+    if (!discoveryResult?.success) {
+        return { steps, profile };
+    }
+    // Step 2: Create a test audience
+    const testAudienceId = `adcp-test-audience-${Date.now()}`;
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create test audience', 'sync_audiences', async () => client.syncAudiences({
+        account: accountRef,
+        audiences: [
+            {
+                audience_id: testAudienceId,
+                name: 'AdCP E2E Test Audience',
+                add: [{ hashed_email: TEST_HASHED_EMAIL }, { hashed_phone: TEST_HASHED_PHONE }],
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (createResult?.success && createResult?.data) {
+        const createData = createResult.data;
+        const audiences = createData.audiences ?? [];
+        const testAudience = audiences.find(a => a.audience_id === testAudienceId);
+        createStep.details = `Created audience "${testAudienceId}", action: ${testAudience?.action}, status: ${testAudience?.status ?? 'n/a'}`;
+        createStep.created_id = testAudienceId;
+        createStep.response_preview = JSON.stringify({
+            audience_id: testAudience?.audience_id,
+            action: testAudience?.action,
+            status: testAudience?.status,
+            uploaded_count: testAudience?.uploaded_count,
+            matched_count: testAudience?.matched_count,
+            effective_match_rate: testAudience?.effective_match_rate,
+            match_breakdown: testAudience?.match_breakdown,
+        }, null, 2);
+        // Advisory: report match breakdown availability
+        if (testAudience?.status === 'ready') {
+            if (testAudience.match_breakdown) {
+                createStep.details += `, match_breakdown: ${testAudience.match_breakdown.length} ID type(s)`;
+            }
+            if (testAudience.effective_match_rate != null) {
+                createStep.details += `, effective_match_rate: ${(testAudience.effective_match_rate * 100).toFixed(1)}%`;
+            }
+        }
+    }
+    else if (createResult && !createResult.success) {
+        createStep.passed = false;
+        createStep.error = createResult.error || 'sync_audiences create call failed';
+    }
+    steps.push(createStep);
+    if (!createResult?.success) {
+        return { steps, profile };
+    }
+    // Step 3: Delete the test audience
+    const { result: deleteResult, step: deleteStep } = await (0, client_1.runStep)('Delete test audience', 'sync_audiences', async () => client.syncAudiences({
+        account: accountRef,
+        audiences: [
+            {
+                audience_id: testAudienceId,
+                delete: true,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (deleteResult?.success && deleteResult?.data) {
+        const deleteData = deleteResult.data;
+        const audiences = deleteData.audiences ?? [];
+        const deleted = audiences.find(a => a.audience_id === testAudienceId);
+        deleteStep.details = `Deleted audience "${testAudienceId}", action: ${deleted?.action}`;
+        deleteStep.response_preview = JSON.stringify({
+            audience_id: deleted?.audience_id,
+            action: deleted?.action,
+        }, null, 2);
+    }
+    else if (deleteResult && !deleteResult.success) {
+        deleteStep.passed = false;
+        deleteStep.error = deleteResult.error || 'sync_audiences delete call failed';
+    }
+    steps.push(deleteStep);
+    return { steps, profile };
+}
+// ---------------------------------------------------------------------------
+// State Machine Compliance Scenarios
+// ---------------------------------------------------------------------------
+/**
+ * Extract media buy status from a response, handling nested shapes.
+ */
+function extractStatus(data) {
+    const nested = data.media_buy;
+    return (data.status ?? nested?.status);
+}
+/**
+ * Test: Media Buy Lifecycle
+ * Exercises the full state machine: create -> pause -> resume -> get status -> cancel
+ */
+async function testMediaBuyLifecycle(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Create a media buy to work with
+    const { steps: createSteps, profile, mediaBuyId } = await testCreateMediaBuy(agentUrl, options);
+    steps.push(...createSteps);
+    if (!mediaBuyId || !profile?.tools.includes('update_media_buy')) {
+        return { steps, profile };
+    }
+    // Track revisions across steps for monotonicity check
+    const revisions = [];
+    // Step 1: Pause the media buy
+    const { result: pauseResult, step: pauseStep } = await (0, client_1.runStep)('Pause media buy', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        paused: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (pauseResult?.success && pauseResult?.data) {
+        const data = pauseResult.data;
+        const status = extractStatus(data);
+        const pauseRevision = data.revision;
+        if (pauseRevision !== undefined)
+            revisions.push({ step: 'pause', revision: pauseRevision });
+        pauseStep.details = `Paused media buy, status: ${status}`;
+        pauseStep.response_preview = JSON.stringify({ media_buy_id: mediaBuyId, status, revision: pauseRevision }, null, 2);
+        if (status && status !== 'paused') {
+            pauseStep.warnings = [`Expected status 'paused', got '${status}'`];
+        }
+    }
+    else if (pauseResult && !pauseResult.success) {
+        pauseStep.passed = false;
+        pauseStep.error = pauseResult.error || 'Pause operation failed';
+    }
+    steps.push(pauseStep);
+    // Step 2: Resume the media buy
+    const { result: resumeResult, step: resumeStep } = await (0, client_1.runStep)('Resume media buy', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        paused: false,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (resumeResult?.success && resumeResult?.data) {
+        const data = resumeResult.data;
+        const status = extractStatus(data);
+        const resumeRevision = data.revision;
+        if (resumeRevision !== undefined)
+            revisions.push({ step: 'resume', revision: resumeRevision });
+        resumeStep.details = `Resumed media buy, status: ${status}`;
+        resumeStep.response_preview = JSON.stringify({ media_buy_id: mediaBuyId, status, revision: resumeRevision }, null, 2);
+        if (status && status !== 'active' && status !== 'pending_start') {
+            resumeStep.warnings = [`Expected status 'active' or 'pending_start', got '${status}'`];
+        }
+    }
+    else if (resumeResult && !resumeResult.success) {
+        resumeStep.passed = false;
+        resumeStep.error = resumeResult.error || 'Resume operation failed';
+    }
+    steps.push(resumeStep);
+    // Step 2b: Budget update — verify substantive field mutation
+    // Find a package to update budget on
+    let budgetPackageId;
+    let originalBudget;
+    if (profile.tools.includes('get_media_buys')) {
+        const { result: fetchResult } = await (0, client_1.runStep)('Fetch packages for budget test', 'get_media_buys', async () => client.executeTask('get_media_buys', { media_buy_ids: [mediaBuyId] }));
+        if (fetchResult?.success && fetchResult?.data) {
+            const mbs = (fetchResult.data.media_buys || []);
+            const mb = mbs.find((item) => item.media_buy_id === mediaBuyId) || mbs[0];
+            const pkgs = (mb?.packages || []);
+            if (pkgs[0]) {
+                budgetPackageId = pkgs[0].package_id;
+                originalBudget = pkgs[0].budget;
+            }
+        }
+    }
+    if (budgetPackageId && originalBudget !== undefined) {
+        const newBudget = Math.round(originalBudget * 1.2 * 100) / 100; // 20% increase
+        const { result: budgetResult, step: budgetStep } = await (0, client_1.runStep)('Update package budget', 'update_media_buy', async () => client.updateMediaBuy({
+            media_buy_id: mediaBuyId,
+            packages: [{ package_id: budgetPackageId, budget: newBudget }],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+        }));
+        if (budgetResult?.success && budgetResult?.data) {
+            const data = budgetResult.data;
+            const budgetRevision = data.revision;
+            if (budgetRevision !== undefined)
+                revisions.push({ step: 'budget_update', revision: budgetRevision });
+            budgetStep.details = `Updated budget from $${originalBudget} to $${newBudget}`;
+            budgetStep.response_preview = JSON.stringify({ media_buy_id: mediaBuyId, package_id: budgetPackageId, new_budget: newBudget, revision: budgetRevision }, null, 2);
+        }
+        else if (budgetResult && !budgetResult.success) {
+            const error = budgetResult.error || '';
+            if (error.includes('BUDGET_EXCEEDED') || error.includes('budget_exceeded')) {
+                budgetStep.passed = true;
+                budgetStep.details = `Agent rejected budget increase with BUDGET_EXCEEDED — acceptable`;
+            }
+            else {
+                budgetStep.passed = false;
+                budgetStep.error = budgetResult.error || 'Budget update failed';
+            }
+        }
+        steps.push(budgetStep);
+    }
+    // Step 3: Get status and check valid_actions, confirmed_at, revision, history (if get_media_buys available)
+    if (profile.tools.includes('get_media_buys')) {
+        const { result: statusResult, step: statusStep } = await (0, client_1.runStep)('Get media buy status and valid_actions', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+            media_buy_ids: [mediaBuyId],
+            include_history: 10,
+        }));
+        if (statusResult?.success && statusResult?.data) {
+            const mediaBuys = (statusResult.data.media_buys || []);
+            const mediaBuy = mediaBuys.find((item) => item.media_buy_id === mediaBuyId) || mediaBuys[0];
+            if (!mediaBuy) {
+                statusStep.passed = false;
+                statusStep.error = 'get_media_buys did not return the created media buy';
+            }
+            else {
+                const validActions = mediaBuy.valid_actions;
+                const mbRevision = mediaBuy.revision;
+                const mbConfirmedAt = mediaBuy.confirmed_at;
+                const history = mediaBuy.history;
+                const packages = (mediaBuy.packages || []);
+                const hasCreativeDeadline = packages.some(p => p.creative_deadline) || !!mediaBuy.creative_deadline;
+                // Validate history entry shape if present
+                let historyValid = true;
+                if (history?.length) {
+                    const missingTimestamp = history.some(h => !h.timestamp);
+                    const missingAction = history.some(h => !h.action);
+                    if (missingTimestamp || missingAction)
+                        historyValid = false;
+                }
+                statusStep.details = `Status: ${mediaBuy.status}, valid_actions: ${validActions ? validActions.join(', ') : 'not provided'}, revision: ${mbRevision ?? 'not provided'}`;
+                statusStep.response_preview = JSON.stringify({
+                    media_buy_id: mediaBuy.media_buy_id,
+                    status: mediaBuy.status,
+                    confirmed_at: mbConfirmedAt,
+                    revision: mbRevision,
+                    valid_actions: validActions,
+                    history_entries: history?.length ?? 0,
+                    history_valid: historyValid,
+                    has_creative_deadline: hasCreativeDeadline,
+                    sandbox: mediaBuy.sandbox,
+                }, null, 2);
+                statusStep.observation_data = {
+                    valid_actions: validActions,
+                    sandbox: mediaBuy.sandbox,
+                    status: mediaBuy.status,
+                    has_creative_deadline: hasCreativeDeadline,
+                    history_entries: history?.length ?? 0,
+                    history_valid: historyValid,
+                };
+            }
+        }
+        else if (statusResult && !statusResult.success) {
+            statusStep.passed = false;
+            statusStep.error = statusResult.error || 'get_media_buys failed';
+        }
+        steps.push(statusStep);
+    }
+    // Step 3b: Revision concurrency check — use actual stale revision from an earlier step
+    const lastRevision = revisions.length > 0 ? revisions[revisions.length - 1].revision : undefined;
+    const staleRevision = revisions.length >= 2 ? revisions[0].revision : -1;
+    const { result: conflictResult, step: conflictStep } = await (0, client_1.runStep)('Update with stale revision (expect CONFLICT)', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        revision: staleRevision,
+        end_time: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (conflictResult && !conflictResult.success) {
+        const error = conflictResult.error || '';
+        if (error.includes('CONFLICT') || error.includes('conflict') || error.includes('revision')) {
+            conflictStep.passed = true;
+            conflictStep.details = `Correctly rejected stale revision ${staleRevision} with CONFLICT (current: ${lastRevision ?? 'unknown'})`;
+        }
+        else {
+            // Agent rejected for another reason — still acceptable, revision may not be supported
+            conflictStep.passed = true;
+            conflictStep.details = `Agent rejected update: ${error}`;
+            conflictStep.warnings = [
+                'Agent did not return CONFLICT for stale revision — revision concurrency may not be supported',
+            ];
+        }
+    }
+    else if (conflictResult?.success) {
+        // Agent accepted stale revision — revision concurrency not enforced
+        conflictStep.passed = true;
+        conflictStep.details = `Agent accepted stale revision ${staleRevision} — optimistic concurrency not enforced`;
+        conflictStep.warnings = ['Agent does not enforce optimistic concurrency via revision numbers'];
+    }
+    else if (!conflictResult) {
+        conflictStep.passed = false;
+        conflictStep.error = 'No response from update_media_buy';
+    }
+    steps.push(conflictStep);
+    // Step 3c: Check revision monotonicity
+    if (revisions.length >= 2) {
+        const monotonicStep = {
+            step: 'Revision monotonicity check',
+            task: 'update_media_buy',
+            passed: true,
+            duration_ms: 0,
+        };
+        const isMonotonic = revisions.every((r, i) => i === 0 || r.revision > revisions[i - 1].revision);
+        if (isMonotonic) {
+            monotonicStep.details = `Revisions are monotonically increasing: ${revisions.map(r => `${r.step}=${r.revision}`).join(' → ')}`;
+        }
+        else {
+            monotonicStep.passed = true; // advisory, not a hard fail
+            monotonicStep.details = `Revisions: ${revisions.map(r => `${r.step}=${r.revision}`).join(' → ')}`;
+            monotonicStep.warnings = [
+                `Revision numbers are not monotonically increasing — buyers depend on this for concurrency safety`,
+            ];
+        }
+        steps.push(monotonicStep);
+    }
+    // Step 4: Cancel the media buy
+    const { result: cancelResult, step: cancelStep } = await (0, client_1.runStep)('Cancel media buy', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        canceled: true,
+        cancellation_reason: 'AdCP compliance test — lifecycle scenario',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (cancelResult?.success && cancelResult?.data) {
+        const data = cancelResult.data;
+        const nested = data.media_buy;
+        const status = extractStatus(data);
+        const cancelRevision = (data.revision ?? nested?.revision);
+        cancelStep.details = `Canceled media buy, status: ${status}`;
+        const canceledBy = (data.canceled_by ?? nested?.canceled_by);
+        const canceledAt = (data.canceled_at ?? nested?.canceled_at);
+        if (cancelRevision !== undefined)
+            revisions.push({ step: 'cancel', revision: cancelRevision });
+        cancelStep.response_preview = JSON.stringify({ media_buy_id: mediaBuyId, status, revision: cancelRevision, canceled_by: canceledBy, canceled_at: canceledAt }, null, 2);
+        cancelStep.observation_data = { status, canceled_by: canceledBy, canceled_at: canceledAt };
+        if (status && status !== 'canceled') {
+            cancelStep.warnings = [`Expected status 'canceled', got '${status}'`];
+        }
+    }
+    else if (cancelResult && !cancelResult.success) {
+        // NOT_CANCELLABLE is a valid response — agent may not support cancellation
+        const error = cancelResult.error || '';
+        if (error.includes('NOT_CANCELLABLE') || error.includes('not_cancellable')) {
+            cancelStep.passed = true;
+            cancelStep.details = 'Agent does not support cancellation (NOT_CANCELLABLE)';
+        }
+        else {
+            cancelStep.passed = false;
+            cancelStep.error = cancelResult.error || 'Cancel operation failed';
+        }
+    }
+    steps.push(cancelStep);
+    return { steps, profile };
+}
+/**
+ * Test: Terminal State Enforcement
+ * Verifies agents reject updates to media buys in terminal states.
+ */
+async function testTerminalStateEnforcement(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Create and cancel a media buy
+    const { steps: createSteps, profile, mediaBuyId } = await testCreateMediaBuy(agentUrl, options);
+    steps.push(...createSteps);
+    if (!mediaBuyId || !profile?.tools.includes('update_media_buy')) {
+        return { steps, profile };
+    }
+    // Cancel the media buy to put it in a terminal state
+    const { result: cancelResult, step: cancelStep } = await (0, client_1.runStep)('Cancel media buy (setup)', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        canceled: true,
+        cancellation_reason: 'AdCP compliance test — terminal state enforcement',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (cancelResult?.success && cancelResult?.data) {
+        const data = cancelResult.data;
+        cancelStep.details = `Canceled media buy, status: ${extractStatus(data)}`;
+    }
+    else if (cancelResult && !cancelResult.success) {
+        const error = cancelResult.error || '';
+        if (error.includes('NOT_CANCELLABLE') || error.includes('not_cancellable')) {
+            // Agent doesn't support cancellation — try to find a completed buy instead
+            cancelStep.passed = true;
+            cancelStep.details = 'Agent does not support cancellation — will check for completed media buys instead';
+            steps.push(cancelStep);
+            // Look for a completed media buy to test terminal state enforcement against
+            if (profile.tools.includes('get_media_buys')) {
+                const { result: completedResult, step: completedStep } = await (0, client_1.runStep)('Find completed media buy for terminal state test', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+                    status_filter: ['completed'],
+                    pagination: { max_results: 1 },
+                }));
+                if (completedResult?.success && completedResult?.data) {
+                    const completedBuys = (completedResult.data.media_buys || []);
+                    if (completedBuys.length > 0) {
+                        const completedId = completedBuys[0].media_buy_id;
+                        completedStep.details = `Found completed media buy: ${completedId}`;
+                        steps.push(completedStep);
+                        // Try to update the completed media buy
+                        const { result: updateCompletedResult, step: updateCompletedStep } = await (0, client_1.runStep)('Update completed media buy (expect rejection)', 'update_media_buy', async () => client.updateMediaBuy({
+                            media_buy_id: completedId,
+                            paused: true,
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+                        }));
+                        if (updateCompletedResult?.success) {
+                            updateCompletedStep.passed = false;
+                            updateCompletedStep.error =
+                                'Agent accepted update to completed media buy — should reject with INVALID_STATE';
+                        }
+                        else if (updateCompletedResult) {
+                            updateCompletedStep.passed = true;
+                            const err = updateCompletedResult.error || '';
+                            const hasCode = err.includes('INVALID_STATE') || err.includes('invalid_state');
+                            updateCompletedStep.details = hasCode
+                                ? 'Correctly rejected update to completed media buy with INVALID_STATE'
+                                : `Correctly rejected update to completed media buy: ${err}`;
+                            if (!hasCode && err) {
+                                updateCompletedStep.warnings = ['Agent rejected the update but did not use INVALID_STATE error code'];
+                            }
+                        }
+                        steps.push(updateCompletedStep);
+                    }
+                    else {
+                        completedStep.details = 'No completed media buys found — cannot test terminal state enforcement';
+                        steps.push(completedStep);
+                    }
+                }
+                else {
+                    completedStep.passed = false;
+                    completedStep.error = completedResult?.error || 'Failed to query for completed media buys';
+                    steps.push(completedStep);
+                }
+            }
+            return { steps, profile };
+        }
+        cancelStep.passed = false;
+        cancelStep.error = cancelResult.error || 'Cancel setup failed';
+    }
+    steps.push(cancelStep);
+    // Try to pause the canceled media buy — should be rejected
+    const { result: pauseTerminalResult, step: pauseTerminalStep } = await (0, client_1.runStep)('Update canceled media buy (expect rejection)', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        paused: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (pauseTerminalResult?.success) {
+        pauseTerminalStep.passed = false;
+        pauseTerminalStep.error = 'Agent accepted update to canceled media buy — should reject with INVALID_STATE';
+    }
+    else if (pauseTerminalResult) {
+        // Agent returned { success: false } — correct behavior
+        pauseTerminalStep.passed = true;
+        const error = pauseTerminalResult.error || '';
+        const hasExpectedCode = error.includes('INVALID_STATE') || error.includes('invalid_state');
+        pauseTerminalStep.details = hasExpectedCode
+            ? 'Correctly rejected with INVALID_STATE'
+            : `Correctly rejected update to canceled media buy: ${error}`;
+        if (!hasExpectedCode && error) {
+            pauseTerminalStep.warnings = ['Agent rejected the update but did not use INVALID_STATE error code'];
+        }
+    }
+    // else: result is undefined (exception thrown) — runStep already set passed=false and error
+    steps.push(pauseTerminalStep);
+    // Try to cancel again — should also be rejected (or idempotent)
+    const { result: reCancelResult, step: reCancelStep } = await (0, client_1.runStep)('Cancel already-canceled media buy (expect rejection)', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        canceled: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (reCancelResult?.success) {
+        // Idempotent cancellation is acceptable
+        reCancelStep.passed = true;
+        reCancelStep.details = 'Agent accepted re-cancellation (idempotent) — acceptable behavior';
+    }
+    else if (reCancelResult) {
+        reCancelStep.passed = true;
+        const error = reCancelResult.error || '';
+        reCancelStep.details = `Correctly rejected re-cancellation: ${error}`;
+    }
+    steps.push(reCancelStep);
+    // Also check completed terminal state if get_media_buys is available
+    if (profile.tools.includes('get_media_buys')) {
+        const { result: completedResult } = await (0, client_1.runStep)('Find completed media buy', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+            status_filter: ['completed'],
+            pagination: { max_results: 1 },
+        }));
+        if (completedResult?.success && completedResult?.data) {
+            const completedBuys = (completedResult.data.media_buys || []);
+            if (completedBuys.length > 0) {
+                const completedId = completedBuys[0].media_buy_id;
+                const { result: updateCompletedResult, step: updateCompletedStep } = await (0, client_1.runStep)('Update completed media buy (expect rejection)', 'update_media_buy', async () => client.updateMediaBuy({
+                    media_buy_id: completedId,
+                    paused: true,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+                }));
+                if (updateCompletedResult?.success) {
+                    updateCompletedStep.passed = false;
+                    updateCompletedStep.error = 'Agent accepted update to completed media buy — should reject with INVALID_STATE';
+                }
+                else if (updateCompletedResult) {
+                    updateCompletedStep.passed = true;
+                    const err = updateCompletedResult.error || '';
+                    const hasCode = err.includes('INVALID_STATE') || err.includes('invalid_state');
+                    updateCompletedStep.details = hasCode
+                        ? 'Correctly rejected update to completed media buy with INVALID_STATE'
+                        : `Correctly rejected update to completed media buy: ${err}`;
+                }
+                steps.push(updateCompletedStep);
+            }
+        }
+    }
+    return { steps, profile };
+}
+/**
+ * Test: Package Lifecycle
+ * Tests package-level pause/resume independent of media buy status.
+ */
+async function testPackageLifecycle(agentUrl, options) {
+    const steps = [];
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
+    // Create a media buy
+    const { steps: createSteps, profile, mediaBuyId } = await testCreateMediaBuy(agentUrl, options);
+    steps.push(...createSteps);
+    if (!mediaBuyId || !profile?.tools.includes('update_media_buy')) {
+        return { steps, profile };
+    }
+    // Find a package ID — try get_media_buys first, fall back to convention
+    let packageId = 'pkg-0';
+    if (profile.tools.includes('get_media_buys')) {
+        const { result: fetchResult, step: fetchStep } = await (0, client_1.runStep)('Fetch package IDs', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+            media_buy_ids: [mediaBuyId],
+        }));
+        if (fetchResult?.success && fetchResult?.data) {
+            const mediaBuys = (fetchResult.data.media_buys || []);
+            const mediaBuy = mediaBuys.find((item) => item.media_buy_id === mediaBuyId) || mediaBuys[0];
+            const packages = (mediaBuy?.packages || []);
+            if (packages[0]?.package_id) {
+                packageId = packages[0].package_id;
+                fetchStep.details = `Found package ${packageId}`;
+            }
+            else {
+                fetchStep.details = `No packages found, falling back to '${packageId}'`;
+            }
+        }
+        else if (fetchResult && !fetchResult.success) {
+            fetchStep.passed = false;
+            fetchStep.error = fetchResult.error || 'get_media_buys failed during package ID discovery';
+        }
+        steps.push(fetchStep);
+    }
+    // Step 1: Pause a package
+    const { result: pauseResult, step: pauseStep } = await (0, client_1.runStep)('Pause package', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        packages: [{ package_id: packageId, paused: true }],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (pauseResult?.success && pauseResult?.data) {
+        const data = pauseResult.data;
+        const affectedPackages = (data.affected_packages || []);
+        const pkg = affectedPackages.find(p => p.package_id === packageId) || affectedPackages[0];
+        pauseStep.details = `Paused package ${packageId}, paused: ${pkg?.paused}`;
+        pauseStep.response_preview = JSON.stringify({
+            media_buy_id: mediaBuyId,
+            media_buy_status: extractStatus(data),
+            package_id: pkg?.package_id,
+            package_paused: pkg?.paused,
+        }, null, 2);
+    }
+    else if (pauseResult && !pauseResult.success) {
+        pauseStep.passed = false;
+        pauseStep.error = pauseResult.error || 'Package pause failed';
+    }
+    steps.push(pauseStep);
+    // Step 2: Resume the package
+    const { result: resumeResult, step: resumeStep } = await (0, client_1.runStep)('Resume package', 'update_media_buy', async () => client.updateMediaBuy({
+        media_buy_id: mediaBuyId,
+        packages: [{ package_id: packageId, paused: false }],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
+    }));
+    if (resumeResult?.success && resumeResult?.data) {
+        const data = resumeResult.data;
+        const affectedPackages = (data.affected_packages || []);
+        const pkg = affectedPackages.find(p => p.package_id === packageId) || affectedPackages[0];
+        resumeStep.details = `Resumed package ${packageId}, paused: ${pkg?.paused}`;
+        resumeStep.response_preview = JSON.stringify({
+            media_buy_id: mediaBuyId,
+            media_buy_status: extractStatus(data),
+            package_id: pkg?.package_id,
+            package_paused: pkg?.paused,
+        }, null, 2);
+    }
+    else if (resumeResult && !resumeResult.success) {
+        resumeStep.passed = false;
+        resumeStep.error = resumeResult.error || 'Package resume failed';
+    }
+    steps.push(resumeStep);
+    // Step 3: Verify media buy is still active
+    if (profile.tools.includes('get_media_buys')) {
+        const { result: verifyResult, step: verifyStep } = await (0, client_1.runStep)('Verify media buy still active after package operations', 'get_media_buys', async () => client.executeTask('get_media_buys', {
+            media_buy_ids: [mediaBuyId],
+        }));
+        if (verifyResult?.success && verifyResult?.data) {
+            const mediaBuys = (verifyResult.data.media_buys || []);
+            const mediaBuy = mediaBuys.find((item) => item.media_buy_id === mediaBuyId) || mediaBuys[0];
+            const status = mediaBuy?.status;
+            if (status === 'active' || status === 'pending_start') {
+                verifyStep.details = `Media buy still ${status} after package-level operations`;
+            }
+            else {
+                verifyStep.details = `Media buy status is '${status}' — expected 'active' or 'pending_start'`;
+                verifyStep.warnings = [`Package-level pause/resume changed media buy status to '${status}'`];
+            }
+            verifyStep.response_preview = JSON.stringify({ media_buy_id: mediaBuy?.media_buy_id, status }, null, 2);
+        }
+        else if (verifyResult && !verifyResult.success) {
+            verifyStep.passed = false;
+            verifyStep.error = verifyResult.error || 'get_media_buys verification failed';
+        }
+        steps.push(verifyStep);
+    }
+    return { steps, profile };
+}
+//# sourceMappingURL=media-buy.js.map