Agentic Cookbook

import { createBrewClient } from '@brew.new/sdk'

const brew = createBrewClient({ apiKey: process.env.BREW_API_KEY! })

// 1. Define the trigger payload schema deterministically.
//    The server hardcodes provider: 'brew_api', don't send one.
//    create returns the bare trigger row (HTTP 201).
const trigger = await brew.automations.triggers.create({
  title: 'User Signed Up',
  description: 'Fires when a user completes signup.',
  payloadSchema: {
    type: 'object',
    fields: [
      { key: 'email', type: 'string', required: true },
      { key: 'firstName', type: 'string', required: false },
      { key: 'plan', type: 'string', required: false },
    ],
  },
})

// 2. Mint each email body. These rows are referenced by sendEmail nodes
//    in the graph below.
const [welcome, dayTwo] = await Promise.all([
  brew.emails.generate({
    prompt: 'Friendly welcome email for new signups, single CTA to the app.',
  }),
  brew.emails.generate({
    prompt: 'Day-2 nudge, three getting-started tips, light tone.',
  }),
])

// 3. Assemble the automation graph. AutomationNodeInput is a per-kind
//    discriminated union. Set node.type and TypeScript narrows
//    node.config automatically.
//
//    A custom sending domain is mandatory for API-authored automations:
//    pick one from `brew.domains.list({ sendableOnly: true })`.
const domainId = 'domain_123' // replace with a real verified domain id
const automation = await brew.automations.create({
  name: 'Welcome flow',
  triggerEventId: trigger.triggerEventId,
  nodes: [
    {
      id: 'trg',
      label: 'On signup',
      type: 'trigger',
      config: { triggerEventId: trigger.triggerEventId },
    },
    {
      id: 'send_welcome',
      label: 'Welcome',
      type: 'sendEmail',
      config: {
        emailId: welcome.emailId,
        // Pin the exact version so later edits don't change what fires.
        emailVersionId: welcome.emailVersionId,
        domainId,
        // {{ variable | fallback }} interpolation against the trigger payload.
        subject: 'Welcome to Brew, {{ firstName | there }}!',
        previewText: 'Thanks for signing up, here is how to get started.',
      },
    },
    {
      id: 'wait_2d',
      label: 'Wait 2 days',
      type: 'wait',
      config: { duration: 2, unit: 'days' },
    },
    {
      id: 'send_day2',
      label: 'Day 2 nudge',
      type: 'sendEmail',
      config: {
        emailId: dayTwo.emailId,
        emailVersionId: dayTwo.emailVersionId,
        domainId,
        subject: 'Three ways to get more out of Brew',
        previewText: 'A few getting-started tips to help you move faster.',
      },
    },
  ],
  connections: [
    { from: 'trg', to: 'send_welcome' },
    { from: 'send_welcome', to: 'wait_2d' },
    { from: 'wait_2d', to: 'send_day2' },
  ],
})

// 4. Publish (convenience wrapper over patch({ published: true })).
await brew.automations.publish({ automationId: automation.automationId })

console.log('Ready to fire:', {
  triggerEventId: trigger.triggerEventId,
  automationId: automation.automationId,
})

const TRIGGER_EVENT_ID = 'order_shipped'

const confirmation = await brew.emails.generate({
  prompt: 'Order-shipped confirmation with tracking link.',
})

// A custom sending domain is mandatory for API-authored automations:
// pick one from `brew.domains.list({ sendableOnly: true })`.
const domainId = 'domain_123' // replace with a real verified domain id

const automation = await brew.automations.create({
  name: 'Order shipped, confirmation',
  triggerEventId: TRIGGER_EVENT_ID,
  nodes: [
    {
      id: 'trg',
      label: 'Order shipped',
      type: 'trigger',
      config: { triggerEventId: TRIGGER_EVENT_ID },
    },
    {
      id: 'send_confirm',
      label: 'Send confirmation',
      type: 'sendEmail',
      config: {
        emailId: confirmation.emailId,
        emailVersionId: confirmation.emailVersionId,
        domainId,
        subject: 'Order #{{ orderId }} is on its way',
        previewText: 'Your order has shipped, track it here.',
      },
    },
  ],
  connections: [{ from: 'trg', to: 'send_confirm' }],
})

await brew.automations.publish({ automationId: automation.automationId })

const existing = await brew.emails.list()
const reusable = existing.data.find((e) =>
  e.title.toLowerCase().includes('welcome')
)

const welcomeEmailId =
  reusable?.emailId ??
  (await brew.emails.generate({
    prompt: 'Welcome email for new signups.',
  })).emailId

const fire = await brew.automations.triggers.fire(
  {
    triggerEventId: 'order_shipped',
    payload: {
      email: order.customerEmail,
      firstName: order.customerFirstName,
      orderId: order.id,
      trackingUrl: order.trackingUrl,
    },
  },
  { idempotencyKey: `order-shipped-${order.id}` },
)

const test = await brew.automations.test({
  automationId,
  payload: { email: 'qa@example.com', firstName: 'QA' },
})

// Wait a moment for the workflow runtime, then read logs.
await new Promise((r) => setTimeout(r, 2000))

const run = await brew.automations.runs.get(test.automationRunIds[0]!, {
  include: 'logs',
})

console.log('Status:', run.status)
for (const log of run.logs ?? []) {
  console.log(`${log.nodeName}: ${log.status} (${log.durationMs ?? '?'}ms)`)
}

const latest = await brew.automations.get('M3nRk8LqW2xT5vBp9YcZd', {
  include: 'graph',
})

const newNodes = latest.nodes.map((node) =>
  node.type === 'wait'
    ? { ...node, config: { duration: 2, unit: 'days' as const } }
    : node
)

const patched = await brew.automations.patch({
  automationId: 'M3nRk8LqW2xT5vBp9YcZd',
  nodes: newNodes,
  connections: latest.connections,
})
const nextVersion = patched

await brew.automations.patch({
  automationId: 'M3nRk8LqW2xT5vBp9YcZd',
  published: true,
  automationVersionId: nextVersion.automationVersionId,
})