LLM → JSON: {"tool": "getPrice", "params": {"from": "quebec", "to": "new york"}}
System → Response: {"price": 600}
LLM → JSON: {"tool": "checkBudget", "params": {"amount": 600}}
System → Response: {"canAfford": false}
LLM → JSON: {"tool": "notifyUser", "params": {"message": "Price too high"}}

// Check the ticket price and user's budget in one go
const price = await getTicketPrice({ from: 'quebec', to: 'new york' })
const budget = await getUserBudget()

if (price > budget) {
  await notifyUser({ message: `Price $${price} exceeds budget $${budget}` })
  return { action: 'budget_exceeded', price, budget }
} else {
  const ticketId = await buyTicket({ from: 'quebec', to: 'new york' })
  return { action: 'done', result: ticketId }
}

npm install llmz @botpress/client

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

const client = new Client({
  botId: process.env.BOTPRESS_BOT_ID!,
  token: process.env.BOTPRESS_TOKEN!,
})

const result = await execute({
  instructions: 'Calculate the sum of numbers 1 to 100',
  client,
})

if (result.isSuccess()) {
  console.log('Result:', result.output)
  console.log('Generated code:', result.iteration.code)
}

import { execute } from 'llmz'
import { Client } from '@botpress/client'
import { CLIChat } from './utils/cli-chat'

const client = new Client({
  botId: process.env.BOTPRESS_BOT_ID!,
  token: process.env.BOTPRESS_TOKEN!,
})

const chat = new CLIChat()

while (await chat.iterate()) {
  await execute({
    instructions: 'You are a helpful assistant',
    chat,
    client,
  })
}

// Chat mode - give turn back to user
return { action: 'listen' }

// Worker mode - complete with result
return { action: 'done', result: calculatedValue }

// Complex conditional logic and error handling
const price = await getTicketPrice({ from: 'quebec', to: 'new york' })

if (price > 500) {
  throw new Error('Price too high')
} else {
  const ticketId = await buyTicket({ from: 'quebec', to: 'new york' })
  return { action: 'done', result: ticketId }
}

// Check user's budget first before proceeding with purchase
const budget = await getUserBudget()

// Only proceed if we have enough funds
if (budget >= price) {
  // Purchase the ticket
  const ticket = await buyTicket(ticketDetails)
}

// Multi-line text support
yield <Text>
Hello, world!
This is a second line.
</Text>

// Composed/nested components
yield <Message>
  <Text>What do you prefer?</Text>
  <Button>Cats</Button>
  <Button>Dogs</Button>
</Message>

return { action: 'listen' }

const result = await execute({
  instructions: 'You are a helpful assistant',
  chat: myChatInstance,
  tools: [searchTool, calculatorTool],
  client,
})

if (result.is(ListenExit)) {
  // Agent is waiting for user input
}

const result = await execute({
  instructions: 'Process the customer data and generate insights',
  tools: [dataProcessorTool, analyticseTool],
  exits: [dataProcessedExit],
  client,
})

if (result.is(dataProcessedExit)) {
  console.log('Analysis complete:', result.output)
}

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

const weatherTool = new Tool({
  name: 'getWeather',
  description: 'Get current weather for a location',
  input: z.object({
    location: z.string().describe('City name or coordinates'),
    units: z.enum(['celsius', 'fahrenheit']).optional().default('celsius'),
  }),
  output: z.object({
    temperature: z.number(),
    conditions: z.string(),
    humidity: z.number(),
  }),
  handler: async ({ location, units }) => {
    // Implementation here
    return {
      temperature: 22,
      conditions: 'sunny',
      humidity: 65,
    }
  },
})

// Simple tool call
const weather = await getWeather({ location: 'New York' })

// Complex logic with multiple tools
const weather = await getWeather({ location: userLocation })
if (weather.temperature < 0) {
  const clothing = await getSuggestions({ type: 'winter', temperature: weather.temperature })
  yield <Text>It's {weather.temperature}°C! {clothing.suggestion}</Text>
} else {
  yield <Text>Nice weather! {weather.conditions} at {weather.temperature}°C</Text>
}

return { action: 'listen' }

const tool = new Tool({
  name: 'calculatePrice',
  aliases: ['getPrice', 'checkCost'],
  // ... rest of definition
})

// All of these work in generated code:
// await calculatePrice(params)
// await getPrice(params)
// await checkCost(params)

const tool = new Tool({
  name: 'logEvent',
  input: z.object({
    event: z.string(),
    userId: z.string(),
    timestamp: z.number(),
  }),
  staticInputs: {
    userId: 'user-123',
    timestamp: () => Date.now(), // Dynamic static input
  },
  handler: async ({ event, userId, timestamp }) => {
    // userId and timestamp are automatically provided
  },
})

const originalTool = new Tool({
  /* definition */
})

const wrappedTool = originalTool.clone({
  name: 'wrappedVersion',
  description: 'Enhanced version with logging',
  handler: async (input) => {
    console.log('Tool called with:', input)
    const result = await originalTool.execute(input)
    console.log('Tool returned:', result)
    return result
  },
})

console.log(weatherTool.getTypings())
// Output:
// /**
//  * Get current weather for a location
//  */
// declare function getWeather(input: {
//   location: string; // City name or coordinates
//   units?: "celsius" | "fahrenheit";
// }): Promise<{
//   temperature: number;
//   conditions: string;
//   humidity: number;
// }>;

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

const userObject = new ObjectInstance({
  name: 'user',
  properties: [
    {
      name: 'name',
      value: 'John Doe',
      writable: true,
      type: z.string(),
    },
    {
      name: 'age',
      value: 30,
      writable: false, // Read-only
      type: z.number(),
    },
    {
      name: 'preferences',
      value: { theme: 'dark', language: 'en' },
      writable: true,
      type: z.object({
        theme: z.enum(['light', 'dark']),
        language: z.string(),
      }),
    },
  ],
  tools: [
    new Tool({
      name: 'updateProfile',
      input: z.object({ name: z.string() }),
      handler: async ({ name }) => {
        // This tool is scoped to the user object
        return { success: true }
      },
    }),
  ],
})

// Reading variables
const userName = user.name // "John Doe"
const userAge = user.age // 30

// Writing to writable variables
user.name = 'Jane Smith' // ✅ Succeeds
user.preferences = { theme: 'light', language: 'es' } // ✅ Succeeds

// Attempting to write read-only variables
user.age = 25 // ❌ Throws AssignmentError

// Valid assignment
user.preferences = { theme: 'dark', language: 'fr' } // ✅

// Invalid assignment - wrong type
user.preferences = { theme: 'blue', language: 'fr' } // ❌ Throws validation error

// Invalid assignment - missing required fields
user.preferences = { theme: 'dark' } // ❌ Missing language field

// In generated code
user.name = 'Updated Name'
user.preferences.theme = 'light'

// After execution, mutations are available
console.log(result.iteration.mutations)
// [
//   {
//     object: 'user',
//     property: 'name',
//     before: 'John Doe',
//     after: 'Updated Name'
//   },
//   {
//     object: 'user',
//     property: 'preferences',
//     before: { theme: 'dark', language: 'en' },
//     after: { theme: 'light', language: 'en' }
//   }
// ]

// Tool is scoped to the user object
await user.updateProfile({ name: 'New Name' })

// This automatically updates the user object's properties
// and is tracked as a mutation

// In generated code - these will throw errors
user.newProperty = 'value' // ❌ Cannot add new properties
delete user.name // ❌ Cannot delete properties

// Only predefined properties can be modified (if writable)
user.name = 'New Name' // ✅ Allowed if writable: true

// Iteration 1: Set a variable
user.preferences = { theme: 'dark', language: 'es' }
return { action: 'think' } // Trigger thinking

// Iteration 2: Variable is still available
const currentTheme = user.preferences.theme // 'dark'

const result = await execute({
  instructions: 'Calculate the sum',
  client,
})

if (result.isSuccess()) {
  console.log('Output:', result.output)
  console.log('Exit used:', result.exit.name)
  console.log('Generated code:', result.iteration.code)
}

if (result.isError()) {
  console.error('Error:', result.error)
  console.error('Failed iteration:', result.iteration?.error)

  // Analyze failure progression
  result.iterations.forEach((iter, i) => {
    console.log(`Iteration ${i + 1}: ${iter.status.type}`)
  })
}

if (result.isInterrupted()) {
  console.log('Interrupted:', result.signal.message)

  // Save snapshot for later resumption
  const serialized = result.snapshot.toJSON()
  await database.saveSnapshot(serialized)
}

const successExit = new Exit({
  name: 'success',
  schema: z.object({
    recordsProcessed: z.number(),
    processingTime: z.number(),
  }),
})

const errorExit = new Exit({
  name: 'error',
  schema: z.object({
    errorCode: z.string(),
    details: z.string(),
  }),
})

const result = await execute({
  instructions: 'Process the data',
  exits: [successExit, errorExit],
  client,
})

// Type-safe exit handling with automatic output typing
if (result.is(successExit)) {
  // TypeScript knows result.output has the success schema
  console.log(`Processed ${result.output.recordsProcessed} records`)
  console.log(`Processing took ${result.output.processingTime}ms`)
} else if (result.is(errorExit)) {
  // TypeScript knows result.output has the error schema
  console.error(`Error ${result.output.errorCode}: ${result.output.details}`)
}

import { ListenExit, DefaultExit, ThinkExit } from 'llmz'

// Check for built-in exits
if (result.is(ListenExit)) {
  console.log('Agent is waiting for user input')
}

if (result.is(DefaultExit)) {
  // DefaultExit has success/failure discriminated union
  if (result.output.success) {
    console.log('Completed successfully:', result.output.result)
  } else {
    console.error('Completed with error:', result.output.error)
  }
}

if (result.is(ThinkExit)) {
  console.log('Agent requested thinking time')
  console.log('Current variables:', result.output.variables)
}

// Access the final iteration
const lastIteration = result.iteration
if (lastIteration) {
  console.log('Generated code:', lastIteration.code)
  console.log('Status:', lastIteration.status.type)
  console.log('Duration:', lastIteration.duration)
}

// Access all iterations to see full execution flow
result.iterations.forEach((iteration, index) => {
  console.log(`Iteration ${index + 1}:`)
  console.log('  Status:', iteration.status.type)
  console.log('  Code length:', iteration.code?.length || 0)
  console.log('  Variables:', Object.keys(iteration.variables).length)
})

// If agent generates: const hello = '1234'
const lastIteration = result.iteration
if (lastIteration) {
  console.log(lastIteration.variables.hello) // '1234'

  // Access all variables from the final iteration
  Object.entries(lastIteration.variables).forEach(([name, value]) => {
    console.log(`Variable ${name}:`, value)
  })
}

// Access tool calls from all iterations
const allToolCalls = result.iterations.flatMap((iter) => iter.traces.filter((trace) => trace.type === 'tool_call'))

console.log('Total tool calls:', allToolCalls.length)

// Access other trace types
const lastIteration = result.iteration
if (lastIteration) {
  const yields = lastIteration.traces.filter((trace) => trace.type === 'yield')
  const comments = lastIteration.traces.filter((trace) => trace.type === 'comment')
  const propertyAccess = lastIteration.traces.filter((trace) => trace.type === 'property')
}

if (result.isSuccess()) {
  // Access original execution parameters
  console.log('Instructions:', result.context.instructions)
  console.log('Loop limit:', result.context.loop)
  console.log('Temperature:', result.context.temperature)
  console.log('Model:', result.context.model)

  // Access tools and exits that were available
  console.log(
    'Available tools:',
    result.context.tools?.map((t) => t.name)
  )
  console.log(
    'Available exits:',
    result.context.exits?.map((e) => e.name)
  )
}

if (result.isError()) {
  console.error('Execution failed:', result.error)

  // Analyze the failure progression
  const failedIteration = result.iteration
  if (failedIteration) {
    switch (failedIteration.status.type) {
      case 'execution_error':
        console.error('Code execution failed:', failedIteration.status.execution_error.message)
        console.error('Stack trace:', failedIteration.status.execution_error.stack)
        console.error('Failed code:', failedIteration.code)
        break

      case 'generation_error':
        console.error('LLM generation failed:', failedIteration.status.generation_error.message)
        break

      case 'invalid_code_error':
        console.error('Invalid code generated:', failedIteration.status.invalid_code_error.message)
        console.error('Invalid code:', failedIteration.code)
        break

      case 'aborted':
        console.error('Execution aborted:', failedIteration.status.aborted.reason)
        break
    }
  }

  // Review all iterations to understand failure progression
  console.log('Iterations before failure:', result.iterations.length)
  result.iterations.forEach((iter, i) => {
    console.log(`Iteration ${i + 1}: ${iter.status.type}`)
  })
}

const result = await execute({
  instructions: 'Process large dataset with pauseable operation',
  tools: [snapshotCapableTool],
  client,
})

if (result.isInterrupted()) {
  console.log('Execution paused:', result.signal.message)

  // Serialize snapshot for persistence
  const serialized = result.snapshot.toJSON()
  await database.saveSnapshot('execution-123', serialized)

  // Later, resume from snapshot
  const snapshot = Snapshot.fromJSON(serialized)
  snapshot.resolve({ resumeData: 'Operation completed' })

  const continuation = await execute({
    snapshot,
    instructions: result.context.instructions,
    tools: result.context.tools,
    exits: result.context.exits,
    client,
  })

  if (continuation.isSuccess()) {
    console.log('Resumed execution completed:', continuation.output)
  }
}

await execute({
  onTrace: ({ trace, iteration }) => {
    console.log(`Iteration ${iteration}: ${trace.type}`, trace)

    // Log specific trace types
    if (trace.type === 'tool_call') {
      console.log(`Tool ${trace.tool_name} called with:`, trace.input)
    }
  },
  // ... other props
})

await execute({
  onIterationEnd: async (iteration, controller) => {
    console.log(`Iteration ${iteration.id} ended with status: ${iteration.status.type}`)

    // Add delays, cleanup, or conditional logic
    if (iteration.status.type === 'execution_error') {
      await logError(iteration.error)

      // Add delay before retry
      await new Promise((resolve) => setTimeout(resolve, 1000))
    }

    // Can use controller to abort execution if needed
    if (shouldAbort(iteration)) {
      controller.abort('Custom abort reason')
    }
  },
  // ... other props
})

await execute({
  onExit: async (result) => {
    console.log(`Exiting with: ${result.exit.name}`, result.result)

    // Implement guardrails
    if (result.exit.name === 'approve_loan' && result.result.amount > 10000) {
      throw new Error('Manager approval required for loans over $10,000')
    }

    // Send notifications
    await notifyStakeholders(result)

    // Log to audit trail
    await auditLog.record({
      action: result.exit.name,
      data: result.result,
      timestamp: Date.now(),
    })
  },
  // ... other props
})

await execute({
  onBeforeExecution: async (iteration, controller) => {
    console.log('Generated code:', iteration.code)

    // Code modification
    if (iteration.code?.includes('dangerousOperation')) {
      return {
        code: iteration.code.replace('dangerousOperation', 'safeOperation'),
      }
    }

    // Guardrails - throw to prevent execution
    if (iteration.code?.includes('forbidden')) {
      throw new Error('Forbidden operation detected')
    }

    // Add security checks
    const securityIssues = await scanCodeForSecurity(iteration.code)
    if (securityIssues.length > 0) {
      throw new Error(`Security issues found: ${securityIssues.join(', ')}`)
    }

    // Log code generation for audit
    await auditCodeGeneration(iteration.code)
  },
  // ... other props
})

await execute({
  onBeforeTool: async ({ iteration, tool, input, controller }) => {
    console.log(`Executing tool: ${tool.name}`, input)

    // Input modification
    if (tool.name === 'sendEmail') {
      return {
        input: {
          ...input,
          subject: `[Automated] ${input.subject}`, // Add prefix
          from: '[email protected]', // Override sender
        },
      }
    }

    // Access control
    if (tool.name === 'deleteFile' && !hasPermission(input.path)) {
      throw new Error('Insufficient permissions to delete file')
    }

    // Rate limiting
    const rateLimit = await checkRateLimit(tool.name)
    if (rateLimit.exceeded) {
      throw new Error(`Rate limit exceeded for ${tool.name}`)
    }

    // Validation
    await validateToolUsage(tool, input)
  },
  // ... other props
})

await execute({
  onAfterTool: async ({ iteration, tool, input, output, controller }) => {
    console.log(`Tool ${tool.name} completed`, { input, output })

    // Output modification
    if (tool.name === 'fetchUserData') {
      return {
        output: {
          ...output,
          // Remove sensitive data before LLM sees it
          ssn: undefined,
          creditCard: undefined,
          // Add metadata
          fetchedAt: Date.now(),
        },
      }
    }

    // Result enhancement
    if (tool.name === 'calculatePrice') {
      return {
        output: {
          ...output,
          currency: 'USD',
          timestamp: Date.now(),
          exchangeRate: await getCurrentExchangeRate(),
        },
      }
    }

    // Logging and caching
    await Promise.all([
      cacheResult(tool.name, input, output),
      logToolExecution(tool.name, input, output),
      updateMetrics(tool.name, Date.now() - tool.startTime),
    ])
  },
  // ... other props
})

await execute({
  onBeforeTool: async ({ tool, input }) => {
    // Apply different logic based on tool
    switch (tool.name) {
      case 'payment':
        return await handlePaymentValidation(input)
      case 'notification':
        return await handleNotificationThrottling(input)
      default:
        return // No modification
    }
  },
})

await execute({
  onExit: async (result) => {
    try {
      await criticalPostProcessing(result)
    } catch (error) {
      // Log error but don't fail the entire execution
      console.error('Post-processing failed:', error)

      // Optionally throw to retry the iteration
      if (error.retryable) {
        throw new Error('Retrying due to recoverable error')
      }
    }
  },
})

let executionMetrics = { toolCalls: 0, totalTime: 0 }

await execute({
  onBeforeTool: async ({ tool }) => {
    executionMetrics.toolCalls++
    tool.startTime = Date.now()
  },

  onAfterTool: async ({ tool }) => {
    executionMetrics.totalTime += Date.now() - tool.startTime
  },

  onIterationEnd: async () => {
    console.log('Execution metrics:', executionMetrics)
  },
})

import { SnapshotSignal, Tool } from 'llmz'

const longRunningTool = new Tool({
  name: 'processLargeDataset',
  input: z.object({ datasetId: z.string() }),
  async handler({ datasetId }) {
    // Start processing
    const dataset = await loadDataset(datasetId)

    // At any point, pause execution for later resumption
    if (dataset.size > LARGE_THRESHOLD) {
      throw new SnapshotSignal(
        'Dataset is large, pausing for background processing',
        'Processing will continue once background job completes'
      )
    }

    return { processed: true }
  },
})

const result = await execute({
  instructions: 'Process the uploaded dataset',
  tools: [longRunningTool],
  client,
})

if (result.isInterrupted()) {
  console.log('Execution paused:', result.signal.message)

  // Serialize snapshot for persistence
  const serialized = result.snapshot.toJSON()
  await database.saveSnapshot('job-123', serialized)

  // Start background processing
  await backgroundJobQueue.add('process-dataset', {
    snapshotId: 'job-123',
    datasetId: result.signal.toolCall?.input.datasetId,
  })
}

// Later, when background job completes
const serialized = await database.getSnapshot('job-123')
const snapshot = Snapshot.fromJSON(serialized)

// Resolve the snapshot with the result
snapshot.resolve({
  processed: true,
  recordCount: 1000000,
  processingTime: 3600000,
})

// Continue execution from where it left off
const continuation = await execute({
  snapshot,
  instructions: 'Process the uploaded dataset', // Same as original
  tools: [longRunningTool], // Same tools
  client,
})

if (continuation.isSuccess()) {
  console.log('Processing completed:', continuation.output)
}

// If background processing fails
const snapshot = Snapshot.fromJSON(serialized)
snapshot.reject(new Error('Background processing failed'))

const continuation = await execute({
  snapshot,
  // ... same parameters
})

// The agent will receive the error and can handle it

const analysisTool = new Tool({
  name: 'analyzeData',
  input: z.object({ data: z.array(z.number()) }),
  async handler({ data }) {
    const result = performAnalysis(data)

    // Force the agent to think about the results before responding
    throw new ThinkSignal(
      'Analysis complete, consider the implications',
      `Found ${result.anomalies.length} anomalies and ${result.patterns.length} patterns`
    )
  },
})

// In generated code
const analysisResult = await analyzeData({ data: userInputData })

// Think about the results before responding to user
return { action: 'think' }

// In generated code
const price = await calculatePrice({ items: cartItems })
const budget = await getUserBudget()

// Think about pricing vs budget with specific context
return {
  action: 'think',
  price,
  budget,
  recommendation: price > budget ? 'deny' : 'approve',
}

const result = await execute({
  instructions: 'Analyze the user data and provide recommendations',
  tools: [analysisTool],
  client,
})

if (result.is(ThinkExit)) {
  console.log('Agent is thinking about:', result.output.variables)

  // Continue execution after thinking
  const continuation = await execute({
    instructions: result.context.instructions,
    tools: result.context.tools,
    // Variables from thinking are automatically preserved
    client,
  })
}

import { CitationsManager } from 'llmz'

const citations = new CitationsManager()

// Register sources and get citation tags
const source1 = citations.registerSource({
  file: 'document.pdf',
  page: 5,
  title: 'Company Policy',
})

const source2 = citations.registerSource({
  url: 'https://example.com/article',
  title: 'Best Practices',
})

console.log(source1.tag) // "【0】"
console.log(source2.tag) // "【1】"

// Use tags in content
const content = `The policy states employees must arrive on time${source1.tag}. However, best practices suggest flexibility${source2.tag}.`

const ragTool = new Tool({
  name: 'search',
  description: 'Searches in the knowledge base for relevant information.',
  input: z.string().describe('The query to search in the knowledge base.'),
  async handler(query) {
    // Perform semantic search
    const { passages } = await client.searchFiles({
      query,
      limit: 20,
      contextDepth: 3,
    })

    if (!passages.length) {
      throw new ThinkSignal(
        'No results found',
        'No results were found in the knowledge base. Try rephrasing your question.'
      )
    }

    // Build response with citations
    let message: string[] = ['Here are the search results:']
    let { tag: example } = chat.citations.registerSource({}) // Example citation

    // Register each passage as a source
    for (const passage of passages) {
      const { tag } = chat.citations.registerSource({
        file: passage.file.key,
        title: passage.file.tags.title,
      })

      message.push(`<${tag} file="${passage.file.key}">`)
      message.push(`**${passage.file.tags.title}**`)
      message.push(passage.content)
      message.push(`</${tag}>`)
    }

    // Provide context with citation instructions
    throw new ThinkSignal(
      `Got search results. When answering, you MUST add inline citations (eg: "The price is $10${example} ...")`,
      message.join('\n').trim()
    )
  },
})

class CLIChat extends Chat {
  public citations: CitationsManager = new CitationsManager()

  private async sendMessage(input: RenderedComponent) {
    if (input.type === 'Text') {
      let sources: string[] = []

      // Extract citations and format them for display
      const { cleaned } = this.citations.extractCitations(input.text, (citation) => {
        let idx = chalk.bgGreenBright.black.bold(` ${sources.length + 1} `)
        sources.push(`${idx}: ${JSON.stringify(citation.source)}`)
        return `${idx}` // Replace 【0】 with [1]
      })

      // Display cleaned text and sources
      console.log(`🤖 Agent: ${cleaned}`)

      if (sources.length) {
        console.log(chalk.dim('Citations'))
        console.log(chalk.dim('========='))
        console.log(chalk.dim(sources.join('\n')))
      }
    }
  }
}

// Agent can reference multiple sources in one citation
const content = 'This fact is supported by multiple studies【0,1,3】'

const { cleaned, citations } = manager.extractCitations(content)
// citations array contains entries for sources 0, 1, and 3

// Remove citations from complex objects
const dataWithCitations = {
  summary: 'The report shows positive trends【0】',
  details: {
    revenue: 'Increased by 15%【1】',
    costs: 'Reduced by 8%【2】',
  },
}

const [cleanData, extractedCitations] = manager.removeCitationsFromObject(dataWithCitations)
// cleanData has citations removed, extractedCitations contains path + citation info

// Remove all citation tags from content
const textWithCitations = 'This statement【0】 has multiple【1,2】 citations.'
const cleaned = CitationsManager.stripCitationTags(textWithCitations)
// Result: "This statement has multiple citations."

await execute({
  // Dynamic instructions based on context
  instructions: (ctx) => {
    const timeOfDay = new Date().getHours()
    const greeting = timeOfDay < 12 ? 'Good morning' : 'Good afternoon'
    return `${greeting}! You are a helpful assistant with access to ${ctx.tools?.length || 0} tools.`
  },

  // Dynamic tools based on user permissions
  tools: async (ctx) => {
    const userPermissions = await getUserPermissions(ctx.userId)
    return allTools.filter((tool) => userPermissions.includes(tool.permission))
  },

  // Dynamic objects with current state
  objects: async (ctx) => {
    const userPreferences = await loadUserPreferences(ctx.userId)
    return [
      new ObjectInstance({
        name: 'user',
        properties: [{ name: 'preferences', value: userPreferences, writable: true }],
      }),
    ]
  },

  client,
})

# Install dependencies
pnpm install

# Set up environment variables
cp .env.example .env
# Edit .env with your Botpress credentials

# Run a specific example
pnpm start 01_chat_basic
pnpm start chat_basic
pnpm start 01

# List all available examples
pnpm start

BOTPRESS_BOT_ID=your_bot_id_here
BOTPRESS_TOKEN=your_token_here