get_media_buys

import { testAgent } from '@adcp/sdk/testing';
import { GetMediaBuysResponseSchema, type WebhookActivityRecord } from '@adcp/sdk';

// The WebhookActivityRecord type is regenerated by the SDK from
// /schemas/core/webhook-activity-record.json — once the SDK rebuilds against this
// branch's schemas the import resolves. The same type appears on every AdCP resource
// that surfaces webhook_activity[], so debug helpers can be written once and reused.
function latestAttempt(trail: WebhookActivityRecord[]): WebhookActivityRecord {
  return trail.reduce((a, b) => (a.attempt >= b.attempt ? a : b));
}

const result = await testAgent.getMediaBuys({
  media_buy_ids: ['mb_12345'],
  include_webhook_activity: true,
  webhook_activity_limit: 20,
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);

for (const mediaBuy of validated.media_buys) {
  // Three-state semantics — distinguish "seller does not surface" from "no recent fires".
  if (mediaBuy.webhook_activity === undefined) {
    console.log(`${mediaBuy.media_buy_id}: seller does not surface webhook activity for this buy`);
    continue;
  }

  const fires = mediaBuy.webhook_activity;
  if (fires.length === 0) {
    console.log(`${mediaBuy.media_buy_id}: no recent fires for this principal`);
    continue;
  }

  // Group attempts by idempotency_key so we can see the retry trail per logical fire.
  const trails = new Map();
  for (const fire of fires) {
    const trail = trails.get(fire.idempotency_key) ?? [];
    trail.push(fire);
    trails.set(fire.idempotency_key, trail);
  }

  for (const [idempotencyKey, trail] of trails) {
    // Pick the latest attempt by `attempt` number — robust against any iteration order.
    const latest = latestAttempt(trail);
    if (latest.status === 'success') continue;

    const detail = latest.error_message ?? latest.http_status_code ?? '—';
    console.log(
      `${mediaBuy.media_buy_id} ${idempotencyKey} ` +
      `(${latest.notification_type} seq=${latest.sequence_number}): ` +
      `${latest.status} after ${trail.length} attempt(s) — ${detail}`
    );
  }
}

import asyncio
from collections import defaultdict
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest, WebhookActivityRecord

# WebhookActivityRecord is regenerated by the SDK from
# /schemas/core/webhook-activity-record.json — once the SDK rebuilds against this
# branch's schemas the import resolves. The same type appears on every AdCP resource
# that surfaces webhook_activity[].
def latest_attempt(trail: list[WebhookActivityRecord]) -> WebhookActivityRecord:
    return max(trail, key=lambda f: f.attempt)

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(
            media_buy_ids=['mb_12345'],
            include_webhook_activity=True,
            webhook_activity_limit=20,
        )
    )

    for media_buy in result.media_buys:
        # Three-state semantics: distinguish "seller does not surface" from "no recent fires".
        if media_buy.webhook_activity is None:
            print(f"{media_buy.media_buy_id}: seller does not surface webhook activity for this buy")
            continue

        fires = media_buy.webhook_activity
        if not fires:
            print(f"{media_buy.media_buy_id}: no recent fires for this principal")
            continue

        trails = defaultdict(list)
        for fire in fires:
            trails[fire.idempotency_key].append(fire)

        for idempotency_key, trail in trails.items():
            latest = latest_attempt(trail)
            if latest.status == 'success':
                continue

            detail = latest.error_message or latest.http_status_code or '—'
            print(f"{media_buy.media_buy_id} {idempotency_key} "
                  f"({latest.notification_type} seq={latest.sequence_number}): "
                  f"{latest.status} after {len(trail)} attempt(s) — {detail}")

asyncio.run(main())

import { testAgent } from '@adcp/sdk/testing';
import { GetMediaBuysResponseSchema } from '@adcp/sdk';

const result = await testAgent.getMediaBuys({
  media_buy_ids: ['mb_12345']
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);

if (validated.errors?.length > 0) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

for (const mediaBuy of validated.media_buys) {
  for (const pkg of mediaBuy.packages) {
    // Check for missing creatives
    if (pkg.format_ids_pending?.length > 0) {
      console.log(`Package ${pkg.package_id}: missing formats ${pkg.format_ids_pending.map(f => f.id).join(', ')}`);
    }

    // Check approval states
    for (const approval of pkg.creative_approvals ?? []) {
      if (approval.approval_status === 'rejected') {
        console.log(`Creative ${approval.creative_id} rejected: ${approval.rejection_reason}`);
      } else if (approval.approval_status === 'pending_review') {
        console.log(`Creative ${approval.creative_id} pending review`);
      }
    }
  }
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(media_buy_ids=['mb_12345'])
    )

    if result.errors:
        raise Exception(f"Query failed: {result.errors}")

    for media_buy in result.media_buys:
        for pkg in media_buy.packages:
            # Check for missing creatives
            if pkg.format_ids_pending:
                ids = [f.id for f in pkg.format_ids_pending]
                print(f"Package {pkg.package_id}: missing formats {', '.join(ids)}")

            # Check approval states
            for approval in pkg.creative_approvals or []:
                if approval.approval_status == 'rejected':
                    print(f"Creative {approval.creative_id} rejected: {approval.rejection_reason}")
                elif approval.approval_status == 'pending_review':
                    print(f"Creative {approval.creative_id} pending review")

asyncio.run(main())

import { testAgent } from '@adcp/sdk/testing';
import { GetMediaBuysResponseSchema } from '@adcp/sdk';

const result = await testAgent.getMediaBuys({
  status_filter: 'active',
  include_snapshot: true
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);

for (const mediaBuy of validated.media_buys) {
  for (const pkg of mediaBuy.packages) {
    const snap = pkg.snapshot;
    if (!snap) continue;

    if (snap.delivery_status === 'not_delivering') {
      console.log(`Package ${pkg.package_id}: zero delivery (data up to ${snap.staleness_seconds}s old)`);
    } else if (snap.pacing_index !== undefined && snap.pacing_index < 0.8) {
      console.log(`Package ${pkg.package_id}: underpacing at ${(snap.pacing_index * 100).toFixed(0)}%`);
    } else {
      console.log(`Package ${pkg.package_id}: ${snap.impressions.toLocaleString()} impressions, pacing ${snap.pacing_index?.toFixed(2)}`);
    }
  }
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(
            status_filter='active',
            include_snapshot=True
        )
    )

    if result.errors:
        raise Exception(f"Query failed: {result.errors}")

    for media_buy in result.media_buys:
        for pkg in media_buy.packages:
            snap = pkg.snapshot
            if not snap:
                continue

            if snap.delivery_status == 'not_delivering':
                print(f"Package {pkg.package_id}: zero delivery (data up to {snap.staleness_seconds}s old)")
            elif snap.pacing_index is not None and snap.pacing_index < 0.8:
                print(f"Package {pkg.package_id}: underpacing at {snap.pacing_index * 100:.0f}%")
            else:
                print(f"Package {pkg.package_id}: {snap.impressions:,} impressions, pacing {snap.pacing_index:.2f}")

asyncio.run(main())

import { testAgent } from '@adcp/sdk/testing';
import { GetMediaBuysResponseSchema } from '@adcp/sdk';

const result = await testAgent.getMediaBuys({
  media_buy_ids: ['mb_12345']
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);
const [mediaBuy] = validated.media_buys;
const issues = [];

for (const pkg of mediaBuy.packages) {
  if (pkg.format_ids_pending?.length > 0) {
    issues.push(`Package ${pkg.package_id}: ${pkg.format_ids_pending.length} format(s) not yet uploaded`);
  }

  const rejected = (pkg.creative_approvals ?? []).filter(a => a.approval_status === 'rejected');
  if (rejected.length > 0) {
    issues.push(`Package ${pkg.package_id}: ${rejected.length} creative(s) rejected`);
  }
}

if (issues.length === 0) {
  console.log('Campaign ready to launch');
} else {
  console.log('Campaign has blocking issues:');
  issues.forEach(issue => console.log(`  - ${issue}`));
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(media_buy_ids=['mb_12345'])
    )

    media_buy = result.media_buys[0]
    issues = []

    for pkg in media_buy.packages:
        if pkg.format_ids_pending:
            issues.append(f"Package {pkg.package_id}: {len(pkg.format_ids_pending)} format(s) not yet uploaded")

        rejected = [a for a in (pkg.creative_approvals or []) if a.approval_status == 'rejected']
        if rejected:
            issues.append(f"Package {pkg.package_id}: {len(rejected)} creative(s) rejected")

    if not issues:
        print("Campaign ready to launch")
    else:
        print("Campaign has blocking issues:")
        for issue in issues:
            print(f"  - {issue}")

asyncio.run(main())