get_products

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

const result = await testAgent.getProducts({
  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);
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_ids.map(f => f.id).join(', ')}`);
}

import asyncio
from adcp.testing import test_agent

async def discover_products():
    result = await test_agent.simple.get_products(
        buying_mode='brief',
        brief='Premium athletic footwear with innovative cushioning',
        brand={
            'domain': 'acmecorp.com'
        }
    )
    print(f"Found {len(result.products)} products")

asyncio.run(discover_products())

uvx adcp \
  https://test-agent.adcontextprotocol.org/sales/mcp \
  get_products \
  '{"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: 'wholesale',
  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='wholesale',
        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({
  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(`  Would resolve in ${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(
        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"  Would resolve in {wait['interval']} {wait['unit']}")

asyncio.run(discover_with_time_budget())

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

// wholesale モード: バイヤー独自のオーディエンスを適用、パブリッシャーキュレーションなし
const result = await testAgent.getProducts({
  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 モード: バイヤー独自のオーディエンスを適用、パブリッシャーキュレーションなし
    result = await test_agent.simple.get_products(
        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';

// video と display の両方をサポートするプロダクトを探す
const result = await testAgent.getProducts({
  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(
        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';

// 指定国とチャンネルで、予算と期間に収まるプロダクトを探す
const result = await testAgent.getProducts({
  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(
        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';

// property_tags を持つプロダクトを取得
const result = await testAgent.getProducts({
  buying_mode: 'brief',
  brief: 'Sports content',
  brand: {
    domain: 'acmecorp.com'
  }
});

if (result.success && result.data) {
  // publisher_properties に property_tags がある場合は大規模ネットワークを意味する
  // エージェントのポートフォリオは get_adcp_capabilities で確認する
  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(
        buying_mode='brief',
        brief='Sports content',
        brand={
            'domain': 'acmecorp.com'
        }
    )

    # publisher_properties に property_tags がある場合は大規模ネットワークを意味する
    # エージェントのポートフォリオは get_adcp_capabilities で確認する
    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({
  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():
    # 計測用に保証配信のプロダクトを探す
    result = await test_agent.simple.get_products(
        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';

// IAB 標準フォーマットのみ受け付けるプロダクトを探す
const result = await testAgent.getProducts({
  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():
    # IAB 標準フォーマットのみ受け付けるプロダクトを探す
    result = await test_agent.simple.get_products(
        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';

// 特定のカタログアイテム向けのリテールメディアプロダクトを探す
const result = await testAgent.getProducts({
  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():
    # 特定のカタログアイテム向けのリテールメディアプロダクトを探す
    result = await test_agent.simple.get_products(
        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 \
  '{"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({
  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) {
  // フィルタが適用されたか確認
  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():
    # ガバナンスエージェントのプロパティリストでフィルタリング
    result = await test_agent.simple.get_products(
        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 catalog with pricing
const fullCatalog = await testAgent.getProducts({
  buying_mode: 'brief',
  brief: 'Premium CTV inventory for brand awareness',
  brand: {
    domain: 'acmecorp.com'
  }
});

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

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

// WITHOUT authentication - limited public catalog
const publicCatalog = await testAgentNoAuth.getProducts({
  buying_mode: 'brief',
  brief: 'Premium CTV inventory for brand awareness',
  brand: {
    domain: 'acmecorp.com'
  }
});

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

console.log(`Without auth: ${publicCatalog.data.products.length} products`);
console.log(`First product pricing: ${publicCatalog.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 catalog with pricing
    full_catalog = await test_agent.simple.get_products(
        buying_mode='brief',
        brief='Premium CTV inventory for brand awareness',
        brand={
            'domain': 'acmecorp.com'
        }
    )

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

    # WITHOUT authentication - limited public catalog
    public_catalog = await test_agent_no_auth.simple.get_products(
        buying_mode='brief',
        brief='Premium CTV inventory for brand awareness',
        brand={
            'domain': 'acmecorp.com'
        }
    )

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

asyncio.run(compare_auth())