@adcp/client 4.14.0 → 4.16.0

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

@@ -64,7 +64,6 @@ function buildCreateMediaBuyRequest(product, pricingOption, options, extras = {}
     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,
         budget,
         pricing_option_id: pricingOption.pricing_option_id,
@@ -82,7 +81,6 @@ function buildCreateMediaBuyRequest(product, pricingOption, options, extras = {}
         packageRequest.creative_ids = extras.creative_ids;
     }
     return {
-        buyer_ref: `e2e-test-${Date.now()}`,
         account: (0, client_1.resolveAccount)(options),
         brand: (0, client_1.resolveBrand)(options),
         start_time: startTime.toISOString(),
@@ -148,7 +146,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);
@@ -218,9 +216,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,
@@ -239,7 +243,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);
@@ -346,9 +350,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({
@@ -462,7 +466,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);
@@ -607,7 +611,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')) {
@@ -797,9 +801,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 };
@@ -874,7 +878,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;
@@ -928,13 +944,15 @@ function extractStatus(data) {
  */
 async function testMediaBuyLifecycle(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    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,
@@ -944,8 +962,11 @@ async function testMediaBuyLifecycle(agentUrl, options) {
     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 }, null, 2);
+        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}'`];
         }
@@ -964,8 +985,11 @@ async function testMediaBuyLifecycle(agentUrl, options) {
     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 }, null, 2);
+        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}'`];
         }
@@ -975,10 +999,55 @@ async function testMediaBuyLifecycle(agentUrl, options) {
         resumeStep.error = resumeResult.error || 'Resume operation failed';
     }
     steps.push(resumeStep);
-    // Step 3: Get status and check valid_actions (if get_media_buys available)
+    // 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 || []);
@@ -989,11 +1058,30 @@ async function testMediaBuyLifecycle(agentUrl, options) {
             }
             else {
                 const validActions = mediaBuy.valid_actions;
-                statusStep.details = `Status: ${mediaBuy.status}, valid_actions: ${validActions ? validActions.join(', ') : 'not provided'}`;
+                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);
             }
         }
@@ -1003,6 +1091,62 @@ async function testMediaBuyLifecycle(agentUrl, options) {
         }
         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,
@@ -1013,8 +1157,13 @@ async function testMediaBuyLifecycle(agentUrl, options) {
     if (cancelResult?.success && cancelResult?.data) {
         const data = cancelResult.data;
         const status = extractStatus(data);
+        const cancelRevision = data.revision;
         cancelStep.details = `Canceled media buy, status: ${status}`;
-        cancelStep.response_preview = JSON.stringify({ media_buy_id: mediaBuyId, status }, null, 2);
+        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}'`];
         }
@@ -1040,7 +1189,7 @@ async function testMediaBuyLifecycle(agentUrl, options) {
  */
 async function testTerminalStateEnforcement(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    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);
@@ -1061,10 +1210,57 @@ async function testTerminalStateEnforcement(agentUrl, options) {
     else if (cancelResult && !cancelResult.success) {
         const error = cancelResult.error || '';
         if (error.includes('NOT_CANCELLABLE') || error.includes('not_cancellable')) {
-            // Agent doesn't support cancellation — can't test terminal state enforcement
+            // Agent doesn't support cancellation — try to find a completed buy instead
             cancelStep.passed = true;
-            cancelStep.details = 'Agent does not support cancellation — skipping terminal state tests';
+            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;
@@ -1072,29 +1268,29 @@ async function testTerminalStateEnforcement(agentUrl, options) {
     }
     steps.push(cancelStep);
     // Try to pause the canceled media buy — should be rejected
-    const { result: pauseResult, step: pauseStep } = await (0, client_1.runStep)('Update canceled media buy (expect rejection)', 'update_media_buy', async () => client.updateMediaBuy({
+    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 (pauseResult?.success) {
-        pauseStep.passed = false;
-        pauseStep.error = 'Agent accepted update to canceled media buy — should reject with INVALID_STATE';
+    if (pauseTerminalResult?.success) {
+        pauseTerminalStep.passed = false;
+        pauseTerminalStep.error = 'Agent accepted update to canceled media buy — should reject with INVALID_STATE';
     }
-    else if (pauseResult) {
+    else if (pauseTerminalResult) {
         // Agent returned { success: false } — correct behavior
-        pauseStep.passed = true;
-        const error = pauseResult.error || '';
+        pauseTerminalStep.passed = true;
+        const error = pauseTerminalResult.error || '';
         const hasExpectedCode = error.includes('INVALID_STATE') || error.includes('invalid_state');
-        pauseStep.details = hasExpectedCode
+        pauseTerminalStep.details = hasExpectedCode
             ? 'Correctly rejected with INVALID_STATE'
             : `Correctly rejected update to canceled media buy: ${error}`;
         if (!hasExpectedCode && error) {
-            pauseStep.warnings = ['Agent rejected the update but did not use INVALID_STATE error code'];
+            pauseTerminalStep.warnings = ['Agent rejected the update but did not use INVALID_STATE error code'];
         }
     }
-    // else: pauseResult is undefined (exception thrown) — runStep already set passed=false and error
-    steps.push(pauseStep);
+    // 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,
@@ -1112,6 +1308,37 @@ async function testTerminalStateEnforcement(agentUrl, options) {
         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 };
 }
 /**
@@ -1120,7 +1347,7 @@ async function testTerminalStateEnforcement(agentUrl, options) {
  */
 async function testPackageLifecycle(agentUrl, options) {
     const steps = [];
-    const client = (0, client_1.createTestClient)(agentUrl, options.protocol || 'mcp', options);
+    const client = (0, client_1.getOrCreateClient)(agentUrl, options);
     // Create a media buy
     const { steps: createSteps, profile, mediaBuyId } = await testCreateMediaBuy(agentUrl, options);
     steps.push(...createSteps);