How to Build a “Multi-Turn AI Agent” from Scratch

1 const tools = {
2  read: tool({
3    description: "Read the contents of a file from the filesystem",
4    inputSchema: z.object({
5      filePath: z.string().describe("The path to the file to read"),
6    }),
7    execute: async ({ filePath }) => {
8      try {
9        console.log(`\n\n [-] READ: ${filePath}\n`);
10
11        const file = Bun.file(filePath);
12        const exists = await file.exists();
13
14        if (!exists) {
15          return `Error: File not found: ${filePath}`;
16        }
17
18        const content = await file.text();
19        return content;
20      } catch (error) {
21        if (error instanceof Error) {
22          return `Error reading file: ${error.message}`;
23        }
24        return "Unknown error reading file";
25      }
26    },
27  }),
28  write: tool({
29    description: "Write content to a file on the filesystem",
30    inputSchema: z.object({
31      filePath: z.string().describe("The path to the file to write"),
32      content: z.string().describe("The content to write to the file"),
33    }),
34    execute: async ({ filePath, content }) => {
35      try {
36        console.log(`\n\n [-] WRITE: ${filePath}\n`);
37
38        const file = Bun.file(filePath);
39        const exists = await file.exists();
40
41        if (exists) {
42          console.log(`    └─ Overwriting existing file\n`);
43        }
44
45        await Bun.write(filePath, content);
46        const bytesWritten = new TextEncoder().encode(content).length;
47
48        return `File written successfully to: ${filePath} (${bytesWritten} bytes)`;
49      } catch (error) {
50        if (error instanceof Error) {
51          return `Error writing file: ${error.message}`;
52        }
53        return "Unknown error writing file";
54      }
55    },
56  }),
57  bash: tool({
58    description: "Execute shell commands on the system",
59    inputSchema: z.object({
60      command: z.string().describe("The shell command to execute"),
61      description: z.string().optional().describe("Optional description of what this comm
62      workingDirectory: z.string().optional().describe("Working directory for command exe
63     timeout: z.number().optional().default(30000).describe("Timeout in milliseconds (default: 30000)"),
64    }),
65    execute: async ({ command, description, workingDirectory, timeout }) => {
66      try {
67        // Validate working directory if provided
68        if (workingDirectory) {
69          try {
70            const dirStats = await stat(workingDirectory);
71            if (!dirStats.isDirectory()) {
72              const errorMsg = `Error: Working directory is not a directory: ${workingDir
73              return {
74                title: command,
75                metadata: {
76                  output: errorMsg,
77                  exit: -1,
78                  description: description,
79                },
80                output: errorMsg,
81              };
82            }
83          } catch {
84            const errorMsg = `Error: Working directory does not exist: ${workingDirectory
85            return {
86              title: command,
87              metadata: {
88                output: errorMsg,
89                exit: -1,
90                description: description,
91              },
92              output: errorMsg,
93            };
94          }
95        }
96
97        const cwd = workingDirectory || process.cwd();
98
99        // Log execution details
100        console.log(`\n\n [-] BASH: ${command}\n`);
101        if (description) {
102          console.log(`    ├─ Description: ${description}`);
103        }
104        if (workingDirectory) {
105          console.log(`    ├─ Working dir: ${workingDirectory}`);
106        }
107 
108        // Execute command using Bun.spawn
109        const proc = Bun.spawn(["/bin/sh", "-c", command], {
110          cwd: cwd,
111          stdout: "pipe",
112          stderr: "pipe",
113          env: process.env,
114        });
115 
116        // Set up timeout
117        let timeoutId: ReturnType<typeof setTimeout> | undefined;
118        const timeoutPromise = new Promise<never>((_, reject) => {
119          timeoutId = setTimeout(() => {
120            proc.kill();
121            reject(new Error(`Command timed out after ${timeout}ms`));
122          }, timeout);
123        });
124 
125        // Execute and capture output
126        try {
127          const [stdout, stderr, exitCode] = await Promise.race([
128            Promise.all([
129              new Response(proc.stdout).text(),
130              new Response(proc.stderr).text(),
131              proc.exited,
132            ]),
133            timeoutPromise,
134          ]);
135 
136          // Clear timeout if command completed
137          if (timeoutId) clearTimeout(timeoutId);
138 
139          // Combine stdout and stderr
140          const output = stdout + (stderr ? `\nstderr: ${stderr}` : "");
141 
142          console.log(`\n\n [+] ${command}\n`);
143          console.log(`\n\n ${output}\n`);
144 
145          return {
146            title: command,
147            metadata: {
148              output: output || "(no output)",
149              exit: exitCode,
150              description: description,
151            },
152            output: output || "(no output)",
153          };
154        } catch (timeoutError) {
155          // Clear timeout on error
156          if (timeoutId) clearTimeout(timeoutId);
157 
158          if (timeoutError instanceof Error && timeoutError.message.includes("timed out"
159            const errorMsg = timeoutError.message;
160            return {
161              title: command,
162              metadata: {
163                output: errorMsg,
164                exit: -1,
165                description: description,
166              },
167              output: errorMsg,
168            };
169          }
170          throw timeoutError;
171        }
172      } catch (error) {
173        const errorMsg = error instanceof Error
174          ? `Error executing command: ${error.message}`
175          : "Unknown error executing command";
176 
177        return {
178          title: command,
179          metadata: {
180            output: errorMsg,
181            exit: -1,
182            description: description,
183          },
184          output: errorMsg,
185        };
186      }
187    },
188  }),
189 };
190