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 = 'tri_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: 'tri_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 { data: runs } = await brew.automations.runs.list({
  automationRunId: test.automationRunIds[0]!,
  include: 'logs',
})
const run = runs[0]!

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

const { data: automations } = await brew.automations.list({
  automationId: 'auto_abc',
  include: 'graph',
})
const latest = automations[0]!

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: 'auto_abc',
  nodes: newNodes,
  connections: latest.connections,
})
const nextVersion = patched

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