From Chatbots to Autonomous Agents: Architecture Patterns

interface ChatbotMessage {  role: "user" | "assistant";  content: string;}
interface Intent {  name: string;  confidence: number;  entities: Record<string, any>;}
class TraditionalChatbot {  private conversationHistory: ChatbotMessage[] = [];
  async processMessage(userMessage: string): Promise<string> {    // Add to history (limited to last N messages)    this.conversationHistory.push({ role: "user", content: userMessage });    if (this.conversationHistory.length > 10) {      this.conversationHistory.shift(); // Drop oldest    }
    // Intent classification    const intent = await this.classifyIntent(userMessage);
    // Route to handler based on intent    switch (intent.name) {      case "check_order":        return await this.handleOrderCheck(intent.entities);      case "return_request":        return await this.handleReturnRequest(intent.entities);      case "product_question":        return await this.handleProductQuestion(intent.entities);      default:        return "I'm not sure how to help with that. Can you rephrase?";    }  }
  private async classifyIntent(message: string): Promise<Intent> {    // Call to NLU service or LLM for intent classification    const response = await fetch("https://api.nlp-service.com/classify", {      method: "POST",      body: JSON.stringify({ text: message })    });    return response.json();  }
  private async handleOrderCheck(entities: Record<string, any>): Promise<string> {    // Fixed flow: extract order ID → query database → format response    const orderId = entities.order_id;    if (!orderId) {      return "What's your order number?";    }
    const order = await this.fetchOrder(orderId);    return `Your order ${orderId} is ${order.status}. Estimated delivery: ${order.eta}`;  }
  private async fetchOrder(orderId: string): Promise<any> {    // Database query implementation    return { status: "shipped", eta: "2025-12-05" };  }}

interface Tool {  name: string;  description: string;  parameters: Record<string, any>;  execute: (params: any) => Promise<any>;}
interface AgentStep {  thought: string;  action?: { tool: string; input: any };  observation?: any;}
class ReActAgent {  private tools: Map<string, Tool>;  private memory: ConversationMemory;  private maxIterations = 10;
  constructor(tools: Tool[], memorySystem: ConversationMemory) {    this.tools = new Map(tools.map(t => [t.name, t]));    this.memory = memorySystem;  }
  async processTask(task: string): Promise<string> {    const steps: AgentStep[] = [];    let finalAnswer: string | null = null;
    // Retrieve relevant context from memory    const context = await this.memory.retrieve(task);
    for (let i = 0; i < this.maxIterations; i++) {      // Generate next step: thought + action      const step = await this.generateNextStep(task, steps, context);      steps.push(step);
      // Check if we have a final answer      if (!step.action) {        finalAnswer = step.thought;        break;      }
      // Execute the action      const tool = this.tools.get(step.action.tool);      if (!tool) {        step.observation = { error: `Tool ${step.action.tool} not found` };        continue;      }
      try {        const result = await tool.execute(step.action.input);        step.observation = result;      } catch (error) {        step.observation = { error: error.message };      }    }
    // Store conversation in long-term memory    await this.memory.store(task, steps, finalAnswer);
    return finalAnswer || "I couldn't complete this task within the iteration limit.";  }
  private async generateNextStep(    task: string,    previousSteps: AgentStep[],    context: any  ): Promise<AgentStep> {    // Build prompt with ReAct pattern    const prompt = this.buildReActPrompt(task, previousSteps, context);
    // Call LLM to generate thought and action    const response = await this.callLLM(prompt);
    // Parse response into structured step    return this.parseReActResponse(response);  }
  private buildReActPrompt(task: string, steps: AgentStep[], context: any): string {    const toolDescriptions = Array.from(this.tools.values())      .map(t => `${t.name}: ${t.description}`)      .join("\n");
    const stepHistory = steps.map((s, i) =>      `Step ${i + 1}:\nThought: ${s.thought}\n` +      (s.action ? `Action: ${s.action.tool}(${JSON.stringify(s.action.input)})\n` : "") +      (s.observation ? `Observation: ${JSON.stringify(s.observation)}\n` : "")    ).join("\n");
    return `You are an AI agent solving tasks by reasoning and using tools.
Task: ${task}
Available Tools:${toolDescriptions}
Relevant Context from Memory:${JSON.stringify(context, null, 2)}
Previous Steps:${stepHistory || "None yet"}
Generate the next step by thinking about what to do, then choosing a tool to use.If you have enough information to answer, provide the final answer instead of an action.
Format:Thought: [your reasoning about what to do next]Action: [tool_name]Input: [tool input as JSON]
OR if ready to answer:Thought: [final reasoning]Answer: [final answer to the task]`;  }
  private parseReActResponse(response: string): AgentStep {    // Parse LLM output into structured step    const thoughtMatch = response.match(/Thought: (.+?)(?=\n|$)/s);    const actionMatch = response.match(/Action: (.+?)(?=\n|$)/);    const inputMatch = response.match(/Input: (.+?)(?=\n|$)/s);    const answerMatch = response.match(/Answer: (.+?)(?=\n|$)/s);
    const thought = thoughtMatch?.[1].trim() || "";
    if (answerMatch) {      // Final answer, no action      return { thought: answerMatch[1].trim() };    }
    if (actionMatch && inputMatch) {      return {        thought,        action: {          tool: actionMatch[1].trim(),          input: JSON.parse(inputMatch[1].trim())        }      };    }
    return { thought };  }
  private async callLLM(prompt: string): Promise<string> {    // Call to LLM API (Anthropic, OpenAI, etc.)    // Implementation would use actual API client    throw new Error("Implement LLM integration");  }}

interface Task {  id: string;  description: string;  status: "pending" | "in-progress" | "completed" | "failed";  dependencies: string[];  result?: any;  error?: string;  metadata?: any;}
interface ExecutionPlan {  goal: string;  tasks: Task[];  strategy: string;}
class PlanAndExecuteAgent {  private tools: Map<string, Tool>;  private memory: ConversationMemory;
  async execute(goal: string): Promise<any> {    // Phase 1: Planning    console.error("[Planning Phase] Decomposing goal into tasks...");    const plan = await this.createPlan(goal);    console.error(`[Planning Phase] Created plan with ${plan.tasks.length} tasks`);
    // Phase 2: Execution    console.error("[Execution Phase] Executing tasks...");    const results = await this.executePlan(plan);
    // Phase 3: Synthesis    console.error("[Synthesis Phase] Combining results...");    const finalResult = await this.synthesizeResults(goal, plan, results);
    return finalResult;  }
  private async createPlan(goal: string): Promise<ExecutionPlan> {    // Retrieve relevant past plans from memory    const pastExperiences = await this.memory.retrieve(goal);
    const planningPrompt = `You are a planning agent. Decompose this goal into executable tasks.
Goal: ${goal}
Available Tools:${Array.from(this.tools.values()).map(t => `- ${t.name}: ${t.description}`).join("\n")}
Past Similar Tasks:${JSON.stringify(pastExperiences, null, 2)}
Create a plan with tasks that:1. Are independent where possible (for parallel execution)2. Explicitly state dependencies3. Map to available tools4. Include verification steps
Return format:{  "strategy": "explanation of approach",  "tasks": [    {      "id": "task-1",      "description": "what to do",      "tool": "tool_name",      "dependencies": [],      "params": {}    }  ]}`;
    const planResponse = await this.callLLM(planningPrompt);    const planData = JSON.parse(planResponse);
    return {      goal,      strategy: planData.strategy,      tasks: planData.tasks.map((t: any) => ({        id: t.id,        description: t.description,        status: "pending" as const,        dependencies: t.dependencies || [],        metadata: { tool: t.tool, params: t.params }      }))    };  }
  private async executePlan(plan: ExecutionPlan): Promise<Map<string, any>> {    const results = new Map<string, any>();    const taskMap = new Map(plan.tasks.map(t => [t.id, t]));
    // Execute tasks respecting dependencies    while (results.size < plan.tasks.length) {      // Find tasks ready to execute (no pending dependencies)      const readyTasks = plan.tasks.filter(task => {        if (task.status !== "pending") return false;
        return task.dependencies.every(depId => {          const depTask = taskMap.get(depId);          return depTask?.status === "completed";        });      });
      if (readyTasks.length === 0) {        // Check if we're stuck (circular dependencies or all failed)        const pendingTasks = plan.tasks.filter(t => t.status === "pending");        if (pendingTasks.length > 0) {          console.error("[Execution Phase] Stuck - circular dependencies detected");          break;        }        break;      }
      // Execute ready tasks in parallel      console.error(`[Execution Phase] Executing ${readyTasks.length} tasks in parallel`);      await Promise.all(        readyTasks.map(task => this.executeTask(task, results))      );    }
    return results;  }
  private async executeTask(task: Task, results: Map<string, any>): Promise<void> {    task.status = "in-progress";    console.error(`[Task ${task.id}] Starting: ${task.description}`);
    try {      // Get dependency results      const depResults = task.dependencies.reduce((acc, depId) => {        acc[depId] = results.get(depId);        return acc;      }, {} as Record<string, any>);
      // Execute tool with parameters and dependency results      const tool = this.tools.get(task.metadata.tool);      if (!tool) {        throw new Error(`Tool ${task.metadata.tool} not found`);      }
      const params = {        ...task.metadata.params,        dependencyResults: depResults      };
      const result = await tool.execute(params);
      task.status = "completed";      task.result = result;      results.set(task.id, result);
      console.error(`[Task ${task.id}] Completed successfully`);    } catch (error) {      task.status = "failed";      task.error = error.message;      results.set(task.id, { error: error.message });
      console.error(`[Task ${task.id}] Failed: ${error.message}`);    }  }
  private async synthesizeResults(    goal: string,    plan: ExecutionPlan,    results: Map<string, any>  ): Promise<any> {    const synthesisPrompt = `You executed a plan to achieve a goal. Synthesize the results into a coherent answer.
Goal: ${goal}
Plan Strategy: ${plan.strategy}
Task Results:${Array.from(results.entries()).map(([id, result]) =>  `${id}: ${JSON.stringify(result)}`).join("\n")}
Provide a comprehensive answer to the original goal, incorporating insights from all tasks.`;
    const synthesis = await this.callLLM(synthesisPrompt);
    // Store successful plan in memory for future reference    if (results.size === plan.tasks.length) {      await this.memory.store(goal, { plan, results: Array.from(results.entries()) }, synthesis);    }
    return synthesis;  }
  private async callLLM(prompt: string): Promise<string> {    throw new Error("Implement LLM integration");  }}

interface MemoryEntry {  timestamp: Date;  content: any;  metadata: Record<string, any>;  embedding?: number[];}
// Simple buffer memory (chatbot style)class BufferMemory {  private buffer: MemoryEntry[] = [];  private maxSize = 10;
  async store(content: any, metadata: Record<string, any> = {}): Promise<void> {    this.buffer.push({ timestamp: new Date(), content, metadata });    if (this.buffer.length > this.maxSize) {      this.buffer.shift(); // FIFO eviction    }  }
  async retrieve(query: string): Promise<any[]> {    // Return all buffer contents (no filtering)    return this.buffer.map(e => e.content);  }
  async clear(): Promise<void> {    this.buffer = [];  }}
// Vector-based long-term memory (agent style)class VectorMemory {  private vectorStore: VectorDatabase;  private embeddingModel: EmbeddingModel;
  constructor(vectorStore: VectorDatabase, embeddingModel: EmbeddingModel) {    this.vectorStore = vectorStore;    this.embeddingModel = embeddingModel;  }
  async store(content: any, metadata: Record<string, any> = {}): Promise<void> {    // Generate embedding for semantic search    const text = this.contentToText(content);    const embedding = await this.embeddingModel.embed(text);
    await this.vectorStore.insert({      timestamp: new Date(),      content,      metadata: {        ...metadata,        importance: this.calculateImportance(content, metadata)      },      embedding    });  }
  async retrieve(query: string, options: { limit?: number; threshold?: number } = {}): Promise<any[]> {    // Semantic search using embeddings    const queryEmbedding = await this.embeddingModel.embed(query);
    const results = await this.vectorStore.search({      embedding: queryEmbedding,      limit: options.limit || 5,      threshold: options.threshold || 0.7    });
    // Return most relevant memories, weighted by recency and importance    return results      .map(r => ({        content: r.content,        relevance: r.similarity,        recency: this.calculateRecency(r.timestamp),        importance: r.metadata.importance      }))      .sort((a, b) => {        const scoreA = a.relevance * 0.6 + a.recency * 0.2 + a.importance * 0.2;        const scoreB = b.relevance * 0.6 + b.recency * 0.2 + b.importance * 0.2;        return scoreB - scoreA;      })      .map(r => r.content);  }
  async forget(criteria: { olderThan?: Date; importance?: number }): Promise<void> {    // Selective forgetting based on time and importance    const deleteFilter: any = {};
    if (criteria.olderThan) {      deleteFilter.timestamp = { $lt: criteria.olderThan };    }    if (criteria.importance !== undefined) {      deleteFilter["metadata.importance"] = { $lt: criteria.importance };    }
    await this.vectorStore.delete(deleteFilter);  }
  private calculateImportance(content: any, metadata: Record<string, any>): number {    // Heuristic scoring: user corrections, explicit feedback, task outcomes    let score = 0.5; // baseline
    if (metadata.userCorrection) score += 0.3;    if (metadata.explicitFeedback) score += 0.2;    if (metadata.taskSuccess === false) score += 0.15; // Learn from failures    if (metadata.toolError) score += 0.1; // Remember issues
    return Math.min(score, 1.0);  }
  private calculateRecency(timestamp: Date): number {    const ageMs = Date.now() - timestamp.getTime();    const ageDays = ageMs / (1000 * 60 * 60 * 24);
    // Exponential decay: fresh memories score higher    return Math.exp(-ageDays / 30); // 30-day half-life  }
  private contentToText(content: any): string {    if (typeof content === "string") return content;    return JSON.stringify(content);  }}
// Hybrid memory system for production agentsclass HybridMemory implements ConversationMemory {  private shortTerm: BufferMemory;  private longTerm: VectorMemory;
  constructor(vectorStore: VectorDatabase, embeddingModel: EmbeddingModel) {    this.shortTerm = new BufferMemory();    this.longTerm = new VectorMemory(vectorStore, embeddingModel);  }
  async store(task: string, steps: any[], result: any): Promise<void> {    // Store in short-term for immediate recall    await this.shortTerm.store({ task, steps, result });
    // Store in long-term for semantic retrieval    await this.longTerm.store(      { task, steps, result },      {        taskSuccess: result !== null,        stepCount: steps.length,        timestamp: new Date()      }    );  }
  async retrieve(query: string): Promise<any> {    // Combine both memory systems    const recent = await this.shortTerm.retrieve(query);    const relevant = await this.longTerm.retrieve(query, { limit: 3 });
    return {      recentContext: recent,      relevantExperiences: relevant    };  }}

interface AgentCapability {  domain: string;  description: string;  tools: string[];}
interface SubAgent {  id: string;  capability: AgentCapability;  execute: (task: string) => Promise<any>;}
class OrchestratorAgent {  private subAgents: Map<string, SubAgent>;  private memory: ConversationMemory;
  constructor(subAgents: SubAgent[], memory: ConversationMemory) {    this.subAgents = new Map(subAgents.map(a => [a.id, a]));    this.memory = memory;  }
  async handleRequest(userRequest: string): Promise<any> {    console.error("[Orchestrator] Analyzing request...");
    // Step 1: Analyze request and determine required agents    const analysis = await this.analyzeRequest(userRequest);
    console.error(`[Orchestrator] Routing to ${analysis.requiredAgents.length} agents`);
    // Step 2: Route to appropriate subagents    const subResults = await this.coordinateSubAgents(analysis);
    // Step 3: Synthesize results    console.error("[Orchestrator] Synthesizing results...");    const finalAnswer = await this.synthesize(userRequest, analysis, subResults);
    return finalAnswer;  }
  private async analyzeRequest(request: string): Promise<{    intent: string;    requiredAgents: string[];    executionStrategy: "sequential" | "parallel" | "iterative";  }> {    const agentDescriptions = Array.from(this.subAgents.values())      .map(a => `${a.id}: ${a.capability.description}`)      .join("\n");
    const analysisPrompt = `You are an orchestrator analyzing which specialized agents to use.
User Request: ${request}
Available Agents:${agentDescriptions}
Determine:1. What is the user trying to accomplish (intent)?2. Which agents are needed?3. Should they work sequentially (one after another) or in parallel?
Return JSON:{  "intent": "description",  "requiredAgents": ["agent-id-1", "agent-id-2"],  "executionStrategy": "sequential" | "parallel"}`;
    const response = await this.callLLM(analysisPrompt);    return JSON.parse(response);  }
  private async coordinateSubAgents(analysis: {    intent: string;    requiredAgents: string[];    executionStrategy: "sequential" | "parallel" | "iterative";  }): Promise<Map<string, any>> {    const results = new Map<string, any>();
    if (analysis.executionStrategy === "parallel") {      // Run all agents simultaneously      const agentPromises = analysis.requiredAgents.map(async agentId => {        const agent = this.subAgents.get(agentId);        if (!agent) return null;
        console.error(`[SubAgent ${agentId}] Starting parallel execution`);        const result = await agent.execute(analysis.intent);        results.set(agentId, result);        return result;      });
      await Promise.all(agentPromises);
    } else if (analysis.executionStrategy === "sequential") {      // Run agents one after another, passing context      let context = analysis.intent;
      for (const agentId of analysis.requiredAgents) {        const agent = this.subAgents.get(agentId);        if (!agent) continue;
        console.error(`[SubAgent ${agentId}] Starting sequential execution`);        const result = await agent.execute(context);        results.set(agentId, result);
        // Next agent gets previous results as context        context = `${analysis.intent}\n\nPrevious agent results: ${JSON.stringify(result)}`;      }    }
    return results;  }
  private async synthesize(    request: string,    analysis: any,    results: Map<string, any>  ): Promise<any> {    const synthesisPrompt = `Combine results from multiple specialized agents into a coherent response.
User Request: ${request}
Agent Results:${Array.from(results.entries()).map(([id, result]) =>  `${id}:\n${JSON.stringify(result, null, 2)}`).join("\n\n")}
Provide a comprehensive, natural response that addresses the user's request.`;
    return await this.callLLM(synthesisPrompt);  }
  private async callLLM(prompt: string): Promise<string> {    throw new Error("Implement LLM integration");  }}

class GuardrailSystem {  async validateInput(input: string): Promise<{ safe: boolean; reason?: string }> {    // Check for prompt injection patterns    const injectionPatterns = [      /ignore previous instructions/i,      /new instructions:/i,      /you are now/i,      /system prompt/i    ];
    for (const pattern of injectionPatterns) {      if (pattern.test(input)) {        return { safe: false, reason: "Potential prompt injection detected" };      }    }
    // Call content moderation API    const moderation = await this.callModerationAPI(input);    if (!moderation.safe) {      return { safe: false, reason: moderation.reason };    }
    return { safe: true };  }
  async authorizeToolUse(    agentId: string,    toolName: string,    params: any  ): Promise<{ authorized: boolean; reason?: string }> {    // Check against permission matrix    const permissions = await this.getAgentPermissions(agentId);
    if (!permissions.tools.includes(toolName)) {      return { authorized: false, reason: `Agent lacks permission for tool: ${toolName}` };    }
    // Check for sensitive operations requiring elevated permissions    if (this.isSensitiveTool(toolName) && !permissions.elevated) {      return { authorized: false, reason: "Sensitive tool requires elevated permissions" };    }
    // Rate limiting    const withinRateLimit = await this.checkRateLimit(agentId, toolName);    if (!withinRateLimit) {      return { authorized: false, reason: "Rate limit exceeded" };    }
    return { authorized: true };  }
  async filterOutput(output: string): Promise<{ filtered: string; blocked: boolean }> {    // PII detection and redaction    const piiRedacted = this.redactPII(output);
    // Content policy check    const policyCheck = await this.checkContentPolicy(piiRedacted);    if (!policyCheck.compliant) {      return { filtered: "", blocked: true };    }
    return { filtered: piiRedacted, blocked: false };  }
  private redactPII(text: string): string {    // Email redaction    text = text.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, "[EMAIL_REDACTED]");
    // Phone number redaction (US format)    text = text.replace(/\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g, "[PHONE_REDACTED]");
    // Credit card redaction    text = text.replace(/\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, "[CARD_REDACTED]");
    return text;  }
  private async callModerationAPI(input: string): Promise<{ safe: boolean; reason?: string }> {    // Implementation with moderation service    return { safe: true };  }
  private async getAgentPermissions(agentId: string): Promise<any> {    // Fetch from permission store    return { tools: [], elevated: false };  }
  private isSensitiveTool(toolName: string): boolean {    const sensitivTools = ["delete-data", "modify-permissions", "send-money"];    return sensitivTools.includes(toolName);  }
  private async checkRateLimit(agentId: string, toolName: string): Promise<boolean> {    // Rate limiting logic    return true;  }
  private async checkContentPolicy(text: string): Promise<{ compliant: boolean }> {    // Policy checking    return { compliant: true };  }}

async function reactLoopWithDetection(task: string) {  const actionHistory = new Set<string>();
  for (let i = 0; i < maxIterations; i++) {    const step = await generateStep();
    // Create signature of this action    const actionSignature = `${step.action.tool}:${JSON.stringify(step.action.input)}`;
    if (actionHistory.has(actionSignature)) {      console.error("[Loop Detected] Breaking out of repeated action");      return { error: "Agent stuck in loop, terminating" };    }
    actionHistory.add(actionSignature);    await executeStep(step);  }}

class ManagedConversationHistory {  private messages: Message[] = [];  private maxMessages = 20;  private summaries: string[] = [];
  async add(message: Message) {    this.messages.push(message);
    if (this.messages.length > this.maxMessages) {      // Summarize oldest 10 messages      const toSummarize = this.messages.splice(0, 10);      const summary = await this.summarize(toSummarize);      this.summaries.push(summary);    }  }
  getContext(): string {    return [      ...this.summaries.map(s => `[Summary] ${s}`),      ...this.messages.map(m => `${m.role}: ${m.content}`)    ].join("\n");  }}

class ContextualToolLoader {  async getRelevantTools(task: string): Promise<Tool[]> {    // Use semantic search to find relevant tools    const taskEmbedding = await embed(task);
    const relevantTools = await this.vectorStore.search({      embedding: taskEmbedding,      limit: 8, // Max 8 tools at a time      threshold: 0.6    });
    return relevantTools.map(t => ({      name: t.name,      description: t.shortDescription, // Use concise version      parameters: t.parameters    }));  }}

class HybridChatbotAgent {  private intentClassifier: IntentClassifier;  private agentMode: boolean = false;
  async process(message: string): Promise<string> {    // Try intent-based handling first (fast, cheap)    const intent = await this.intentClassifier.classify(message);
    if (intent.confidence > 0.85 && !intent.requiresToolUse) {      // Use traditional chatbot flow      return await this.handleIntent(intent);    }
    // Fall back to agent mode for complex queries    console.error("[Hybrid] Switching to agent mode for complex query");    this.agentMode = true;    return await this.agentProcess(message);  }}