sync_creatives

import { testAgent } from "@adcp/sdk/testing";
import { SyncCreativesResponseSchema } from "@adcp/sdk";
import { randomUUID } from "node:crypto";

const result = await testAgent.syncCreatives({
  account: {
    brand: { domain: "acmecorp.com" },
    operator: "acmecorp.com",
    sandbox: true,
  },
  idempotency_key: randomUUID(),
  creatives: [
    {
      creative_id: "creative_video_001",
      name: "Summer Sale 30s",
      format_kind: "video_hosted",
      assets: {
        video: {
          asset_type: "video",
          url: "https://cdn.example.com/summer-sale-30s.mp4",
          width: 1920,
          height: 1080,
          duration_ms: 30000,
        },
      },
    },
  ],
});

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

// Validate response against schema
const validated = SyncCreativesResponseSchema.parse(result.data);

// Three-shape discriminated union: errors | submitted | creatives
if ("errors" in validated && validated.errors && !("creatives" in validated) && !("status" in validated)) {
  throw new Error(`Operation failed: ${JSON.stringify(validated.errors)}`);
}

if ("status" in validated && validated.status === "submitted") {
  // Whole sync queued asynchronously — invoke get_task_status with task_id or await webhook
  console.log(`Sync queued as task ${validated.task_id}: ${validated.message ?? ""}`);
} else if ("creatives" in validated) {
  console.log(`Synced ${validated.creatives.length} creatives`);
  for (const c of validated.creatives) {
    // c.status carries review state: approved, pending_review, rejected, processing, archived
    if (c.status === "pending_review" || c.status === "processing") {
      console.log(`  ${c.creative_id}: awaiting review (${c.status})`);
    }
  }
}

import asyncio
from adcp.testing import test_agent
from uuid import uuid4

async def main():
    result = await test_agent.simple.sync_creatives(
        account={
            'brand': {'domain': 'acmecorp.com'},
            'operator': 'acmecorp.com',
            'sandbox': True
        },
        idempotency_key=str(uuid4()),
        creatives=[{
            'creative_id': 'creative_video_001',
            'name': 'Summer Sale 30s',
            'format_kind': 'video_hosted',
            'assets': {
                'video': {
                    'asset_type': 'video',
                    'url': 'https://cdn.example.com/summer-sale-30s.mp4',
                    'width': 1920,
                    'height': 1080,
                    'duration_ms': 30000
                }
            }
        }]
    )

    # Three-shape discriminated union: errors | submitted | creatives
    if getattr(result, 'status', None) == 'submitted':
        # Whole sync queued asynchronously — invoke get_task_status with task_id or await webhook
        print(f"Sync queued as task {result.task_id}: {getattr(result, 'message', '') or ''}")
        return

    if getattr(result, 'errors', None) and not getattr(result, 'creatives', None):
        raise Exception(f"Operation failed: {result.errors}")

    print(f"Synced {len(result.creatives)} creatives")
    for c in result.creatives:
        # c.status carries review state: approved, pending_review, rejected, processing, archived
        if getattr(c, 'status', None) in ('pending_review', 'processing'):
            print(f"  {c.creative_id}: awaiting review ({c.status})")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { SyncCreativesResponseSchema } from "@adcp/sdk";
import { randomUUID } from "node:crypto";

const result = await testAgent.syncCreatives({
  account: {
    brand: { domain: "acmecorp.com" },
    operator: "acmecorp.com",
    sandbox: true,
  },
  idempotency_key: randomUUID(),
  creatives: [
    {
      creative_id: "creative_display_001",
      name: "Summer Sale Banner 300x250",
      format_kind: "image",
      assets: {
        image: {
          asset_type: "image",
          url: "https://cdn.example.com/banner-300x250.jpg",
          width: 300,
          height: 250,
        },
      },
    },
    {
      creative_id: "creative_video_002",
      name: "Product Demo 15s",
      format_kind: "video_hosted",
      assets: {
        video: {
          asset_type: "video",
          url: "https://cdn.example.com/demo-15s.mp4",
          width: 1920,
          height: 1080,
          duration_ms: 15000,
        },
      },
    },
    {
      creative_id: "creative_display_002",
      name: "Summer Sale Banner 728x90",
      format_kind: "image",
      assets: {
        image: {
          asset_type: "image",
          url: "https://cdn.example.com/banner-728x90.jpg",
          width: 728,
          height: 90,
        },
      },
    },
  ],
});

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

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

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

if ("creatives" in validated) {
  console.log(`Successfully synced ${validated.creatives.length} creatives`);
  validated.creatives.forEach((creative) => {
    console.log(`  ${creative.creative_id}: ${creative.action}`);
  });
}

import asyncio
from adcp.testing import test_agent
from uuid import uuid4

async def main():
    result = await test_agent.simple.sync_creatives(
        account={
            'brand': {'domain': 'acmecorp.com'},
            'operator': 'acmecorp.com',
            'sandbox': True
        },
        idempotency_key=str(uuid4()),
        creatives=[
            {
                'creative_id': 'creative_display_001',
                'name': 'Summer Sale Banner 300x250',
                'format_kind': 'image',
                'assets': {
                    'image': {
                        'asset_type': 'image',
                        'url': 'https://cdn.example.com/banner-300x250.jpg',
                        'width': 300,
                        'height': 250
                    }
                }
            },
            {
                'creative_id': 'creative_video_002',
                'name': 'Product Demo 15s',
                'format_kind': 'video_hosted',
                'assets': {
                    'video': {
                        'asset_type': 'video',
                        'url': 'https://cdn.example.com/demo-15s.mp4',
                        'width': 1920,
                        'height': 1080,
                        'duration_ms': 15000
                    }
                }
            },
            {
                'creative_id': 'creative_display_002',
                'name': 'Summer Sale Banner 728x90',
                'format_kind': 'image',
                'assets': {
                    'image': {
                        'asset_type': 'image',
                        'url': 'https://cdn.example.com/banner-728x90.jpg',
                        'width': 728,
                        'height': 90
                    }
                }
            }
        ]
    )

    # Check for operation-level errors first
    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Operation failed: {result.errors}")

    print(f"Successfully synced {len(result.creatives)} creatives")
    for creative in result.creatives:
        print(f"  {creative.creative_id}: {creative.action}")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { SyncCreativesResponseSchema } from "@adcp/sdk";
import { randomUUID } from "node:crypto";

const result = await testAgent.syncCreatives({
  account: {
    brand: { domain: "acmecorp.com" },
    operator: "acmecorp.com",
    sandbox: true,
  },
  idempotency_key: randomUUID(),
  creatives: [
    {
      creative_id: "creative_gen_001",
      name: "AI-Generated Summer Banner",
      format_kind: "image",
      assets: {
        prompt: {
          asset_type: "text",
          content: "Create a summer banner for outdoor enthusiasts. Headline: Summer gear built for every trail. CTA: Shop the collection.",
        },
      },
    },
  ],
});

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

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

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

if ("creatives" in validated) {
  console.log(
    "Generative creative synced:",
    validated.creatives[0].creative_id
  );
}

import asyncio
from adcp.testing import test_agent
from uuid import uuid4

async def main():
    result = await test_agent.simple.sync_creatives(
        account={
            'brand': {'domain': 'acmecorp.com'},
            'operator': 'acmecorp.com',
            'sandbox': True
        },
        idempotency_key=str(uuid4()),
        creatives=[{
            'creative_id': 'creative_gen_001',
            'name': 'AI-Generated Summer Banner',
            'format_kind': 'image',
            'assets': {
                'prompt': {
                    'asset_type': 'text',
                    'content': 'Create a summer banner for outdoor enthusiasts. Headline: Summer gear built for every trail. CTA: Shop the collection.'
                }
            }
        }]
    )

    # Check for operation-level errors first
    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Operation failed: {result.errors}")

    print(f"Generative creative synced: {result.creatives[0].creative_id}")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { SyncCreativesResponseSchema } from "@adcp/sdk";
import { randomUUID } from "node:crypto";

const result = await testAgent.syncCreatives({
  account: {
    brand: { domain: "acmecorp.com" },
    operator: "acmecorp.com",
    sandbox: true,
  },
  idempotency_key: randomUUID(),
  dry_run: true,
  creatives: [
    {
      creative_id: "creative_test_001",
      name: "Test Creative",
      format_kind: "video_hosted",
      assets: {
        video: {
          asset_type: "video",
          url: "https://cdn.example.com/test-video.mp4",
          width: 1920,
          height: 1080,
          duration_ms: 30000,
        },
      },
    },
  ],
});

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

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

if ("errors" in validated && validated.errors && validated.errors.length > 0) {
  console.log("Validation errors found:");
  validated.errors.forEach((error) => console.log(`  - ${error.message}`));
} else if (
  "creatives" in validated && validated.creatives?.some((creative) => creative.action === "failed")
) {
  console.log("Creative validation errors found.");
} else if (
  "assignments" in validated && validated.assignments?.some((assignment) => assignment.status === "error")
) {
  console.log("Assignment validation errors found.");
} else {
  console.log("Validation passed! Ready to sync.");
}

import asyncio
from adcp.testing import test_agent
from uuid import uuid4

async def main():
    result = await test_agent.simple.sync_creatives(
        account={
            'brand': {'domain': 'acmecorp.com'},
            'operator': 'acmecorp.com',
            'sandbox': True
        },
        idempotency_key=str(uuid4()),
        dry_run=True,
        creatives=[{
            'creative_id': 'creative_test_001',
            'name': 'Test Creative',
            'format_kind': 'video_hosted',
            'assets': {
                'video': {
                    'asset_type': 'video',
                    'url': 'https://cdn.example.com/test-video.mp4',
                    'width': 1920,
                    'height': 1080,
                    'duration_ms': 30000
                }
            }
        }]
    )

    if hasattr(result, 'errors') and result.errors:
        error_messages = [error.message for error in result.errors]
        raise Exception(f"Validation errors: {error_messages}")
    if any(getattr(creative, 'action', None) == 'failed' for creative in getattr(result, 'creatives', [])):
        raise Exception('Creative validation errors found')
    if any(getattr(assignment, 'status', None) == 'error' for assignment in getattr(result, 'assignments', [])):
        raise Exception('Assignment validation errors found')

    print('Validation passed! Ready to sync.')

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { SyncCreativesResponseSchema } from "@adcp/sdk";
import { randomUUID } from "node:crypto";

// Update just 2 creatives out of 100+ in the library
const result = await testAgent.syncCreatives({
  account: {
    brand: { domain: "acmecorp.com" },
    operator: "acmecorp.com",
    sandbox: true,
  },
  idempotency_key: randomUUID(),
  creative_ids: ["creative_video_001", "creative_display_001"],
  creatives: [
    {
      creative_id: "creative_video_001",
      name: "Summer Sale 30s - Updated",
      format_kind: "video_hosted",
      assets: {
        video: {
          asset_type: "video",
          url: "https://cdn.example.com/updated-video.mp4",
          width: 1920,
          height: 1080,
          duration_ms: 30000,
        },
      },
    },
    {
      creative_id: "creative_display_001",
      name: "Summer Sale Banner - Updated",
      format_kind: "image",
      assets: {
        image: {
          asset_type: "image",
          url: "https://cdn.example.com/updated-banner.jpg",
          width: 300,
          height: 250,
        },
      },
    },
  ],
});

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

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

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

if ("creatives" in validated) {
  console.log(
    `Updated ${validated.creatives.length} creatives, others untouched`
  );
}

import asyncio
from adcp.testing import test_agent
from uuid import uuid4

async def main():
    # Update just 2 creatives out of 100+ in the library
    result = await test_agent.simple.sync_creatives(
        account={
            'brand': {'domain': 'acmecorp.com'},
            'operator': 'acmecorp.com',
            'sandbox': True
        },
        idempotency_key=str(uuid4()),
        creative_ids=['creative_video_001', 'creative_display_001'],
        creatives=[
            {
                'creative_id': 'creative_video_001',
                'name': 'Summer Sale 30s - Updated',
                'format_kind': 'video_hosted',
                'assets': {
                    'video': {
                        'asset_type': 'video',
                        'url': 'https://cdn.example.com/updated-video.mp4',
                        'width': 1920,
                        'height': 1080,
                        'duration_ms': 30000
                    }
                }
            },
            {
                'creative_id': 'creative_display_001',
                'name': 'Summer Sale Banner - Updated',
                'format_kind': 'image',
                'assets': {
                    'image': {
                        'asset_type': 'image',
                        'url': 'https://cdn.example.com/updated-banner.jpg',
                        'width': 300,
                        'height': 250
                    }
                }
            }
        ]
    )

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

    print(f"Updated {len(result.creatives)} creatives, others untouched")

asyncio.run(main())