Ads Agent

// Generate ad content for products
 
@OnEndpoint('/ads/generate', { method: 'POST' })
async generateAd(request: Request) {
  const { product_id, platform, style, max_length } = request.body;
 
  const product = await getProduct(product_id);
  const pricing = await calculateDynamicPrice(product, {});
 
  // Generate platform-specific ad copy
  const adCopy = await this.llm.generate({
    prompt: `Generate a ${style} ad for ${platform}:
 
Product: ${product.name}
Description: ${product.description}
Price: $${pricing.suggested} (was $${product.pricing.list_price})
Key features: ${product.attributes}
 
Requirements:
- Max length: ${max_length} characters
- Platform: ${platform}
- Style: ${style}
- Include call to action
`,
  });
 
  return {
    product_id,
    platform,
    variants: [
      {
        id: 'v1',
        headline: adCopy.headline,
        body: adCopy.body,
        cta: adCopy.cta,
        character_count: adCopy.body.length,
      },
      // Generate multiple variants for A/B testing
      {
        id: 'v2',
        headline: adCopy.headline_alt,
        body: adCopy.body_alt,
        cta: adCopy.cta_alt,
        character_count: adCopy.body_alt.length,
      },
    ],
    product_data: {
      name: product.name,
      price: pricing.suggested,
      original_price: product.pricing.list_price,
      discount_percent: pricing.discountPercent,
      image_url: product.media.images[0]?.url,
      landing_url: `https://store.example.com/p/${product_id}`,
    },
  };
}
 
// Generate structured product card
@OnEndpoint('/ads/product-card', { method: 'POST' })
async generateProductCard(request: Request) {
  const { product_id } = request.body;
 
  const product = await getProduct(product_id);
  const inventory = await checkInventory(product_id);
  const pricing = await calculateDynamicPrice(product, {});
 
  return {
    "@context": "https://schema.org",
    "@type": "Product",
    name: product.name,
    description: product.description,
    image: product.media.images.map(i => i.url),
    brand: {
      "@type": "Brand",
      name: product.attributes.brand,
    },
    offers: {
      "@type": "Offer",
      price: pricing.suggested,
      priceCurrency: product.pricing.currency,
      availability: inventory.status === 'in_stock'
        ? "https://schema.org/InStock"
        : "https://schema.org/OutOfStock",
      seller: {
        "@type": "Organization",
        name: "Acme Sports",
      },
    },
    aggregateRating: {
      "@type": "AggregateRating",
      ratingValue: product.rating,
      reviewCount: product.review_count,
    },
  };
}

// Handle Perplexity Shopping queries
 
@OnEndpoint('/ads/perplexity', { method: 'POST' })
async handlePerplexityQuery(request: Request) {
  const { query, user_context } = request.body;
 
  // Semantic search for relevant products
  const products = await searchProducts(query, {
    limit: 5,
    minConfidence: 0.7,
  });
 
  // Format response for Perplexity
  return {
    results: products.results.map(product => ({
      title: product.name,
      description: this.generateShortDescription(product),
      price: {
        value: product.price,
        currency: 'USD',
        formatted: `$${product.price.toFixed(2)}`,
      },
      availability: product.in_stock ? 'in_stock' : 'out_of_stock',
      url: `https://store.example.com/p/${product.product_id}`,
      image_url: product.image_url,
      rating: product.rating,
      brand: product.brand,
      merchant: {
        name: 'Acme Sports',
        logo_url: 'https://...',
        shipping_info: 'Free shipping on orders over $100',
      },
    })),
 
    summary: this.generateQuerySummary(query, products),
 
    follow_up_questions: [
      `What sizes are available for ${products.results[0]?.name}?`,
      `Do you have similar products under $100?`,
      `What's your return policy?`,
    ],
  };
}
 
// Generate concise product summary for Perplexity
generateShortDescription(product: Product): string {
  const highlights = [
    product.attributes.brand,
    ...product.semantics.usage_context.slice(0, 2),
    product.attributes.waterproof ? 'waterproof' : null,
  ].filter(Boolean);
 
  return `${product.name} - ${highlights.join(', ')}. ${product.description.slice(0, 150)}...`;
}

# ads-agent-config.yaml
name: ads-agent
type: ads
version: "1.0"
 
# Supported platforms
platforms:
  google_ads:
    enabled: true
    headline_max: 30
    description_max: 90
 
  meta_ads:
    enabled: true
    primary_text_max: 125
    headline_max: 40
 
  perplexity:
    enabled: true
    api_key: $PERPLEXITY_API_KEY
 
# Ad generation settings
generation:
  model: gpt-4o
  temperature: 0.8  # Higher creativity for ads
  variants_per_product: 3
 
  styles:
    - professional
    - casual
    - urgent
    - value_focused
 
  # Forbidden words/phrases
  blocklist:
    - "best in class"
    - "world's best"
    - "guaranteed"
 
# Dynamic pricing in ads
pricing:
  include_original_price: true
  show_discount_percent: true
  min_discount_to_show: 5
 
# A/B testing
ab_testing:
  enabled: true
  min_impressions: 1000
  significance_threshold: 0.95
 
# Campaign tracking
tracking:
  utm_source: hyperfold
  utm_medium: agent_ads
  conversion_window_days: 30