import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// --- Configuration ---
const llm = new ChatOpenAI({
  model: 'gpt-4o-mini',
  temperature: 0.7,
});

// --- Define Specialized Sub-Agents ---

// Researcher Agent - Focuses on gathering information
const createResearcherAgent = (topic) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Research Specialist. Your role is to gather comprehensive information about: {topic}
Provide detailed findings with sources.`,
    ],
    ['user', 'Please research this topic thoroughly.'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// Analyst Agent - Focuses on analyzing data
const createAnalystAgent = (researchData) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Data Analyst. Your role is to analyze the following research data and identify key insights, trends, and patterns.
Research Data:
{researchData}`,
    ],
    ['user', 'Provide a detailed analysis with key findings.'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// Writer Agent - Focuses on creating content
const createWriterAgent = (analysis) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Content Writer. Your role is to transform analytical insights into engaging, clear content.
Analysis:
{analysis}`,
    ],
    ['user', 'Create a well-structured article based on this analysis.'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// --- Coordinator Agent ---
const createCoordinatorAgent = (task) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Project Coordinator. Your role is to break down complex tasks and delegate to specialized agents.
Current Task: {task}

Determine which agents are needed and in what sequence.
Available agents: Researcher, Analyst, Writer`,
    ],
    ['user', 'Provide a coordination plan.'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// --- Hierarchical Execution Pipeline ---

async function runHierarchicalAgentSystem(task) {
  console.log(`\n--- Running Hierarchical Multi-Agent System ---`);
  console.log(`Task: ${task}\n`);

  try {
    // Step 1: Coordinator plans the approach
    const coordinationPlan = await createCoordinatorAgent(task)(task);
    console.log('--- Coordinator Plan ---');
    console.log(coordationPlan);
    console.log();

    // Step 2: Researcher gathers information
    console.log('--- Researcher Agent Working ---');
    const topic = task; // In production, coordinator would extract this
    const researchData = await createResearcherAgent(topic)(topic);
    console.log('Research complete.\n');

    // Step 3: Analyst processes the research
    console.log('--- Analyst Agent Working ---');
    const analysis = await createAnalystAgent(researchData)(researchData);
    console.log('Analysis complete.\n');

    // Step 4: Writer creates final content
    console.log('--- Writer Agent Working ---');
    const finalContent = await createWriterAgent(analysis)(analysis);
    console.log('Content creation complete.\n');

    return finalContent;
  } catch (error) {
    console.error(`Error in hierarchical system: ${error}`);
    throw error;
  }
}

// Run the system
runHierarchicalAgentSystem('The impact of artificial intelligence on healthcare').then((result) => {
  console.log('\n--- Final Output ---\n');
  console.log(result);
});

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { RunnableParallel } from '@langchain/core/runnables';

// --- Configuration ---
const llm = new ChatOpenAI({
  model: 'gpt-4o-mini',
  temperature: 0.7,
});

// --- Define Peer Agents ---

// Agent 1: Financial Expert
const financialAgent = async (query) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Financial Expert. Provide insights from a financial perspective.
Consider: ROI, costs, revenue, market trends, investment opportunities.`,
    ],
    ['user', '{query}'],
  ]);

  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ query });
};

// Agent 2: Technical Expert
const technicalAgent = async (query) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Technical Expert. Provide insights from a technical perspective.
Consider: Feasibility, architecture, technology stack, implementation challenges.`,
    ],
    ['user', '{query}'],
  ]);

  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ query });
};

// Agent 3: Legal Expert
const legalAgent = async (query) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Legal Expert. Provide insights from a legal perspective.
Consider: Compliance, regulations, risks, contracts, intellectual property.`,
    ],
    ['user', '{query}'],
  ]);

  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ query });
};

// --- Collaborative Execution (Parallel) ---

async function runCollaborativeAgents(query) {
  console.log(`\n--- Running Collaborative Multi-Agent System ---`);
  console.log(`Query: ${query}\n`);

  // Execute all agents in parallel (Fan-out)
  const parallelResults = await new RunnableParallel({
    financial: () => financialAgent(query),
    technical: () => technicalAgent(query),
    legal: () => legalAgent(query),
  }).invoke();

  console.log('--- All Expert Inputs Received ---');
  console.log('Financial:', parallelResults.financial.substring(0, 100) + '...');
  console.log('Technical:', parallelResults.technical.substring(0, 100) + '...');
  console.log('Legal:', parallelResults.legal.substring(0, 100) + '...');
  console.log();

  // Synthesize results (Fan-in)
  const synthesisPrompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Project Manager synthesizing expert opinions.
Combine the following expert perspectives into a comprehensive recommendation.

**Financial Perspective:**
{financial}

**Technical Perspective:**
{technical}

**Legal Perspective:**
{legal}

Provide a balanced recommendation considering all perspectives.`,
    ],
    ['user', 'Please synthesize these expert opinions.'],
  ]);

  const synthesisChain = synthesisPrompt.pipe(llm).pipe(new StringOutputParser());
  const finalRecommendation = await synthesisChain.invoke(parallelResults);

  return finalRecommendation;
}

// Run the collaborative system
runCollaborativeAgents('Should we build a mobile app or a web app for our startup?').then(
  (result) => {
    console.log('\n--- Final Recommendation ---\n');
    console.log(result);
  },
);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// --- Configuration ---
const llm = new ChatOpenAI({
  model: 'gpt-4o-mini',
  temperature: 0.7,
});

// --- Define Debate Agents ---

// Pro Agent - Argues in favor
const createProAgent = (topic, context = '') => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are arguing IN FAVOR of: {topic}
Provide strong arguments supporting this position.
Previous context: {context}

Be persuasive, cite benefits, and address potential counterarguments.`,
    ],
    ['user', 'Present your strongest arguments.'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// Con Agent - Argues against
const createConAgent = (topic, context = '') => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are arguing AGAINST: {topic}
Provide strong arguments opposing this position.
Previous context: {context}

Be persuasive, cite risks, and highlight potential problems.`,
    ],
    ['user', 'Present your strongest counterarguments.'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// Judge Agent - Evaluates and decides
const createJudgeAgent = (topic, proArgs, conArgs) => {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a Judge evaluating arguments about: {topic}

**Arguments IN FAVOR:**
{pro}

**Arguments AGAINST:**
{con}

Evaluate both sides objectively and provide a final recommendation.
Consider: Strength of arguments, risks, benefits, and overall viability.`,
    ],
    ['user', 'What is your final decision?'],
  ]);

  return prompt.pipe(llm).pipe(new StringOutputParser());
};

// --- Debate Execution ---

async function runDebate(topic, rounds = 2) {
  console.log(`\n--- Running Debate: ${topic} ---`);
  console.log(`Rounds: ${rounds}\n`);

  let context = '';

  for (let round = 1; round <= rounds; round++) {
    console.log(`--- Round ${round} ---`);

    // Pro presents arguments
    const proArgs = await createProAgent(topic, context)('');
    console.log('Pro Arguments:', proArgs.substring(0, 200) + '...');

    // Con presents counterarguments
    const conArgs = await createConAgent(topic, context)('');
    console.log('\nCon Arguments:', conArgs.substring(0, 200) + '...');

    // Update context for next round
    context += `\nRound ${round} - Pro: ${proArgs}\nRound ${round} - Con: ${conArgs}\n`;
    console.log();
  }

  // Judge makes final decision
  console.log('--- Judge Making Decision ---');
  const finalDecision = await createJudgeAgent(topic, proArgs, conArgs)('');

  return finalDecision;
}

// Run the debate
runDebate('Should companies adopt a 4-day work week?', 2).then((decision) => {
  console.log('\n--- Final Decision ---\n');
  console.log(decision);
});

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// --- Shared State ---
const sharedState = {
  context: {},
  results: {},
  messages: [],
};

// --- Define State-Managing Agents ---

// Manager Agent - Coordinates and maintains state
class ManagerAgent {
  constructor(name) {
    this.name = name;
    this.llm = new ChatOpenAI({ model: 'gpt-4o-mini', temperature: 0.7 });
  }

  async assignTask(agentName, task) {
    console.log(`\n[${this.name}] Assigning task to ${agentName}: ${task}`);
    sharedState.messages.push({
      from: this.name,
      to: agentName,
      task: task,
      timestamp: new Date().toISOString(),
    });
    return task;
  }

  async synthesizeResults() {
    const prompt = ChatPromptTemplate.fromMessages([
      [
        'system',
        `You are a Manager synthesizing results from your team.
Team Results:
{results}

Provide a comprehensive summary.`,
      ],
      ['user', 'Synthesize the team results.'],
    ]);

    const chain = prompt.pipe(this.llm).pipe(new StringOutputParser());
    return chain.invoke({ results: JSON.stringify(sharedState.results) });
  }
}

// Worker Agent - Executes specific tasks
class WorkerAgent {
  constructor(name, specialty) {
    this.name = name;
    this.specialty = specialty;
    this.llm = new ChatOpenAI({ model: 'gpt-4o-mini', temperature: 0.7 });
  }

  async execute(task) {
    console.log(`\n[${this.name}] Executing: ${task}`);

    const prompt = ChatPromptTemplate.fromMessages([
      [
        'system',
        `You are a ${this.specialty} specialist. Execute the given task efficiently.
Your specialty: ${this.specialty}`,
      ],
      ['user', '{task}'],
    ]);

    const chain = prompt.pipe(this.llm).pipe(new StringOutputParser());
    const result = await chain.invoke({ task });

    // Store result in shared state
    sharedState.results[this.name] = result;
    sharedState.messages.push({
      agent: this.name,
      result: result,
      timestamp: new Date().toISOString(),
    });

    console.log(`[${this.name}] Completed: ${result.substring(0, 100)}...`);
    return result;
  }
}

// --- Execution ---

async function runMultiAgentSystem() {
  console.log('=== Starting Multi-Agent System with Shared State ===\n');

  // Create agents
  const manager = new ManagerAgent('ProjectManager');
  const worker1 = new WorkerAgent('DataCollector', 'data collection');
  const worker2 = new WorkerAgent('DataAnalyzer', 'data analysis');
  const worker3 = new WorkerAgent('ReportWriter', 'technical writing');

  // Manager assigns tasks
  await manager.assignTask('DataCollector', 'Collect information about renewable energy trends');
  await manager.assignTask('DataAnalyzer', 'Analyze the collected data for key trends');
  await manager.assignTask('ReportWriter', 'Write a comprehensive report on renewable energy');

  // Workers execute in parallel (simulated)
  const [dataResult, analysisResult, reportResult] = await Promise.all([
    worker1.execute('Research latest renewable energy technologies and market trends'),
    worker2.execute('Analyze the trends and identify opportunities'),
    worker3.execute('Create a professional report on renewable energy'),
  ]);

  // Manager synthesizes results
  console.log('\n--- Manager Synthesizing Results ---');
  const finalReport = await manager.synthesizeResults();

  console.log('\n=== Final Report ===');
  console.log(finalReport);

  console.log('\n=== Shared State Summary ===');
  console.log('Total messages:', sharedState.messages.length);
  console.log('Agents with results:', Object.keys(sharedState.results).join(', '));
}

// Run the system
runMultiAgentSystem();

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

// --- Configuration ---
const researchLLM = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.7 });
const synthesisLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });

// --- 1. Data Fetching / Research Agent ---
class ResearchAgent {
  async analyze(query) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Data Research Agent. Gather comprehensive financial data for: {query}

Provide: stock prices, financial, and metrics, earnings data key fundamentals.`],
      ["user", "Research:"],
    ]);
    const chain = prompt.pipe(researchLLM).pipe(new StringOutputParser());
    return chain.invoke({ query });
  }
}

// --- 2. Sentiment Analysis Agent ---
class SentimentAgent {
  async analyze(query) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Sentiment Analysis Agent. Analyze market sentiment for: {query}

Include: news sentiment, social media trends, analyst ratings, investor behavior.`],
      ["user", "Analyze sentiment:"],
    ]);
    const chain = prompt.pipe(researchLLM).pipe(new StringOutputParser());
    return chain.invoke({ query });
  }
}

// --- 3. Technical Analysis Agent ---
class TechnicalAgent {
  async analyze(query) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Technical Analysis Agent. Provide technical insights for: {query}

Include: price trends, support/resistance levels, RSI, MACD, volume analysis.`],
      ["user", "Technical analysis:"],
    ]);
    const chain = prompt.pipe(researchLLM).pipe(new StringOutputParser());
    return chain.invoke({ query });
  }
}

// --- 4. Strategy / Synthesis Agent ---
class StrategyAgent {
  async synthesize(data, sentiment, technical) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Strategy Agent (Portfolio Manager). Synthesize all inputs into an investment recommendation.

**Fundamental Data:**
{data}

**Sentiment Analysis:**
{sentiment}

**Technical Analysis:**
{technical}

Provide:
1. Investment Rating (BUY/SELL/HOLD)
2. Target Price
3. Key Reasons
4. Risk Factors`],
      ["user", "Generate strategy:"],
    ]);
    const chain = prompt.pipe(synthesisLLM).pipe(new StringOutputParser());
    return chain.invoke({ data, sentiment, technical });
  }
}

// --- 5. Risk & Compliance Reviewer Agent ---
class RiskReviewAgent {
  async review(strategy) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Risk & Compliance Reviewer Agent. Critically evaluate this investment strategy.

**Proposed Strategy:**
{strategy}

Evaluate:
1. Risk level (1-10)
2. Compliance with investment policy
3. Potential red flags
4. Is this approved or rejected?`],
      ["user", "Review risk:"],
    ]);
    const chain = prompt.pipe(synthesisLLM).pipe(new StringOutputParser());
    return chain.invoke({ strategy });
  }
}

// --- Expert Teams Execution ---
async function runExpertTeams(symbol) {
  console.log(`\n=== Running Expert Teams for ${symbol} ===`);

  // Create expert agents
  const researchAgent = new ResearchAgent();
  const sentimentAgent = new SentimentAgent();
  const technicalAgent = new TechnicalAgent();
  const strategyAgent = new StrategyAgent();
  const riskAgent = new RiskReviewAgent();

  // Execute research
  console.log("\n[Research Agent] Gathering data...");
  const data = await researchAgent.analyze(symbol);

  console.log("\n[Sentiment Agent] Analyzing sentiment...");
  const sentiment = await sentimentAgent.analyze(symbol);

  console.log("\n[Technical Agent] Technical analysis...");
  const technical = await technicalAgent.analyze(symbol);

  // Strategy synthesis
  console.log("\n[Strategy Agent] Synthesizing recommendation...");
  const strategy = await strategyAgent.synthesize(data, sentiment, technical);
  console.log("Strategy:", strategy.substring(0, 200), "...");

  // Risk review
  console.log("\n[Risk Review Agent] Evaluating...");
  const riskReview = await riskAgent.review(strategy);
  console.log("Risk Review:", riskReview);

  return { data, sentiment, technical, strategy, riskReview };
}

runExpertTeams("TSLA");

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.7 });

// --- Supervisor Agent ---
class SupervisorAgent {
  async delegate(task) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Supervisor Agent. Your job is to delegate user tasks to the right specialist agents.

User Task: {task}

Available Specialists:
- ResearchAgent: For data gathering and research
- SentimentAgent: For market sentiment analysis
- TechnicalAgent: For technical analysis
- StrategyAgent: For investment strategy synthesis

Determine which agents are needed and in what order. Return a delegation plan.`],
      ["user", "Delegate:"],
    ]);
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    return chain.invoke({ task });
  }
}

// --- Specialist Agents ---
const agents = {
  research: async (query) => "Research: Gathered fundamentals, earnings, financial metrics...",
  sentiment: async (query) => "Sentiment: Market is bullish, positive news flow...",
  technical: async (query) => "Technical: Stock in uptrend, RSI at 65...",
  strategy: async (data) => "Strategy: BUY rating, target price $300...",
};

// --- Hierarchical Execution ---
async function runSupervisorSystem(userQuery) {
  console.log(`\n=== Supervisor System ===`);
  console.log("User Query:", userQuery);

  // Supervisor delegates
  console.log("\n[Supervisor] Delegating tasks...");
  const supervisor = new SupervisorAgent();
  const delegation = await supervisor.delegate(userQuery);
  console.log("Delegation Plan:", delegation);

  // Execute based on delegation
  console.log("\n[Execution] Running specialist agents...");

  // Parallel execution of independent tasks
  const [research, sentiment, technical] = await Promise.all([
    agents.research(userQuery),
    agents.sentiment(userQuery),
    agents.technical(userQuery),
  ]);

  // Strategy synthesis
  const strategy = await agents.strategy({ research, sentiment, technical });

  console.log("\n=== Final Result ===");
  console.log(strategy);

  return strategy;
}

runSupervisorSystem("Analyze TSLA for potential investment");

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { RunnableParallel } from "@langchain/core/runnables";

const llm = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.7 });

// --- Specialized Analysis Agents ---

// Parallel agents for information gathering
const fundamentalAnalysis = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Analyze fundamentals for {symbol}. Include: P/E, revenue, margins.`],
    ["user", "Fundamental analysis:"],
  ]);
  return prompt.pipe(llm).pipe(new StringOutputParser()).invoke({ symbol });
};

const sentimentAnalysis = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Analyze sentiment for {symbol}. Include: news, social, analyst views.`],
    ["user", "Sentiment analysis:"],
  ]);
  return prompt.pipe(llm).pipe(new StringOutputParser()).invoke({ symbol });
};

const technicalAnalysis = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Technical analysis for {symbol}. Include: trends, indicators, levels.`],
    ["user", "Technical analysis:"],
  ]);
  return prompt.pipe(llm).pipe(new StringOutputParser()).invoke({ symbol });
};

// --- Parallel Execution (Fan-out) ---
async function parallelAnalysis(symbol) {
  console.log(`\n=== Parallel Processing for ${symbol} ===`);

  // All three agents work in parallel
  const parallelResults = await new RunnableParallel({
    fundamentals: () => fundamentalAnalysis(symbol),
    sentiment: () => sentimentAnalysis(symbol),
    technical: () => technicalAnalysis(symbol),
  }).invoke();

  console.log("\n[Parallel Agents] All analyses complete!");
  console.log("- Fundamentals:", parallelResults.fundamentals.substring(0, 100));
  console.log("- Sentiment:", parallelResults.sentiment.substring(0, 100));
  console.log("- Technical:", parallelResults.technical.substring(0, 100));

  return parallelResults;
}

// --- Fan-in: Synthesis ---
async function synthesizeResults(results) {
  const synthesisPrompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an Investment Strategist. Combine all analyses into a recommendation.

**Fundamentals:** {fundamentals}
**Sentiment:** {sentiment}
**Technical:** {technical}

Provide final investment recommendation.`],
    ["user", "Synthesize:"],
  ]);

  const chain = synthesisPrompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke(results);
}

// --- Full Pipeline ---
async function runParallelCollaboration(symbol) {
  // Fan-out: Parallel processing
  const results = await parallelAnalysis(symbol);

  // Fan-in: Synthesis
  console.log("\n[Synthesis] Combining results...");
  const recommendation = await synthesizeResults(results);

  console.log("\n=== Final Recommendation ===");
  console.log(recommendation);
}

runParallelCollaboration("AAPL");

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ model: "gpt-4o", temperature: 0.7 });

// --- Debate Agents with Different Perspectives ---

// Bullish Fundamental Analyst
const bullishAgent = async (symbol, context = "") => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Bullish Fundamental Analyst.
Argue IN FAVOR of buying {symbol}.

Consider: Strong fundamentals, growth potential, competitive advantages.
Previous arguments: {context}

Provide compelling bullish arguments.`],
    ["user", "Bullish case:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ symbol, context });
};

// Bearish Technical Analyst
const bearishAgent = async (symbol, context = "") => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Bearish Technical Analyst.
Argue AGAINST buying {symbol}.

Consider: Overbought indicators, negative technical signals, resistance levels.
Previous arguments: {context}

Provide compelling bearish arguments.`],
    ["user", "Bearish case:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ symbol, context });
};

// Neutral Judge / Consensus Builder
const judgeAgent = async (symbol, bullishArgs, bearishArgs) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Judge Agent. Evaluate arguments and reach consensus for {symbol}.

**Bullish Arguments:**
{bullish}

**Bearish Arguments:**
{bearish}

Weigh both sides and provide:
1. Final consensus recommendation
2. Confidence level
3. Key reasoning`],
    ["user", "Reach consensus:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ symbol, bullish: bullishArgs, bearish: bearishArgs });
};

// --- Debate Execution ---
async function runDebateConsensus(symbol, rounds = 2) {
  console.log(`\n=== Debate & Consensus for ${symbol} ===`);

  let context = "";

  for (let round = 1; round <= rounds; round++) {
    console.log(`\n--- Round ${round} ---`);

    // Both sides present arguments in parallel
    const [bullishArgs, bearishArgs] = await Promise.all([
      bullishAgent(symbol, context),
      bearishAgent(symbol, context),
    ]);

    console.log("\n[Bullish]:", bullishArgs.substring(0, 150));
    console.log("\n[Bearish]:", bearishArgs.substring(0, 150));

    // Update context
    context += `\nRound ${round} - Bullish: ${bullishArgs}\nBearish: ${bearishArgs}\n`;
  }

  // Final consensus
  console.log("\n=== Reaching Consensus ===");
  const finalArgs = await Promise.all([
    bullishAgent(symbol, context),
    bearishAgent(symbol, context),
  ]);

  const consensus = await judgeAgent(symbol, finalArgs[0], finalArgs[1]);

  console.log("\n=== Final Consensus ===");
  console.log(consensus);

  return consensus;
}

runDebateConsensus("TSLA", 2);

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.7 });

// --- Sequential Pipeline Agents ---

// Step 1: Data Collection Agent
class DataCollectionAgent {
  async execute(symbol) {
    console.log("\n[Step 1] Data Collection Agent: Gathering data...");
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `Gather financial data for {symbol}: stock price, P/E, revenue, earnings.`],
      ["user", "Collect data:"],
    ]);
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    const result = await chain.invoke({ symbol });
    console.log("[Step 1] Complete");
    return { data: result, symbol };
  }
}

// Step 2: Analysis Agent
class AnalysisAgent {
  async execute(input) {
    console.log("\n[Step 2] Analysis Agent: Analyzing data...");
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `Analyze this financial data for {symbol}:

{data}

Provide: key findings, ratios, and initial assessment.`],
      ["user", "Analyze:"],
    ]);
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    const result = await chain.invoke({ symbol: input.symbol, data: input.data });
    console.log("[Step 2] Complete");
    return { ...input, analysis: result };
  }
}

// Step 3: Strategy Agent
class StrategyAgent {
  async execute(input) {
    console.log("\n[Step 3] Strategy Agent: Developing strategy...");
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `Based on analysis for {symbol}:

**Data:** {data}
**Analysis:** {analysis}

Create investment strategy with: rating, target price, rationale.`],
      ["user", "Create strategy:"],
    ]);
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    const result = await chain.invoke({
      symbol: input.symbol,
      data: input.data,
      analysis: input.analysis,
    });
    console.log("[Step 3] Complete");
    return { ...input, strategy: result };
  }
}

// Step 4: Risk Review Agent
class RiskReviewAgent {
  async execute(input) {
    console.log("\n[Step 4] Risk Review Agent: Checking compliance...");
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `Review this investment strategy for {symbol}:

**Strategy:** {strategy}

Evaluate: risk level, compliance, approval/rejection.`],
      ["user", "Review risk:"],
    ]);
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    const result = await chain.invoke({ symbol: input.symbol, strategy: input.strategy });
    console.log("[Step 4] Complete");
    return { ...input, riskReview: result };
  }
}

// Step 5: Execution Agent
class ExecutionAgent {
  async execute(input) {
    console.log("\n[Step 5] Execution Agent: Finalizing...");
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `Prepare final investment memo for {symbol}:

**Data:** {data}
**Analysis:** {analysis}
**Strategy:** {strategy}
**Risk Review:** {riskReview}

Create final execution memo with all details.`],
      ["user", "Execute:"],
    ]);
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    const result = await chain.invoke({
      symbol: input.symbol,
      data: input.data,
      analysis: input.analysis,
      strategy: input.strategy,
      riskReview: input.riskReview,
    });
    console.log("[Step 5] Complete");
    return { ...input, execution: result };
  }
}

// --- Sequential Handoff Execution ---
async function runSequentialHandoffs(symbol) {
  console.log(`\n========================================`);
  console.log(`Starting Sequential Pipeline for ${symbol}`);
  console.log(`========================================`);

  // Create pipeline agents
  const dataAgent = new DataCollectionAgent();
  const analysisAgent = new AnalysisAgent();
  const strategyAgent = new StrategyAgent();
  const riskAgent = new RiskReviewAgent();
  const executionAgent = new ExecutionAgent();

  // Sequential execution with handoffs
  let result = await dataAgent.execute(symbol);
  result = await analysisAgent.execute(result);
  result = await strategyAgent.execute(result);
  result = await riskAgent.execute(result);
  result = await executionAgent.execute(result);

  console.log("\n========================================");
  console.log("Pipeline Complete!");
  console.log("========================================");
  console.log("\nFinal Execution Memo:");
  console.log(result.execution);

  return result;
}

runSequentialHandoffs("NVDA");