Run a first voltagent example

1import { VoltAgent, Agent, Memory } from "@voltagent/core";
2import { LibSQLMemoryAdapter } from "@voltagent/libsql";
3import { createPinoLogger } from "@voltagent/logger";
4import { honoServer } from "@voltagent/server-hono";
5import { openai } from "@ai-sdk/openai";
6import { expenseApprovalWorkflow } from "./workflows";
7import { weatherTool } from "./tools";
8 
9// Create a logger instance
10const logger = createPinoLogger({
11  name: "my-agent-app",
12  level: "info",
13});
14 
15// Optional persistent memory (remove to use default in-memory)
16const memory = new Memory({
17  storage: new LibSQLMemoryAdapter({ url: "file:./.voltagent/memory.db" }),
18});
19 
20// A simple, general-purpose agent for the project.
21const agent = new Agent({
22  name: "my-agent",
23  instructions: "A helpful assistant that can check weather and help with various tasks",
24  model: openai("gpt-4o-mini"),
25  tools: [weatherTool],
26  memory,
27});
28 
29// Initialize VoltAgent with your agent(s) and workflow(s)
30new VoltAgent({
31  agents: {
32    agent,
33  },
34  workflows: {
35    expenseApprovalWorkflow,
36  },
37  server: honoServer(),
38  logger,
39});

1import { createWorkflowChain } from "@voltagent/core";
2import { z } from "zod";
3 
4export const expenseApprovalWorkflow = createWorkflowChain({
5  id: "expense-approval",
6  name: "Expense Approval Workflow",
7  purpose: "Process expense reports with manager approval for high amounts",
8 
9  input: z.object({
10    employeeId: z.string(),
11    amount: z.number(),
12    category: z.string(),
13    description: z.string(),
14  }),
15  result: z.object({
16    status: z.enum(["approved", "rejected"]),
17    approvedBy: z.string(),
18    finalAmount: z.number(),
19  }),
20})
21  // Step 1: Validate expense and check if approval needed
22  .andThen({
23    id: "check-approval-needed",
24    resumeSchema: z.object({
25      approved: z.boolean(),
26      managerId: z.string(),
27      comments: z.string().optional(),
28      adjustedAmount: z.number().optional(),
29    }),
30    execute: async ({ data, suspend, resumeData }) => {
31      // If we're resuming with manager's decision
32      if (resumeData) {
33        return {
34          ...data,
35          approved: resumeData.approved,
36          approvedBy: resumeData.managerId,
37          finalAmount: resumeData.adjustedAmount || data.amount,
38        };
39      }
40 
41      // Check if manager approval is needed (expenses over $500)
42      if (data.amount > 500) {
43        await suspend("Manager approval required", {
44          employeeId: data.employeeId,
45          requestedAmount: data.amount,
46        });
47      }
48 
49      // Auto-approve small expenses
50      return {
51        ...data,
52        approved: true,
53        approvedBy: "system",
54        finalAmount: data.amount,
55      };
56    },
57  })
58  // Step 2: Process the final decision
59  .andThen({
60    id: "process-decision",
61    execute: async ({ data }) => {
62      return {
63        status: data.approved ? "approved" : "rejected",
64        approvedBy: data.approvedBy,
65        finalAmount: data.finalAmount,
66      };
67    },
68  });