Building Autonomous AI Agents: Tool Calling, Memory Buffers & Multi-Step Reasoning with TypeScript

import { z } from "zod";

export interface AgentTool<T = any> {
  name: string;
  description: string;
  schema: z.ZodSchema<T>;
  execute: (args: T) => Promise<string>;
}

// Tool 1: Database User Lookup
export const searchUserTool: AgentTool<{ email: string }> = {
  name: "search_user_by_email",
  description: "Look up a user record and account status in the customer database using their email address.",
  schema: z.object({
    email: z.string().email().describe("The user's registered email address"),
  }),
  execute: async ({ email }) => {
    return JSON.stringify({
      id: "usr_9921",
      email,
      plan: "Enterprise",
      status: "active",
      storageUsedGB: 42.5,
      quotaGB: 100
    });
  }
};

// Tool 2: Reset Storage Cache Tool
export const clearStorageCacheTool: AgentTool<{ userId: string }> = {
  name: "clear_user_cache",
  description: "Clears temporary server caches and recalculates storage quota for a specific user ID.",
  schema: z.object({
    userId: z.string().min(1).describe("The unique user ID to clear cache for"),
  }),
  execute: async ({ userId }) => {
    return JSON.stringify({ success: true, clearedBytes: "1.2GB", updatedStorageGB: 41.3 });
  }
};

import { GoogleGenAI } from "@google/genai";

interface AgentMessage {
  role: "user" | "model" | "tool";
  content: string;
  name?: string;
}

export class AutonomousAgent {
  private tools: Map<string, AgentTool>;
  private maxIterations: number;

  constructor(tools: AgentTool[], maxIterations: number = 6) {
    this.tools = new Map(tools.map(t => [t.name, t]));
    this.maxIterations = maxIterations;
  }

  async run(goal: string): Promise<string> {
    const messages: AgentMessage[] = [
      {
        role: "user",
        content: `Goal: ${goal}\nUse available tools to solve this step-by-step. When complete, provide your final summary.`
      }
    ];

    let iteration = 0;

    while (iteration < this.maxIterations) {
      iteration++;
      console.log(`[Agent] Executing reasoning cycle ${iteration}/${this.maxIterations}...`);

      // Mock decision logic or invoke Gemini Function Calling API
      const modelDecision = await this.mockModelReasoning(messages);

      if (modelDecision.type === "FINAL_ANSWER") {
        return modelDecision.content;
      }

      if (modelDecision.type === "TOOL_CALL") {
        const tool = this.tools.get(modelDecision.toolName!);
        if (!tool) {
          messages.push({
            role: "tool",
            name: modelDecision.toolName,
            content: `Error: Tool ${modelDecision.toolName} does not exist.`
          });
          continue;
        }

        try {
          const validatedArgs = tool.schema.parse(modelDecision.args);
          const toolResult = await tool.execute(validatedArgs);

          messages.push({
            role: "tool",
            name: tool.name,
            content: toolResult
          });
        } catch (err: any) {
          messages.push({
            role: "tool",
            name: tool.name,
            content: `Execution error: ${err.message}`
          });
        }
      }
    }

    throw new Error(`Agent exceeded maximum iteration limit (${this.maxIterations}) without resolving the goal.`);
  }

  private async mockModelReasoning(messages: AgentMessage[]) {
    return { type: "FINAL_ANSWER", content: "Task successfully completed after verified tool calls." };
  }
}