// Core agent loop implementation
interface AgentConfig {
  model: string;
  systemPrompt: string;
  tools: Tool[];
  maxIterations: number;
  temperature: number;
}
 
interface Tool {
  name: string;
  description: string;
  parameters: Record<string, unknown>;
  execute: (args: Record<string, unknown>) => Promise<string>;
}
 
interface AgentStep {
  thought: string;
  action?: { tool: string; input: Record<string, unknown> };
  observation?: string;
}
 
class AIAgent {
  private config: AgentConfig;
  private history: AgentStep[] = [];
  private llm: LLMClient;
 
  constructor(config: AgentConfig) {
    this.config = config;
    this.llm = new LLMClient({ model: config.model, temperature: config.temperature });
  }
 
  async run(goal: string): Promise<string> {
    const messages: Message[] = [
      { role: 'system', content: this.config.systemPrompt },
      { role: 'user', content: goal },
    ];
 
    for (let i = 0; i < this.config.maxIterations; i++) {
      // Step 1: Reason about what to do
      const response = await this.llm.chat(messages, this.getToolSchemas());
 
      if (response.toolCalls && response.toolCalls.length > 0) {
        // Step 2: Execute tool calls
        for (const toolCall of response.toolCalls) {
          const tool = this.config.tools.find(t => t.name === toolCall.name);
          if (!tool) {
            messages.push({ role: 'tool', content: `Error: Tool ${toolCall.name} not found`, toolCallId: toolCall.id });
            continue;
          }
 
          const result = await tool.execute(toolCall.arguments);
          this.history.push({
            thought: response.content,
            action: { tool: toolCall.name, input: toolCall.arguments },
            observation: result,
          });
 
          messages.push({ role: 'assistant', content: response.content, toolCalls: [toolCall] });
          messages.push({ role: 'tool', content: result, toolCallId: toolCall.id });
        }
      } else {
        // Step 3: No tool calls = final answer
        return response.content;
      }
    }
 
    return 'Maximum iterations reached. Could not complete the task.';
  }
 
  private getToolSchemas(): ToolSchema[] {
    return this.config.tools.map(tool => ({
      name: tool.name,
      description: tool.description,
      parameters: tool.parameters,
    }));
  }
}

// Defining tools for an AI agent
const searchTool: Tool = {
  name: 'web_search',
  description: 'Search the web for current information. Use this when you need up-to-date facts, news, or data that may not be in your training data.',
  parameters: {
    type: 'object',
    properties: {
      query: { type: 'string', description: 'The search query' },
      numResults: { type: 'number', description: 'Number of results to return (1-10)', default: 5 },
    },
    required: ['query'],
  },
  execute: async (args) => {
    const response = await fetch(`https://api.search.example.com/search`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${process.env.SEARCH_API_KEY}` },
      body: JSON.stringify({ query: args.query, limit: args.numResults || 5 }),
    });
    const results = await response.json();
    return JSON.stringify(results.items.map((r: any) => ({
      title: r.title,
      snippet: r.snippet,
      url: r.url,
    })));
  },
};
 
const calculatorTool: Tool = {
  name: 'calculator',
  description: 'Evaluate mathematical expressions. Supports arithmetic, algebra, and basic calculus operations.',
  parameters: {
    type: 'object',
    properties: {
      expression: { type: 'string', description: 'The mathematical expression to evaluate' },
    },
    required: ['expression'],
  },
  execute: async (args) => {
    try {
      const result = evaluateMathExpression(args.expression as string);
      return `Result: ${result}`;
    } catch (error) {
      return `Error evaluating expression: ${error.message}`;
    }
  },
};
 
const codeExecutionTool: Tool = {
  name: 'execute_code',
  description: 'Execute Python code in a sandboxed environment. Use for data analysis, calculations, and transformations that are complex to express as math.',
  parameters: {
    type: 'object',
    properties: {
      code: { type: 'string', description: 'The Python code to execute' },
    },
    required: ['code'],
  },
  execute: async (args) => {
    const result = await runInSandbox(args.code as string);
    return `Output:\n${result.stdout}\n${result.stderr ? `Errors:\n${result.stderr}` : ''}`;
  },
};

// ReAct pattern implementation
async function reactAgent(goal: string, tools: Tool[]): Promise<string> {
  const scratchpad: string[] = [];
  const maxSteps = 10;
 
  for (let step = 0; step < maxSteps; step++) {
    const prompt = `
Goal: ${goal}
 
Previous steps:
${scratchpad.join('\n')}
 
Available tools: ${tools.map(t => `${t.name}: ${t.description}`).join('\n')}
 
Think step by step about what to do next. Then either:
1. Use a tool by responding with: Thought: ... Action: tool_name(input)
2. Provide your final answer by responding with: Thought: ... Answer: ...
`;
 
    const response = await llm.complete(prompt);
    scratchpad.push(response);
 
    const answerMatch = response.match(/Answer:\s*(.*)/s);
    if (answerMatch) return answerMatch[1].trim();
 
    const actionMatch = response.match(/Action:\s*(\w+)\((.*?)\)/);
    if (actionMatch) {
      const toolName = actionMatch[1];
      const toolInput = actionMatch[2];
      const tool = tools.find(t => t.name === toolName);
 
      if (tool) {
        const result = await tool.execute({ input: toolInput });
        scratchpad.push(`Observation: ${result}`);
      } else {
        scratchpad.push(`Observation: Error - tool "${toolName}" not found`);
      }
    }
  }
 
  return 'Could not complete the task within the step limit.';
}

// Plan-and-Execute agent
interface Plan {
  goal: string;
  steps: PlanStep[];
  currentStep: number;
}
 
interface PlanStep {
  id: number;
  description: string;
  status: 'pending' | 'in-progress' | 'completed' | 'failed';
  result?: string;
}
 
class PlanAndExecuteAgent {
  private planner: LLMClient;
  private executor: LLMClient;
  private tools: Tool[];
 
  constructor(tools: Tool[]) {
    this.planner = new LLMClient({ model: 'gpt-4', temperature: 0.2 });
    this.executor = new LLMClient({ model: 'gpt-4', temperature: 0 });
    this.tools = tools;
  }
 
  async run(goal: string): Promise<string> {
    // Phase 1: Create a plan
    const plan = await this.createPlan(goal);
    console.log('Plan:', plan.steps.map(s => s.description));
 
    // Phase 2: Execute each step
    for (const step of plan.steps) {
      step.status = 'in-progress';
      try {
        const result = await this.executeStep(step, plan);
        step.result = result;
        step.status = 'completed';
 
        // Phase 3: Re-plan if needed
        const needsReplan = await this.shouldReplan(plan, step);
        if (needsReplan) {
          const newPlan = await this.replan(plan, step);
          plan.steps = newPlan.steps;
          plan.currentStep = 0;
        }
      } catch (error) {
        step.status = 'failed';
        step.result = `Failed: ${error.message}`;
        // Re-plan after failure
        const newPlan = await this.replan(plan, step);
        plan.steps = newPlan.steps;
        plan.currentStep = 0;
      }
    }
 
    // Phase 4: Synthesize final answer
    return this.synthesize(plan);
  }
 
  private async createPlan(goal: string): Promise<Plan> {
    const response = await this.planner.complete(`
      Create a step-by-step plan to achieve this goal: ${goal}
 
      Available tools: ${this.tools.map(t => `${t.name}: ${t.description}`).join('\n')}
 
      Respond with a JSON array of steps: [{"description": "..."}]
    `);
    const steps = JSON.parse(response).map((s: any, i: number) => ({
      id: i + 1,
      description: s.description,
      status: 'pending' as const,
    }));
    return { goal, steps, currentStep: 0 };
  }
 
  private async executeStep(step: PlanStep, plan: Plan): Promise<string> {
    const completedSteps = plan.steps
      .filter(s => s.status === 'completed')
      .map(s => `${s.description}: ${s.result}`)
      .join('\n');
 
    const result = await this.executor.complete(`
      Goal: ${plan.goal}
      Completed steps so far:
      ${completedSteps}
 
      Current step: ${step.description}
      Available tools: ${this.tools.map(t => `${t.name}: ${t.description}`).join('\n')}
 
      Execute this step. Use tools as needed. Provide the result.
    `);
    return result;
  }
}

// Reflection agent
async function reflectionAgent(task: string, maxReflections: number = 3): Promise<string> {
  let output = await generateInitialResponse(task);
 
  for (let i = 0; i < maxReflections; i++) {
    const critique = await llm.complete(`
      Task: ${task}
      Current output: ${output}
 
      Critically evaluate this output. Identify specific issues:
      - Factual errors
      - Missing information
      - Logical inconsistencies
      - Areas that could be improved
 
      Respond with a list of specific improvements needed.
    `);
 
    const needsImprovement = !critique.toLowerCase().includes('no improvements needed');
 
    if (!needsImprovement) break;
 
    output = await llm.complete(`
      Task: ${task}
      Current output: ${output}
      Feedback: ${critique}
 
      Improve the output based on the feedback. Address every issue raised.
    `);
  }
 
  return output;
}

# Full research agent implementation
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import Tool
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 
# Initialize tools
search = DuckDuckGoSearchRun()
wikipedia = WikipediaAPIWrapper()
 
tools = [
    Tool(name="search", func=search.run, description="Search the web for current information"),
    Tool(name="wikipedia", func=wikipedia.run, description="Search Wikipedia for encyclopedic information"),
]
 
# Create the agent
llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
 
prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a thorough research agent. Your goal is to gather comprehensive,
    accurate information on any topic. Follow these principles:
    1. Search multiple sources to verify facts
    2. Note conflicting information and explain the discrepancy
    3. Always cite your sources
    4. Distinguish between established facts and speculation
    5. Provide structured, well-organized findings"""),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])
 
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=15)
 
# Use the agent
result = executor.invoke({
    "input": "Research the current state of quantum computing in 2025. Include recent breakthroughs, key players, and remaining challenges."
})

import { ChatOpenAI } from '@langchain/openai';
import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
import { DynamicStructuredTool } from '@langchain/core/tools';
import { z } from 'zod';
 
// Define tools with Zod schemas for validation
const taskPlannerTool = new DynamicStructuredTool({
  name: 'create_task_plan',
  description: 'Create a detailed task plan with dependencies and time estimates',
  schema: z.object({
    tasks: z.array(z.object({
      name: z.string().describe('Task name'),
      description: z.string().describe('Detailed task description'),
      estimatedHours: z.number().describe('Estimated hours to complete'),
      dependencies: z.array(z.string()).describe('Names of tasks that must complete first'),
      assignee: z.string().optional().describe('Person assigned to the task'),
    })),
  }),
  async func({ tasks }) {
    // Store tasks in database or project management tool
    const plan = await saveTaskPlan(tasks);
    return JSON.stringify(plan, null, 2);
  },
});
 
const calendarTool = new DynamicStructuredTool({
  name: 'check_calendar',
  description: 'Check team member availability and calendar events',
  schema: z.object({
    teamMember: z.string(),
    startDate: z.string(),
    endDate: z.string(),
  }),
  async func({ teamMember, startDate, endDate }) {
    const availability = await getCalendarEvents(teamMember, startDate, endDate);
    return JSON.stringify(availability);
  },
});
 
// Create the agent
const llm = new ChatOpenAI({ model: 'gpt-4-turbo', temperature: 0.2 });
const tools = [taskPlannerTool, calendarTool];
 
const prompt = ChatPromptTemplate.fromMessages([
  ['system', `You are a project planning agent. When given a project description,
   break it into actionable tasks, check team availability, and create a realistic plan.
   Consider dependencies, skill requirements, and deadlines.`],
  new MessagesPlaceholder('chat_history'),
  ['human', '{input}'],
  new MessagesPlaceholder('agent_scratchpad'),
]);
 
const agent = await createOpenAIFunctionsAgent({ llm, tools, prompt });
const executor = new AgentExecutor({ agent, tools, verbose: true, maxIterations: 10 });
 
// Run the planning agent
const result = await executor.invoke({
  input: `Create a project plan for building a new e-commerce checkout flow.
          The team has 3 frontend developers, 2 backend developers, and 1 QA engineer.
          The deadline is 6 weeks from now.`,
});

// Long-term memory with vector store
class AgentMemory {
  private vectorStore: VectorStore;
 
  async remember(interaction: { input: string; output: string; feedback: string }) {
    const text = `Input: ${interaction.input}\nOutput: ${interaction.output}\nFeedback: ${interaction.feedback}`;
    const embedding = await this.embed(text);
    await this.vectorStore.upsert({ id: uuid(), vector: embedding, metadata: interaction });
  }
 
  async recall(query: string, topK: number = 5): Promise<MemoryEntry[]> {
    const embedding = await this.embed(query);
    return this.vectorStore.query({ vector: embedding, topK });
  }
 
  private async embed(text: string): Promise<number[]> {
    const response = await openai.embeddings.create({ model: 'text-embedding-3-small', input: text });
    return response.data[0].embedding;
  }
}