get_products

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

const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441000',
  buying_mode: 'brief',
  brief: 'Premium athletic footwear with innovative cushioning',
  brand: {
    domain: 'acmecorp.com'
  }
});

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

// Validate response against schema
const validated = GetProductsResponseSchema.parse(result.data);
if (validated.status === 'rejected') {
  console.log(`Seller declined the brief: ${validated.reason}`);
  for (const suggestion of validated.suggestions ?? []) {
    console.log(`- ${suggestion}`);
  }
} else {
  console.log(`Found ${validated.products.length} products`);

  // Access validated product fields
  for (const product of validated.products) {
    console.log(`- ${product.name} (${product.delivery_type})`);
    console.log(`  Formats: ${product.format_options.map(option => option.format_kind).join(', ')}`);
  }
}

import asyncio
from adcp.testing import test_agent

async def discover_products():
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441001',
        buying_mode='brief',
        brief='Premium athletic footwear with innovative cushioning',
        brand={
            'domain': 'acmecorp.com'
        }
    )
    if result.status == 'rejected':
        print(f"Seller declined the brief: {result.reason}")
        for suggestion in result.suggestions or []:
            print(f"- {suggestion}")
    else:
        print(f"Found {len(result.products)} products")

asyncio.run(discover_products())

uvx adcp \
  https://test-agent.adcontextprotocol.org/sales/mcp \
  get_products \
  '{"idempotency_key":"550e8400-e29b-41d4-a716-446655441002","buying_mode":"brief","brief":"Premium athletic footwear with innovative cushioning","brand":{"domain":"acmecorp.com"}}' \
  --auth $ADCP_AUTH_TOKEN

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

const result = await testAgent.getProducts({
  buying_mode: 'brief',
  brief: 'Premium connected-TV inventory for a national launch',
  brand: {
    domain: 'acmecorp.com'
  },
  filters: {
    channels: ['ctv'],
    delivery_type: 'guaranteed',
    standard_formats_only: true
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} guaranteed CTV products`);
}

import asyncio
from adcp.testing import test_agent

async def discover_with_filters():
    result = await test_agent.simple.get_products(
        buying_mode='brief',
        brief='Premium connected-TV inventory for a national launch',
        brand={
            'domain': 'acmecorp.com'
        },
        filters={
            'channels': ['ctv'],
            'delivery_type': 'guaranteed',
            'standard_formats_only': True
        }
    )
    print(f"Found {len(result.products)} guaranteed CTV products")

asyncio.run(discover_with_filters())

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

const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441008',
  buying_mode: 'brief',
  brief: 'CTV and display for brand awareness',
  brand: {
    domain: 'acmecorp.com'
  },
  time_budget: {
    interval: 10,
    unit: 'seconds'
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} products`);

  if (result.data.incomplete) {
    for (const entry of result.data.incomplete) {
      console.log(`Incomplete: ${entry.scope} — ${entry.description}`);
      if (entry.estimated_wait) {
        console.log(`  Seller estimates more time may help: ${entry.estimated_wait.interval} ${entry.estimated_wait.unit}`);
      }
    }
  }
}

import asyncio
from adcp.testing import test_agent

async def discover_with_time_budget():
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441009',
        buying_mode='brief',
        brief='CTV and display for brand awareness',
        brand={
            'domain': 'acmecorp.com'
        },
        time_budget={
            'interval': 10,
            'unit': 'seconds'
        }
    )
    print(f"Found {len(result.products)} products")

    for entry in result.get('incomplete', []):
        print(f"Incomplete: {entry['scope']} — {entry['description']}")
        if 'estimated_wait' in entry:
            wait = entry['estimated_wait']
            print(f"  Seller estimates more time may help: {wait['interval']} {wait['unit']}")

asyncio.run(discover_with_time_budget())

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

// wholesale mode: buyer applies their own audiences, no publisher curation
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441010',
  buying_mode: 'wholesale',
  brand: {
    domain: 'acmecorp.com'
  },
  filters: {
    delivery_type: 'non_guaranteed'
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} standard wholesale products`);
}

import asyncio
from adcp.testing import test_agent

async def discover_standard_wholesale_products():
    # wholesale mode: buyer applies their own audiences, no publisher curation
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441011',
        buying_mode='wholesale',
        brand={
            'domain': 'acmecorp.com'
        },
        filters={
            'delivery_type': 'non_guaranteed'
        }
    )
    print(f"Found {len(result.products)} standard wholesale products")

asyncio.run(discover_standard_wholesale_products())

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

// Find products supporting both video and display
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441012',
  buying_mode: 'brief',
  brief: 'Brand awareness campaign with video and display',
  brand: {
    domain: 'acmecorp.com'
  },
  filters: {
    channels: ['display', 'ctv']
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} products supporting video and display`);
}

import asyncio
from adcp.testing import test_agent

async def discover_multi_format():
    # Find products supporting both video and display
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441013',
        buying_mode='brief',
        brief='Brand awareness campaign with video and display',
        brand={
            'domain': 'acmecorp.com'
        },
        filters={
            'channels': ['display', 'ctv']
        }
    )
    print(f"Found {len(result.products)} products supporting video and display")

asyncio.run(discover_multi_format())

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

// Find products within budget and date range for specific countries and channels
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441014',
  buying_mode: 'brief',
  brief: 'Q2 campaign for athletic footwear in North America',
  brand: {
    domain: 'acmecorp.com'
  },
  filters: {
    start_date: '2025-04-01',
    end_date: '2025-06-30',
    budget_range: {
      min: 50000,
      max: 100000,
      currency: 'USD'
    },
    countries: ['US', 'CA'],
    channels: ['display', 'ctv', 'podcast'],
    delivery_type: 'guaranteed'
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} products for Q2 within budget`);
}

import asyncio
from adcp.testing import test_agent

async def discover_with_budget_and_dates():
    # Find products within budget and date range for specific countries and channels
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441015',
        buying_mode='brief',
        brief='Q2 campaign for athletic footwear in North America',
        brand={
            'domain': 'acmecorp.com'
        },
        filters={
            'start_date': '2025-04-01',
            'end_date': '2025-06-30',
            'budget_range': {
                'min': 50000,
                'max': 100000,
                'currency': 'USD'
            },
            'countries': ['US', 'CA'],
            'channels': ['display', 'ctv', 'podcast'],
            'delivery_type': 'guaranteed'
        }
    )
    print(f"Found {len(result.products)} products for Q2 within budget")

asyncio.run(discover_with_budget_and_dates())

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

// Get products with property tags
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441016',
  buying_mode: 'brief',
  brief: 'Sports content',
  brand: {
    domain: 'acmecorp.com'
  }
});

if (result.success && result.data) {
  // Products with property_tags in publisher_properties represent large networks
  // Use get_adcp_capabilities to discover the agent's portfolio
  const productsWithTags = result.data.products.filter(p =>
    p.publisher_properties?.some(pub => pub.property_tags && pub.property_tags.length > 0)
  );
  console.log(`${productsWithTags.length} products use property tags (large networks)`);
}

import asyncio
from adcp.testing import test_agent

async def discover_property_tags():
    # Get products with property tags
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441017',
        buying_mode='brief',
        brief='Sports content',
        brand={
            'domain': 'acmecorp.com'
        }
    )

    # Products with property_tags in publisher_properties represent large networks
    # Use get_adcp_capabilities to discover the agent's portfolio
    products_with_tags = [p for p in result.products
        if any(pub.get('property_tags') for pub in p.get('publisher_properties', []))]
    print(f"{len(products_with_tags)} products use property tags (large networks)")

asyncio.run(discover_property_tags())

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

// Find guaranteed delivery products for measurement
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441018',
  buying_mode: 'brief',
  brief: 'Guaranteed delivery for lift study',
  brand: {
    domain: 'acmecorp.com'
  },
  filters: {
    delivery_type: 'guaranteed',
    min_exposures: 100000
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} guaranteed products with 100k+ exposures`);
}

import asyncio
from adcp.testing import test_agent

async def discover_guaranteed():
    # Find guaranteed delivery products for measurement
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441019',
        buying_mode='brief',
        brief='Guaranteed delivery for lift study',
        brand={
            'domain': 'acmecorp.com'
        },
        filters={
            'delivery_type': 'guaranteed',
            'min_exposures': 100000
        }
    )
    print(f"Found {len(result.products)} guaranteed products with 100k+ exposures")

asyncio.run(discover_guaranteed())

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

// Find products that only accept IAB standard formats
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441020',
  buying_mode: 'wholesale',
  brand: {
    domain: 'acmecorp.com'
  },
  filters: {
    standard_formats_only: true
  }
});

if (result.success && result.data) {
  console.log(`Found ${result.data.products.length} products with standard formats only`);
}

import asyncio
from adcp.testing import test_agent

async def discover_standard_formats():
    # Find products that only accept IAB standard formats
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441021',
        buying_mode='wholesale',
        brand={
            'domain': 'acmecorp.com'
        },
        filters={
            'standard_formats_only': True
        }
    )
    print(f"Found {len(result.products)} products with standard formats only")

asyncio.run(discover_standard_formats())

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

// Discover retail media products for specific catalog items
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441022',
  buying_mode: 'wholesale',
  brand: {
    domain: 'acmecorp.com'
  },
  catalog: {
    type: 'product',
    tags: ['ketchup', 'organic'],
    category: 'food/condiments'
  },
  filters: {
    channels: ['retail_media']
  }
});

if (result.success && result.data) {
  if (result.data.catalog_applied) {
    console.log(`Found ${result.data.products.length} products with catalog matches`);
  } else {
    console.log('Seller does not support catalog matching');
  }
}

import asyncio
from adcp.testing import test_agent

async def discover_commerce_products():
    # Discover retail media products for specific catalog items
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441023',
        buying_mode='wholesale',
        brand={
            'domain': 'acmecorp.com'
        },
        catalog={
            'type': 'product',
            'tags': ['ketchup', 'organic'],
            'category': 'food/condiments'
        },
        filters={
            'channels': ['retail_media']
        }
    )
    if result.get('catalog_applied'):
        print(f"Found {len(result.products)} products with catalog matches")
    else:
        print("Seller does not support catalog matching")

asyncio.run(discover_commerce_products())

uvx adcp \
  https://test-agent.adcontextprotocol.org/sales/mcp \
  get_products \
  '{"idempotency_key":"550e8400-e29b-41d4-a716-446655441024","buying_mode":"wholesale","brand":{"domain":"acmecorp.com"},"catalog":{"type":"product","tags":["ketchup","organic"],"category":"food/condiments"},"filters":{"channels":["retail_media"]}}' \
  --auth $ADCP_AUTH_TOKEN

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

// Filter products by property list from governance agent
const result = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441025',
  buying_mode: 'brief',
  brief: 'Brand-safe inventory for family brand',
  brand: {
    domain: 'acmecorp.com'
  },
  property_list: {
    agent_url: 'https://governance.example.com',
    list_id: 'pl_brand_safe_2024'
  }
});

if (result.success && result.data) {
  // Check if filtering was actually applied
  if (result.data.property_list_applied) {
    console.log(`Found ${result.data.products.length} products on approved properties`);
  } else {
    console.log('Agent does not support property list filtering');
    console.log(`Found ${result.data.products.length} products (unfiltered)`);
  }
}

import asyncio
from adcp.testing import test_agent

async def discover_with_property_list():
    # Filter products by property list from governance agent
    result = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441026',
        buying_mode='brief',
        brief='Brand-safe inventory for family brand',
        brand={
            'domain': 'acmecorp.com'
        },
        property_list={
            'agent_url': 'https://governance.example.com',
            'list_id': 'pl_brand_safe_2024'
        }
    )

    # Check if filtering was actually applied
    if result.get('property_list_applied'):
        print(f"Found {len(result['products'])} products on approved properties")
    else:
        print("Agent does not support property list filtering")
        print(f"Found {len(result['products'])} products (unfiltered)")

asyncio.run(discover_with_property_list())

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

// WITH authentication - full product results with pricing
const fullProducts = await testAgent.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441028',
  buying_mode: 'brief',
  brief: 'Premium CTV inventory for brand awareness',
  brand: {
    domain: 'acmecorp.com'
  }
});

if (!fullProducts.success) {
  throw new Error(`Failed to get products: ${fullProducts.error}`);
}

console.log(`With auth: ${fullProducts.data.products.length} products`);
console.log(`First product pricing: ${fullProducts.data.products[0].pricing_options.length} options`);

// WITHOUT authentication - limited public product results
const publicProducts = await testAgentNoAuth.getProducts({
  idempotency_key: '550e8400-e29b-41d4-a716-446655441029',
  buying_mode: 'brief',
  brief: 'Premium CTV inventory for brand awareness',
  brand: {
    domain: 'acmecorp.com'
  }
});

if (!publicProducts.success) {
  throw new Error(`Failed to get products: ${publicProducts.error}`);
}

console.log(`Without auth: ${publicProducts.data.products.length} products`);
console.log(`First product pricing: ${publicProducts.data.products[0].pricing_options?.length || 0} options`);

import asyncio
from adcp.testing import test_agent, test_agent_no_auth

async def compare_auth():
    # WITH authentication - full product results with pricing
    full_products = await test_agent.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441030',
        buying_mode='brief',
        brief='Premium CTV inventory for brand awareness',
        brand={
            'domain': 'acmecorp.com'
        }
    )

    print(f"With auth: {len(full_products['products'])} products")
    print(f"First product pricing: {len(full_products['products'][0]['pricing_options'])} options")

    # WITHOUT authentication - limited public product results
    public_products = await test_agent_no_auth.simple.get_products(
        idempotency_key='550e8400-e29b-41d4-a716-446655441031',
        buying_mode='brief',
        brief='Premium CTV inventory for brand awareness',
        brand={
            'domain': 'acmecorp.com'
        }
    )

    print(f"Without auth: {len(public_products['products'])} products")
    print(f"First product pricing: {len(public_products['products'][0].get('pricing_options', []))} options")

asyncio.run(compare_auth())