Agents

import { isStepCount } from 'frogbot'
import type { AgentConfig } from 'frogbot'

export const supportAgent: AgentConfig = {
  slug: 'support',
  model: 'fast',
  instructions: 'Answer support questions and use tools when needed.',
  stopWhen: isStepCount(8),
  access: ({ req }) => Boolean(req.user)
}

import type { AgentConfig } from 'frogbot'

export const assistant: AgentConfig = {
  slug: 'assistant',
  model: { default: 'bedrock/zai.glm-5', options: '*' },
  instructions: 'You are a concise and friendly assistant.'
}

import { buildConfig } from 'frogbot'
import { general } from 'frogbot/agents'

export default buildConfig({
  // required options omitted
  ai: {
    defaultModel: 'openai/gpt-4o-mini',
    providers: {
      openai: true
    }
  },
  agents: [general()]
})

agents: [general({ tools: [lookupTicket] })]

export const supportAgent: AgentConfig = {
  slug: 'support',
  model: 'fast',
  instructions: 'Answer support questions.',
  profile: {
    name: 'Ada',
    avatar: '/agents/ada.png',
    description: 'Answers support questions.'
  }
}

import type { Tool } from 'frogbot'
import { z } from 'zod'

const lookupInput = z.object({
  ticket: z.string()
})

export const lookupTicket: Tool<
  typeof lookupInput,
  { ticket: string; status: string }
> = {
  slug: 'lookup-ticket',
  description: 'Look up the current status of a support ticket',
  inputSchema: lookupInput,
  execute: async ({ ticket }, ctx) => {
    ctx.frogbot.logger.info({ ticket }, 'Looking up ticket')

    return {
      ticket,
      status: 'open'
    }
  }
}

export const supportAgent: AgentConfig = {
  slug: 'support',
  model: 'fast',
  instructions: 'Use lookup-ticket before reporting ticket status.',
  tools: [lookupTicket]
}

export const lookupTicket: Tool<typeof lookupInput, LookupResult> = {
  component: '@/components/LookupTicket#LookupTicket',
  slug: 'lookup-ticket',
  description: 'Look up the current status of a support ticket',
  inputSchema: lookupInput,
  execute: lookupTicketStatus
}

import type { SkillConfig } from 'frogbot'

const supportSkill: SkillConfig = {
  slug: 'support-playbook',
  description: 'Procedures for handling support requests',
  license: 'MIT',
  compatibility: 'Requires authenticated support access',
  metadata: { owner: 'support' },
  instructions: 'Identify the request category before choosing a procedure.',
  resources: [
    {
      path: 'refunds.md',
      description: 'Refund eligibility and workflow',
      content: 'Verify the purchase date and payment status before issuing a refund.'
    },
    {
      path: 'account.md',
      description: 'Account-specific guidance',
      content: async ({ req }) => loadAccountGuidance(req.user?.id)
    }
  ]
}

export const supportAgent: AgentConfig = {
  slug: 'support',
  model: 'fast',
  instructions: 'Use the relevant skill before answering policy questions.',
  skills: [supportSkill]
}

export default buildConfig({
  tools: [lookupTicket],
  agents: [supportAgent, reportingAgent]
})

export const reportingAgent: AgentConfig = {
  slug: 'reporting',
  model: 'fast',
  instructions: 'Create reports from approved data sources.',
  inheritTools: false,
  tools: [queryWarehouse]
}

import { todoTools } from 'frogbot/tools'

export default buildConfig({
  tools: [...todoTools],
  agents: [supportAgent]
})

export const supportAgent: AgentConfig = {
  slug: 'support',
  model: 'fast',
  instructions: 'Keep the todo list current while completing multi-step work.',
  tools: [...todoTools]
}

import { question } from 'frogbot/tools'

export const plannerAgent: AgentConfig = {
  slug: 'planner',
  model: 'fast',
  instructions: 'Ask before choosing between materially different plans.',
  tools: [question]
}

src/
├── agents/
│   ├── index.ts
│   └── support.ts
└── tools/
    └── lookup-ticket.ts
frogbot.config.ts

// src/agents/index.ts
import { supportAgent } from './support'

export const agents = [supportAgent]

// frogbot.config.ts
import { buildConfig } from 'frogbot'
import { agents } from './src/agents'

export default buildConfig({
  // secret, db, collections, and ai omitted
  agents
})

const result = await frogbot.agents.support.generate({
  prompt: 'What is the status of ticket SUP-42?'
})

console.log(result.text)

const result = await frogbot.agents.support.stream({
  messages: [
    {
      id: 'message-1',
      role: 'user',
      parts: [{ type: 'text', text: 'Help with ticket SUP-42' }]
    }
  ]
})

for await (const text of result.textStream) {
  process.stdout.write(text)
}

await frogbot.agents.support.generate({
  prompt: 'Review ticket SUP-42',
  req,
  overrideAccess: false
})

await frogbot.agents.support.generate({
  prompt: 'Review ticket SUP-42 again',
  chatId,
  req,
  overrideAccess: false
})

export const reportingAgent: AgentConfig = {
  slug: 'reporting',
  model: 'fast',
  instructions: 'Analyze account activity and report anomalies.',
  triggers: [
    {
      type: 'schedule',
      slug: 'frequent-check',
      schedule: { every: '30m' },
      prompt: 'Check account activity and report any anomalies.'
    },
    {
      type: 'schedule',
      slug: 'daily-rollup',
      schedule: { cron: '0 0 * * *' },
      handler: async ({ agent, req, job }) => {
        await agent.generate({
          prompt: `Prepare the rollup scheduled for ${job.scheduledFor.toISOString()}`,
          req
        })
      }
    }
  ]
}

curl http://localhost:3000/api/agents/support \
  --request POST \
  --header "Authorization: Bearer $FROGBOT_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{ "prompt": "Help with ticket SUP-42" }'

curl http://localhost:3000/api/agents/support \
  --request POST \
  --header "Authorization: Bearer $FROGBOT_TOKEN" \
  --header "Content-Type: application/json" \
  --header "Accept: text/event-stream" \
  --data '{ "prompt": "Help with ticket SUP-42" }'

curl http://localhost:3000/api/agents/support \
  --request POST \
  --header "Authorization: Bearer $FROGBOT_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{ "prompt": "What changed since then?", "chatId": "CHAT_ID" }'

access: ({ req }) => Boolean(req.user)