{
  "tool": "getTicketPrice",
  "parameters": { "from": "quebec", "to": "new york" }
}

const price = await getTicketPrice({ from: 'quebec', to: 'new york' })

if (price > 500) {
  throw new Error('Price too high')
}

const ticketId = await buyTicket({ from: 'quebec', to: 'new york' })
return { action: 'done', result: ticketId }

npm install @botpress/client llmz

import { Client } from '@botpress/client'
import { execute } from 'llmz'

const client = new Client({ botId: '...', token: '...' })

const result = await execute({
  instructions: 'Calculate sum of integers 14-1078 divisible by 3, 9, or 5',
  client,
})

console.log(result.output) // 271575

let sum = 0
for (let i = 14; i <= 1078; i++) {
  if (i % 3 === 0 || i % 9 === 0 || i % 5 === 0) {
    sum += i
  }
}
return { action: 'done', value: { success: true, result: sum } }

import { execute } from 'llmz'
import { Text, Button } from './components'

const tools = [searchFlights, bookTicket, cancelBooking]

let state = { transcript: [] }

while (true) {
  const result = await execute({
    client,
    tools,
    chat: {
      transcript: state.transcript,
      components: { Text, Button },
    },
  })

  if (result.is('listen')) {
    // Agent yielded UI and is waiting for user input
    console.log('Agent:', result.value.components)
    const userInput = await getUserInput()
    state.transcript.push({ role: 'user', content: userInput })
  } else {
    // Agent completed the task
    break
  }
}

const flights = await searchFlights({ from: 'SFO', to: 'NYC' })

yield (
  <Text>
    Found {flights.length} flights. Cheapest is ${flights[0].price}. Book it?
  </Text>
)
yield <Button>Book Flight</Button>
yield <Button>Cancel</Button>

return { action: 'listen' }

const result = await execute({
  instructions: 'Analyze Q4 sales data and generate report',
  client,
  tools: [fetchSales, calculateMetrics, generatePDF],
})

const result = await execute({
  client,
  tools,
  chat: {
    transcript: conversationHistory,
    components: { Text, Button, Form },
  },
})

import { Tool } from 'llmz'
import { z } from '@bpinternal/zui'

const searchFlights = new Tool({
  name: 'searchFlights',
  description: 'Search for available flights',
  input: z.object({
    from: z.string(),
    to: z.string(),
    date: z.string(),
  }),
  output: z.array(
    z.object({
      id: z.string(),
      price: z.number(),
      departure: z.string(),
    })
  ),
  handler: async ({ from, to, date }) => {
    // Your implementation
    return flights
  },
})

import { ObjectInstance } from 'llmz'
import { z } from '@bpinternal/zui'

const database = new ObjectInstance({
  name: 'db',
  description: 'Database operations',
  tools: [queryUsers, updateRecord, deleteRecord],
  properties: [
    {
      name: 'connectionString',
      value: process.env.DB_URL,
      writable: false,
    },
    {
      name: 'lastQueryTime',
      value: null,
      type: z.string().nullable(),
      writable: true,
    },
  ],
})

const users = await db.queryUsers({ active: true })
db.lastQueryTime = new Date().toISOString()

import { Exit } from 'llmz'
import { z } from '@bpinternal/zui'

const TicketBooked = new Exit({
  name: 'ticket_booked',
  description: 'Successfully booked a ticket',
  schema: z.object({
    ticketId: z.string(),
    price: z.number(),
    confirmation: z.string(),
  }),
})

const result = await execute({
  client,
  tools,
  exits: [TicketBooked],
})

if (result.is(TicketBooked)) {
  console.log('Booked:', result.value.ticketId) // Fully typed
}

return {
  action: 'ticket_booked',
  ticketId: 'TKT-12345',
  price: 299,
  confirmation: 'ABC123',
}

import { ThinkSignal } from 'llmz'

const complexAnalysis = new Tool({
  name: 'analyze',
  handler: async (data) => {
    const result = performComplexCalculation(data)
    // Force agent to reflect on results before proceeding
    throw new ThinkSignal('Analysis complete. Review data before next step.')
  },
})

// Agent-generated code
const data = await fetchLargeDataset()
return { action: 'think' } // Pause to process information

import { SnapshotSignal } from 'llmz'

const approvalRequired = new Tool({
  name: 'submitForApproval',
  handler: async (request) => {
    await saveToDatabase(request)
    // Halt execution until manual approval
    throw new SnapshotSignal('Awaiting manager approval')
  },
})

// Later, resume from snapshot
const result = await execute({
  client,
  snapshot: savedSnapshot,
})

const result = await execute({
  client,
  tools,
  hooks: {
    onTrace: (trace) => {
      // Non-blocking: log tool calls, errors, outputs
      logger.info(trace)
    },
    onExit: (exit) => {
      // Validate before allowing exit
      if (exit.action === 'transfer_money' && exit.amount > 10000) {
        throw new Error('Amount exceeds limit')
      }
    },
    onBeforeExecution: (code) => {
      // Inspect/modify generated code before execution
      if (code.includes('dangerousOperation')) {
        throw new Error('Blocked unsafe operation')
      }
    },
  },
})

git clone https://github.com/botpress/botpress
cd packages/llmz

pnpm install
pnpm test
pnpm build