@adcp/client 4.8.0 → 4.10.0

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

@@ -16,6 +16,7 @@ exports.testCreateMediaBuy = testCreateMediaBuy;
 exports.testFullSalesFlow = testFullSalesFlow;
 exports.testCreativeSync = testCreativeSync;
 exports.testCreativeInline = testCreativeInline;
+exports.testCreativeReference = testCreativeReference;
 exports.resolveAccountForAudiences = resolveAccountForAudiences;
 exports.testSyncAudiences = testSyncAudiences;
 const client_1 = require("../client");
@@ -27,11 +28,11 @@ 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)));
+        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.model)));
+        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;
@@ -42,7 +43,7 @@ function selectProduct(products, options) {
 function selectPricingOption(product, preferredModels) {
     const options = product.pricing_options || [];
     if (preferredModels?.length) {
-        const preferred = options.find((po) => preferredModels.includes(po.model));
+        const preferred = options.find((po) => preferredModels.includes(po.pricing_model));
         if (preferred)
             return preferred;
     }
@@ -52,11 +53,13 @@ function selectPricingOption(product, preferredModels) {
  * Build a create_media_buy request
  */
 function buildCreateMediaBuyRequest(product, pricingOption, options, extras = {}) {
-    const budget = options.budget || 1000;
+    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 = pricingOption.model === 'auction' || pricingOption.is_fixed === false || pricingOption.floor_price !== undefined;
+    const isAuction = !('fixed_price' in pricingOption) &&
+        (pricingOption.floor_price !== undefined || pricingOption.price_guidance !== undefined);
     const packageRequest = {
         buyer_ref: `pkg-test-${Date.now()}`,
         product_id: product.product_id,
@@ -83,6 +86,56 @@ function buildCreateMediaBuyRequest(product, pricingOption, options, extras = {}
         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) {
+    return {
+        name: `Inline Test Creative ${Date.now()}`,
+        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
@@ -104,12 +157,14 @@ async function testCreateMediaBuy(agentUrl, options) {
         return { steps, profile };
     }
     // Get products
-    const { result: productsResult } = await (0, client_1.runStep)('Fetch products for media buy', 'get_products', async () => client.executeTask('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 products = productsResult?.data?.products;
+    const productsData = productsResult?.data;
+    const products = productsData?.products;
     if (!productsResult?.success || !products?.length) {
         steps.push({
             step: 'Create media buy',
@@ -121,6 +176,16 @@ async function testCreateMediaBuy(agentUrl, options) {
         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({
@@ -134,20 +199,23 @@ async function testCreateMediaBuy(agentUrl, options) {
     }
     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', async () => client.executeTask('create_media_buy', createRequest));
+    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) {
         const mediaBuy = createResult.data;
-        mediaBuyId = mediaBuy.media_buy_id || mediaBuy.media_buy?.media_buy_id;
-        const status = mediaBuy.status || mediaBuy.media_buy?.status;
-        const packages = mediaBuy.packages || mediaBuy.media_buy?.packages;
+        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;
         createStep.response_preview = JSON.stringify({
             media_buy_id: mediaBuyId,
             status,
             packages_count: packages?.length,
-            pricing_model: pricingOption.model,
+            pricing_model: pricingOption.pricing_model,
             product_name: product.name,
         }, null, 2);
     }
@@ -173,7 +241,7 @@ async function testFullSalesFlow(agentUrl, options) {
     }
     // 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.executeTask('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: [
                 {
@@ -181,13 +249,15 @@ async function testFullSalesFlow(agentUrl, options) {
                     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 status = data.status || data.media_buy?.status;
+            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 || data.media_buy?.media_buy_id,
+                media_buy_id: (data.media_buy_id || nested?.media_buy_id),
                 status,
             }, null, 2);
         }
@@ -197,16 +267,61 @@ async function testFullSalesFlow(agentUrl, options) {
         }
         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) {
+            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);
+            }
+        }
+        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.executeTask('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: !!(delivery.deliveries?.length || delivery.media_buys?.length),
+                has_deliveries: !!(deliveries?.length || mediaBuys?.length),
             }, null, 2);
         }
         else if (deliveryResult && !deliveryResult.success) {
@@ -238,14 +353,25 @@ async function testCreativeSync(agentUrl, options) {
         return { steps, profile };
     }
     // Get format info first
-    let formatId = 'display_300x250'; // Default
+    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.executeTask('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 firstFormat = data.format_ids?.[0] || data.formats?.[0];
+            const formatIds = data.format_ids;
+            const formats = data.formats;
+            const firstFormat = formatIds?.[0] || formats?.[0];
             if (firstFormat) {
-                formatId = typeof firstFormat === 'string' ? firstFormat : firstFormat.id || firstFormat.format_id;
+                if (typeof firstFormat === 'string') {
+                    formatId = { id: firstFormat };
+                }
+                else {
+                    const formatObj = firstFormat;
+                    formatId = formatObj.format_id || formatObj;
+                }
             }
         }
     }
@@ -264,18 +390,20 @@ async function testCreativeSync(agentUrl, options) {
             },
         },
     };
-    const { result: syncResult, step: syncStep } = await (0, client_1.runStep)('Sync creative to library', 'sync_creatives', async () => client.executeTask('sync_creatives', {
+    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);
+        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),
+            creative_ids: creatives.map(c => c.creative_id),
         }, null, 2);
     }
     else if (syncResult && !syncResult.success) {
@@ -285,7 +413,7 @@ async function testCreativeSync(agentUrl, options) {
     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.executeTask('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 || [];
@@ -308,7 +436,7 @@ async function testCreativeSync(agentUrl, options) {
                 listStep.response_preview = JSON.stringify({
                     creatives_count: creatives.length,
                     total_matching: totalMatching,
-                    statuses: Array.from(new Set(creatives.map((c) => c.status))),
+                    statuses: Array.from(new Set(creatives.map(c => c.status))),
                 }, null, 2);
             }
         }
@@ -341,12 +469,14 @@ async function testCreativeInline(agentUrl, options) {
         return { steps, profile };
     }
     // Get products
-    const { result: productsResult } = await (0, client_1.runStep)('Fetch products for inline creative test', 'get_products', async () => client.executeTask('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 products = productsResult?.data?.products;
+    const inlineProductsData = productsResult?.data;
+    const products = inlineProductsData?.products;
     if (!productsResult?.success || !products?.length) {
         steps.push({
             step: 'Create media buy with inline creatives',
@@ -358,6 +488,16 @@ async function testCreativeInline(agentUrl, options) {
         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({
@@ -369,35 +509,53 @@ async function testCreativeInline(agentUrl, options) {
         });
         return { steps, profile };
     }
-    // Get format for inline creative
-    let formatId = 'display_300x250';
-    if (product.format_ids?.length) {
-        const fid = product.format_ids[0];
-        formatId = typeof fid === 'string' ? fid : fid.id || fid.format_id || formatId;
+    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);
     }
-    // Build inline creative
-    const inlineCreative = {
-        name: `Inline Test Creative ${Date.now()}`,
-        format_id: formatId,
-        assets: {
-            primary: {
-                url: 'https://via.placeholder.com/300x250?text=Inline+Creative',
-                width: 300,
-                height: 250,
-                format: 'png',
-            },
-        },
-    };
     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', async () => client.executeTask('create_media_buy', createRequest));
+    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) {
         const mediaBuy = createResult.data;
-        const mediaBuyId = mediaBuy.media_buy_id || mediaBuy.media_buy?.media_buy_id;
-        const status = mediaBuy.status || mediaBuy.media_buy?.status;
-        const packages = mediaBuy.packages || mediaBuy.media_buy?.packages;
-        const hasCreatives = packages?.some((p) => p.creatives?.length || p.creative_ids?.length);
+        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({
@@ -414,6 +572,131 @@ async function testCreativeInline(agentUrl, options) {
     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.createTestClient)(agentUrl, options.protocol || 'mcp', 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) {
+        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);
@@ -432,7 +715,10 @@ async function resolveAccountForAudiences(options, tools, listAccounts) {
     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 sandboxAccounts = sandboxResult?.success ? (sandboxResult.data?.accounts ?? []) : [];
+        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);
@@ -459,7 +745,8 @@ async function resolveAccountForAudiences(options, tools, listAccounts) {
     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 accounts = accountsResult.data.accounts ?? [];
+            const accountsData = accountsResult.data;
+            const accounts = accountsData.accounts ?? [];
             if (accounts[0]?.account_id) {
                 accountsStep.details = `Using account: ${accounts[0].account_id}`;
                 steps.push(accountsStep);
@@ -497,7 +784,9 @@ async function testSyncAudiences(agentUrl, options) {
         });
         return { steps, profile };
     }
-    const { accountRef, steps: accountSteps } = await resolveAccountForAudiences(options, profile.tools, async (params) => client.executeTask('list_accounts', params));
+    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({
@@ -510,15 +799,17 @@ async function testSyncAudiences(agentUrl, options) {
         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.executeTask('sync_audiences', {
+    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 audiences = discoveryResult.data.audiences ?? [];
+        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),
+            audience_ids: audiences.map(a => a.audience_id).slice(0, 5),
         }, null, 2);
     }
     else if (discoveryResult && !discoveryResult.success) {
@@ -531,7 +822,7 @@ async function testSyncAudiences(agentUrl, options) {
     }
     // 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.executeTask('sync_audiences', {
+    const { result: createResult, step: createStep } = await (0, client_1.runStep)('Create test audience', 'sync_audiences', async () => client.syncAudiences({
         account: accountRef,
         audiences: [
             {
@@ -540,10 +831,12 @@ async function testSyncAudiences(agentUrl, options) {
                 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 audiences = createResult.data.audiences ?? [];
-        const testAudience = audiences.find((a) => a.audience_id === testAudienceId);
+        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({
@@ -562,7 +855,7 @@ async function testSyncAudiences(agentUrl, options) {
         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.executeTask('sync_audiences', {
+    const { result: deleteResult, step: deleteStep } = await (0, client_1.runStep)('Delete test audience', 'sync_audiences', async () => client.syncAudiences({
         account: accountRef,
         audiences: [
             {
@@ -570,10 +863,12 @@ async function testSyncAudiences(agentUrl, options) {
                 delete: true,
             },
         ],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- intentional: test request bypasses strict typing
     }));
     if (deleteResult?.success && deleteResult?.data) {
-        const audiences = deleteResult.data.audiences ?? [];
-        const deleted = audiences.find((a) => a.audience_id === testAudienceId);
+        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,