@adcp/client 4.13.0 → 4.15.0

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

@@ -19,6 +19,9 @@ 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");
 /**
@@ -145,7 +148,7 @@ function buildSyncCreativeFromManifest(manifest, fallbackFormatId) {
  */
 async function testCreateMediaBuy(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    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);
@@ -207,6 +210,7 @@ async function testCreateMediaBuy(agentUrl, options) {
     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);
@@ -214,9 +218,15 @@ async function testCreateMediaBuy(agentUrl, options) {
         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,
@@ -235,7 +245,7 @@ async function testCreateMediaBuy(agentUrl, options) {
  */
 async function testFullSalesFlow(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    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);
@@ -276,6 +286,7 @@ async function testFullSalesFlow(agentUrl, options) {
             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 || [];
@@ -341,9 +352,9 @@ async function testFullSalesFlow(agentUrl, options) {
  */
 async function testCreativeSync(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Discover profile
-    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profile.tools.includes('sync_creatives')) {
         steps.push({
@@ -457,7 +468,7 @@ async function testCreativeSync(agentUrl, options) {
  */
 async function testCreativeInline(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Discovery first
     const { steps: discoverySteps, profile } = await (0, discovery_1.testDiscovery)(agentUrl, options);
     steps.push(...discoverySteps);
@@ -569,6 +580,7 @@ async function testCreativeInline(agentUrl, options) {
     // 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);
@@ -601,7 +613,7 @@ async function testCreativeInline(agentUrl, options) {
  */
 async function testCreativeReference(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    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')) {
@@ -701,6 +713,7 @@ async function testCreativeReference(agentUrl, options) {
     });
     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;
@@ -790,9 +803,9 @@ async function resolveAccountForAudiences(options, tools, listAccounts) {
  */
 async function testSyncAudiences(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Discover agent profile
-    const { profile, step: profileStep } = await (0, client_1.discoverAgentProfile)(client);
+    const { profile, step: profileStep } = await (0, client_1.getOrDiscoverProfile)(client, options);
     steps.push(profileStep);
     if (!profileStep.passed) {
         return { steps, profile };
@@ -867,7 +880,19 @@ async function testSyncAudiences(agentUrl, options) {
             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;
@@ -905,4 +930,526 @@ async function testSyncAudiences(agentUrl, options) {
     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_activation') {
+            resumeStep.warnings = [`Expected status 'active' or 'pending_activation', 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);
+            }
+        }
+        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 status = extractStatus(data);
+        const cancelRevision = data.revision;
+        cancelStep.details = `Canceled media buy, status: ${status}`;
+        const canceledBy = data.canceled_by;
+        const canceledAt = data.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);
+        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_activation') {
+                verifyStep.details = `Media buy still ${status} after package-level operations`;
+            }
+            else {
+                verifyStep.details = `Media buy status is '${status}' — expected 'active' or 'pending_activation'`;
+                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