update_media_buy

import { testAgent } from '@adcp/sdk/testing';
import { CreateMediaBuyResponseSchema, UpdateMediaBuyResponseSchema } from '@adcp/sdk';

// First, create a media buy to update
const uniqueRef = `test_campaign_${Date.now()}`;

// Use dates in the future
const startDate = new Date();
startDate.setDate(startDate.getDate() + 7); // Start 1 week from now
const endDate = new Date();
endDate.setDate(endDate.getDate() + 37); // End 5 weeks from now

const createResult = await testAgent.createMediaBuy({
  brand: { domain: 'acmecorp.com' },
  packages: [{
    product_id: 'prod_d979b543',
    pricing_option_id: 'cpm_usd_fixed',
    format_option_refs: [{ scope: 'product', format_option_id: 'display_300x250_image' }],
    budget: 800,
    bidding: { bid_amount: 5.00 }
  }],
  start_time: startDate.toISOString(),
  end_time: endDate.toISOString()
});

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

const created = CreateMediaBuyResponseSchema.parse(createResult.data);
if ('errors' in created && created.errors) {
  throw new Error(`Create failed: ${JSON.stringify(created.errors)}`);
}

console.log(`Created media buy ${created.media_buy_id}`);

// Now update it - pause the campaign
const updateResult = await testAgent.updateMediaBuy({
  account: { brand: { domain: 'acmecorp.com' }, operator: 'acmecorp.com' },
  media_buy_id: created.media_buy_id,
  revision: created.revision,
  paused: true
});

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

const updated = UpdateMediaBuyResponseSchema.parse(updateResult.data);
if ('errors' in updated && updated.errors) {
  throw new Error(`Update failed: ${JSON.stringify(updated.errors)}`);
}

console.log(`Campaign ${updated.media_buy_id} paused`);

import asyncio
import time
from datetime import datetime, timedelta
from adcp.testing import test_agent

async def create_and_pause_campaign():
    # First, create a media buy to update
    unique_ref = f"test_campaign_{int(time.time() * 1000)}"

    # Use dates in the future
    start_date = datetime.utcnow() + timedelta(days=7)
    end_date = datetime.utcnow() + timedelta(days=37)

    create_result = await test_agent.simple.create_media_buy(
        brand={'domain': 'acmecorp.com'},
        packages=[{
            'product_id': 'prod_d979b543',
            'pricing_option_id': 'cpm_usd_fixed',
            'format_kind': 'image',
            'params': {'width': 300, 'height': 250},
            'budget': 800,
            'bidding': {'bid_amount': 5.00}
        }],
        start_time=start_date.strftime('%Y-%m-%dT%H:%M:%SZ'),
        end_time=end_date.strftime('%Y-%m-%dT%H:%M:%SZ')
    )

    if hasattr(create_result, 'errors') and create_result.errors:
        raise Exception(f"Create failed: {create_result.errors}")

    print(f"Created media buy {create_result.media_buy_id}")

    # Now update it - pause the campaign
    update_result = await test_agent.simple.update_media_buy(
        account={'brand': {'domain': 'acmecorp.com'}, 'operator': 'acmecorp.com'},
        media_buy_id=create_result.media_buy_id,
        revision=create_result.revision,
        paused=True
    )

    if hasattr(update_result, 'errors') and update_result.errors:
        raise Exception(f"Update failed: {update_result.errors}")

    print(f"Campaign {update_result.media_buy_id} paused")

asyncio.run(create_and_pause_campaign())

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

const result = await testAgent.updateMediaBuy({
  account: { account_id: 'acc_acme_001' },
  media_buy_id: 'mb_12345',
  packages: [{
    package_id: 'pkg_001',
    budget: 50000  // Increased from 30000
  }]
});

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

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

if ('errors' in validated && validated.errors) {
  throw new Error(`Update failed: ${JSON.stringify(validated.errors)}`);
}

const pkg = validated.affected_packages?.find(p => p.package_id === 'pkg_001');
if (pkg) {
  console.log(`Package budget updated to ${pkg.budget}`);
}

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

async def increase_budget():
    result = await test_agent.update_media_buy(
        UpdateMediaBuyRequest(
            account={'account_id': 'acc_acme_001'},
            media_buy_id='mb_12345',
            packages=[
                {'package_id': 'pkg_001', 'budget': 50000}
            ]
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Update failed: {result.errors}")

    pkg = next((p for p in result.affected_packages if p.package_id == 'pkg_001'), None)
    if pkg:
        print(f"Package budget updated to {pkg.budget}")

asyncio.run(increase_budget())

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

const result = await testAgent.updateMediaBuy({
  account: { account_id: 'acc_acme_001' },
  media_buy_id: 'mb_12345',
  end_time: '2025-09-30T23:59:59Z'
});

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

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

if ('errors' in validated && validated.errors) {
  throw new Error(`Update failed: ${JSON.stringify(validated.errors)}`);
}

console.log('Campaign end date extended');
console.log(`Effective: ${validated.implementation_date}`);

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

async def extend_campaign():
    result = await test_agent.update_media_buy(
        UpdateMediaBuyRequest(
            account={'account_id': 'acc_acme_001'},
            media_buy_id='mb_12345',
            end_time='2025-09-30T23:59:59Z'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Update failed: {result.errors}")

    print('Campaign end date extended')
    print(f"Effective: {result.implementation_date}")

asyncio.run(extend_campaign())

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

const result = await testAgent.updateMediaBuy({
  account: { account_id: 'acc_acme_001' },
  media_buy_id: 'mb_12345',
  packages: [{
    package_id: 'pkg_001',
    targeting_overlay: {
      geo_countries: ['US', 'CA'],
      geo_regions: ['US-CA', 'US-NY', 'US-TX', 'CA-ON', 'CA-QC']
    }
  }]
});

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

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

if ('errors' in validated && validated.errors) {
  throw new Error(`Update failed: ${JSON.stringify(validated.errors)}`);
}

console.log('Targeting updated successfully');

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

async def update_targeting():
    result = await test_agent.update_media_buy(
        UpdateMediaBuyRequest(
            account={'account_id': 'acc_acme_001'},
            media_buy_id='mb_12345',
            packages=[
                {
                    'package_id': 'pkg_001',
                    'targeting_overlay': {
                        'geo_countries': ['US', 'CA'],
                        'geo_regions': ['US-CA', 'US-NY', 'US-TX', 'CA-ON', 'CA-QC']
                    }
                }
            ]
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Update failed: {result.errors}")

    print('Targeting updated successfully')

asyncio.run(update_targeting())

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

const result = await testAgent.updateMediaBuy({
  account: { account_id: 'acc_acme_001' },
  media_buy_id: 'mb_12345',
  packages: [{
    package_id: 'pkg_001',
    creative_assignments: [
      { creative_id: 'creative_video_v2' },
      { creative_id: 'creative_display_v2', weight: 60 }
    ]
  }]
});

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

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

if ('errors' in validated && validated.errors) {
  throw new Error(`Update failed: ${JSON.stringify(validated.errors)}`);
}

const pkg = validated.affected_packages?.find(p => p.package_id === 'pkg_001');
const assignmentCount = pkg?.creative_assignments?.length || 0;
console.log(`Assigned ${assignmentCount} creatives`);

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

async def replace_creatives():
    result = await test_agent.update_media_buy(
        UpdateMediaBuyRequest(
            account={'account_id': 'acc_acme_001'},
            media_buy_id='mb_12345',
            packages=[
                {
                    'package_id': 'pkg_001',
                    'creative_assignments': [
                        {'creative_id': 'creative_video_v2'},
                        {'creative_id': 'creative_display_v2', 'weight': 60}
                    ]
                }
            ]
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Update failed: {result.errors}")

    pkg = next((p for p in result.affected_packages if p.package_id == 'pkg_001'), None)
    assignment_count = len(pkg.creative_assignments) if pkg and pkg.creative_assignments else 0
    print(f"Assigned {assignment_count} creatives")

asyncio.run(replace_creatives())

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

const result = await testAgent.updateMediaBuy({
  account: { account_id: 'acc_acme_001' },
  media_buy_id: 'mb_12345',
  packages: [
    {
      package_id: 'pkg_001',
      budget: 50000,
      pacing: 'front_loaded'
    },
    {
      package_id: 'pkg_002',
      budget: 30000,
      paused: true
    }
  ]
});

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

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

if ('errors' in validated && validated.errors) {
  throw new Error(`Update failed: ${JSON.stringify(validated.errors)}`);
}

console.log(`Updated ${validated.affected_packages?.length || 0} packages`);

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

async def update_multiple_packages():
    result = await test_agent.update_media_buy(
        UpdateMediaBuyRequest(
            account={'account_id': 'acc_acme_001'},
            media_buy_id='mb_12345',
            packages=[
                {
                    'package_id': 'pkg_001',
                    'budget': 50000,
                    'pacing': 'front_loaded'
                },
                {
                    'package_id': 'pkg_002',
                    'budget': 30000,
                    'paused': True
                }
            ]
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Update failed: {result.errors}")

    print(f"Updated {len(result.affected_packages)} packages")

asyncio.run(update_multiple_packages())