// examples/01-single-agent.ts
import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createReactAgent } from "langchain/agents";

const llm = new ChatOpenAI({ temperature: 0 });
const agent = await createReactAgent({
  llm,
  tools: [],
  prompt: "You are a helpful assistant.",
});

const agentExecutor = new AgentExecutor({
  agent,
  tools: [],
});

const result = await agentExecutor.invoke({
  input: "What is the capital of France?",
});

// examples/02-agent-with-tools.ts
import { SerperAPI } from "@langchain/community/tools";

const searchTool = new SerperAPI();
const calculator = new CalculatorTool();

const agent = await createReactAgent({
  llm,
  tools: [searchTool, calculator],
  prompt: "You are a research assistant.",
});

// examples/03-sequential-agents.ts
import { AgentChain } from "../lib/agent-chain";

const researcher = createAgent({
  role: "Researcher",
  goal: "Find information on {topic}",
  tools: [searchTool],
});

const writer = createAgent({
  role: "Writer",
  goal: "Write a blog post about {topic}",
  tools: [],
});

const chain = new AgentChain([researcher, writer]);
const result = await chain.run({ topic: "AI agents" });

// examples/04-parallel-agents.ts
import { ParallelExecutor } from "../lib/parallel-executor";

const agents = [
  createTranslatorAgent({ language: "Spanish" }),
  createTranslatorAgent({ language: "French" }),
  createTranslatorAgent({ language: "German" }),
];

const executor = new ParallelExecutor();
const translations = await executor.executeAll(agents, {
  text: "Hello, world!",
});

// examples/05-hierarchical-agents.ts
import { ManagerAgent } from "../lib/manager-agent";

const manager = new ManagerAgent({
  name: "Project Manager",
  subAgents: [
    { name: "Researcher", agent: researchAgent },
    { name: "Writer", agent: writerAgent },
    { name: "Editor", agent: editorAgent },
  ],
  coordination: "sequential", // or "parallel"
});

const report = await manager.coordinate({
  task: "Create a market research report",
  topic: "Electric Vehicles",
});

// examples/06-agent-with-memory.ts
import { BufferMemory } from "langchain/memory";

const memory = new BufferMemory({
  memoryKey: "chat_history",
  returnMessages: true,
});

const agent = await createReactAgent({
  llm,
  tools: [searchTool],
  prompt: "You are a helpful assistant with memory.",
  memory,
});

// First interaction
await agentExecutor.invoke({
  input: "My name is Alice",
});

// Agent remembers!
await agentExecutor.invoke({
  input: "What is my name?",
});

// examples/07-self-correcting-agent.ts
import { ReviewAgent } from "../lib/review-agent";

const writer = createWriterAgent();
const reviewer = new ReviewAgent({
  criteria: ["accuracy", "clarity", "style"],
  maxIterations: 3,
});

const content = await reviewer.improveWithFeedback({
  contentGenerator: writer,
  topic: "Quantum Computing",
});

// examples/08-agent-debate.ts
import { AgentDebate } from "../lib/agent-debate";

const debate = new AgentDebate({
  protagonist: createAgent({ stance: "pro-ai" }),
  antagonist: createAgent({ stance: "skeptic" }),
  moderator: createAgent({ stance: "neutral" }),
  rounds: 3,
});

const summary = await debate.conduct({
  topic: "Will AI replace human workers?",
});

// real-world/content-pipeline.ts
const pipeline = new AgentPipeline([
  {
    agent: seoResearcher,
    outputKey: "keywords",
  },
  {
    agent: contentWriter,
    inputKeys: ["keywords"],
    outputKey: "draft",
  },
  {
    agent: humanEditor,
    inputKeys: ["draft"],
    outputKey: "edited",
  },
  {
    agent: publisher,
    inputKeys: ["edited"],
    outputKey: "published",
  },
]);

const result = await pipeline.execute({
  topic: "Best practices for API design",
});

// real-world/customer-support.ts
const triageAgent = new TriageAgent({
  categories: ["billing", "technical", "feature-request"],
});

const routingMap = {
  billing: billingAgent,
  technical: technicalSupportAgent,
  "feature-request": productTeamAgent,
};

const supportSystem = new SupportSystem({
  triageAgent,
  routingMap,
  escalation: humanAgent,
});

const response = await supportSystem.handleTicket({
  customerQuery: "I was charged twice!",
  customerHistory: customerData,
});

// real-world/research-assistant.ts
const researchTeam = new ResearchTeam({
  leader: leadResearcher,
  members: [
    dataCollector,
    dataAnalyzer,
    reportWriter,
  ],
});

const research = await researchTeam.conductResearch({
  question: "What is the impact of remote work on productivity?",
  sources: ["arxiv", "google-scholar", "news"],
  depth: "comprehensive",
});

import { AgentChain, ParallelExecutor, ManagerAgent } from './lib';

const customSystem = new ManagerAgent({
  subAgents: [
    new AgentChain([agent1, agent2]),
    new ParallelExecutor([agent3, agent4]),
  ],
});