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

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

// --- Define Independent Chains ---
// These three chains represent distinct tasks that can be executed in parallel.

// Chain 1: Summarize the topic
const summarizeChain = ChatPromptTemplate.fromMessages([
  ["system", "Summarize the following topic concisely:"],
  ["user", "{topic}"],
]).pipe(llm).pipe(new StringOutputParser());

// Chain 2: Generate questions about the topic
const questionsChain = ChatPromptTemplate.fromMessages([
  ["system", "Generate three interesting questions about the following topic:"],
  ["user", "{topic}"],
]).pipe(llm).pipe(new StringOutputParser());

// Chain 3: Extract key terms from the topic
const termsChain = ChatPromptTemplate.fromMessages([
  ["system", "Identify 5-10 key terms from the following topic, separated by commas:"],
  ["user", "{topic}"],
]).pipe(llm).pipe(new StringOutputParser());

// --- Build the Parallel + Synthesis Chain ---

// 1. Define the block of tasks to run in parallel
const mapChain = new RunnableParallel({
  summary: summarizeChain,
  questions: questionsChain,
  keyTerms: termsChain,
  topic: new RunnablePassthrough(), // Pass the original topic through
});

// 2. Define the final synthesis prompt
const synthesisPrompt = ChatPromptTemplate.fromMessages([
  ["system", `Based on the following information:
Summary: {summary}
Related Questions: {questions}
Key Terms: {keyTerms}
Synthesize a comprehensive answer.`],
  ["user", "Original topic: {topic}"],
]);

// 3. Construct the full chain
const fullParallelChain = mapChain.pipe(synthesisPrompt).pipe(llm).pipe(new StringOutputParser());

// --- Run the Chain ---
async function runParallelExample(topic) {
  console.log(`\n--- Running Parallel LangChain Example for Topic: '${topic}' ---`);

  try {
    // Invoke the chain with the topic
    const response = await fullParallelChain.invoke(topic);

    console.log("\n--- Final Response ---");
    console.log(response);
  } catch (error) {
    console.error(`\nAn error occurred during chain execution: ${error}`);
  }
}

// Run the example
const testTopic = "The history of space exploration";
runParallelExample(testTopic);

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 Researcher Sub-Agents (to run in parallel) ---

// Researcher 1: Renewable Energy
const researcherAgent1 = async (topic) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an AI Research Assistant specializing in energy.
Research the latest advancements in '{topic}'.
Summarize your key findings concisely (1-2 sentences). Output *only* the summary.`],
    ["user", "Topic: {topic}"],
  ]);

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

// Researcher 2: Electric Vehicles
const researcherAgent2 = async (topic) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an AI Research Assistant specializing in transportation.
Research the latest developments in '{topic}'.
Summarize your key findings concisely (1-2 sentences). Output *only* the summary.`],
    ["user", "Topic: {topic}"],
  ]);

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

// Researcher 3: Carbon Capture
const researcherAgent3 = async (topic) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an AI Research Assistant specializing in climate solutions.
Research the current state of '{topic}'.
Summarize your key findings concisely (1-2 sentences). Output *only* the summary.`],
    ["user", "Topic: {topic}"],
  ]);

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

// --- Parallel Execution (Fan-out) ---
async function runParallelResearch(topic) {
  console.log(`\n--- Running Parallel Research for Topic: '${topic}' ---`);

  // Execute all researchers in parallel
  const parallelResults = await new RunnableParallel({
    renewableEnergy: () => researcherAgent1(topic),
    evTechnology: () => researcherAgent2(topic),
    carbonCapture: () => researcherAgent3(topic),
  }).invoke();

  return parallelResults;
}

// --- Merger Agent (Fan-in / Synthesis) ---
async function runMergerAgent(results) {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an AI Assistant responsible for combining research findings into a structured report.
Your primary task is to synthesize the following research summaries, clearly attributing findings to their source areas.

**Crucially: Your entire response MUST be grounded *exclusively* on the information provided below.**
Do NOT add any external knowledge or details not present in these specific summaries.

**Input Summaries:**
* **Renewable Energy:** {renewableEnergy}
* **Electric Vehicles:** {evTechnology}
* **Carbon Capture:** {carbonCapture}

Output a structured report with headings for each topic.`],
    ["user", "Please synthesize these findings."],
  ]);

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

// --- Main Pipeline (Sequential) ---
async function runResearchPipeline(topic) {
  try {
    // Step 1: Run parallel research
    const parallelResults = await runParallelResearch(topic);

    // Step 2: Run merger agent to synthesize results
    const finalReport = await runMergerAgent(parallelResults);

    console.log("\n--- Final Synthesis Report ---");
    console.log(finalReport);
  } catch (error) {
    console.error(`\nAn error occurred during pipeline execution: ${error}`);
  }
}

// Run the pipeline
const testTopic = "sustainable technology advancements";
runResearchPipeline(testTopic);

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 });
const strongLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });

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

// 1. Fundamental Analysis Agent
const fundamentalAnalysisAgent = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Fundamental Analysis Expert.
Research the fundamental data for {symbol}.
Include: P/E ratio, revenue growth, profit margins, debt levels, and key financial metrics.
Provide a concise analysis (2-3 sentences).`],
    ["user", "Analyze {symbol} fundamentals:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ symbol });
};

// 2. Sentiment Analysis Agent
const sentimentAnalysisAgent = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Market Sentiment Analyst.
Analyze the market sentiment for {symbol} based on recent news and social media.
Include: recent news themes, social media trends, analyst ratings, and investor sentiment.
Provide a concise analysis (2-3 sentences).`],
    ["user", "Analyze {symbol} sentiment:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ symbol });
};

// 3. Technical Analysis Agent
const technicalAnalysisAgent = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Technical Analysis Expert.
Analyze the technical indicators for {symbol}.
Include: key support/resistance levels, moving averages, RSI, MACD, and volume trends.
Provide a concise analysis (2-3 sentences).`],
    ["user", "Analyze {symbol} technically:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ symbol });
};

// --- Parallel Information Gathering (Fan-out) ---
async function gatherInvestmentInfo(symbol) {
  console.log(`\n--- Gathering Investment Info for ${symbol} in Parallel ---`);

  // Execute all three analyses in parallel
  const parallelResults = await new RunnableParallel({
    fundamental: () => fundamentalAnalysisAgent(symbol),
    sentiment: () => sentimentAnalysisAgent(symbol),
    technical: () => technicalAnalysisAgent(symbol),
  }).invoke();

  return parallelResults;
}

// --- Synthesis Agent (Fan-in) ---
async function synthesizeInvestmentReport(symbol, results) {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Senior Investment Analyst. Create a comprehensive investment report for {symbol}.

**Fundamental Analysis:**
{fundamental}

**Sentiment Analysis:**
{sentiment}

**Technical Analysis:**
{technical}

Synthesize these three perspectives into a coherent investment recommendation.
Highlight any contradictions between the analyses (e.g., strong fundamentals but negative sentiment).
Provide a final rating: BUY / HOLD / SELL with rationale.`],
    ["user", "Create investment report:"],
  ]);

  const chain = prompt.pipe(strongLLM).pipe(new StringOutputParser());
  return chain.invoke({
    symbol,
    fundamental: results.fundamental,
    sentiment: results.sentiment,
    technical: results.technical,
  });
}

// --- Complete Investment Analysis Pipeline ---
async function analyzeStock(symbol) {
  try {
    // Step 1: Gather information from all sources in parallel
    const infoResults = await gatherInvestmentInfo(symbol);

    // Step 2: Synthesize into a final investment report
    const finalReport = await synthesizeInvestmentReport(symbol, infoResults);

    console.log("\n--- Final Investment Report ---");
    console.log(finalReport);
  } catch (error) {
    console.error(`Error analyzing ${symbol}:`, error);
  }
}

// Run the investment analysis
analyzeStock("TSLA");

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 });
const strongLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });

// --- Sub-Query Agents for Asset Comparison ---

// Agent A: Research Microsoft's AI strategy and financials
const researchMicrosoft = async (query) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Research Microsoft (MSFT) based on the following query:
{query}

Provide key findings about their AI investments, financial health, and competitive positioning.`],
    ["user", "Research query:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ query });
};

// Agent B: Research Apple's AI strategy and financials
const researchApple = async (query) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Research Apple (AAPL) based on the following query:
{query}

Provide key findings about their AI investments, financial health, and competitive positioning.`],
    ["user", "Research query:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ query });
};

// --- Parallel Asset Research (Fan-out) ---
async function compareAssets(assetA, assetB, comparisonCriteria) {
  console.log(`\n--- Comparing ${assetA} vs ${assetB} in Parallel ---`);

  // Parallel research on both assets
  const results = await new RunnableParallel({
    assetA: () => researchMicrosoft(comparisonCriteria),
    assetB: () => researchApple(comparisonCriteria),
  }).invoke();

  return {
    assetA: { name: assetA, research: results.assetA },
    assetB: { name: assetB, research: results.assetB },
  };
}

// --- Comparison Synthesis Agent ---
async function synthesizeComparison(results) {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an Investment Comparison Analyst. Compare the following two assets:

**{assetA}:**
{researchA}

**{assetB}:**
{researchB}

Provide a detailed comparison covering:
1. AI Strategy and Investments
2. Financial Health
3. Competitive Positioning
4. Investment Recommendation with rationale`],
    ["user", "Create comparison report:"],
  ]);

  const chain = prompt.pipe(strongLLM).pipe(new StringOutputParser());
  return chain.invoke({
    assetA: results.assetA.name,
    researchA: results.assetA.research,
    assetB: results.assetB.name,
    researchB: results.assetB.research,
  });
}

// --- Complete Comparison Pipeline ---
async function runAssetComparison() {
  const comparisonQuery = "AI investment布局、研发支出、财务健康度、竞争优势分析";

  try {
    // Step 1: Parallel research on both assets
    const researchResults = await compareAssets("Microsoft (MSFT)", "Apple (AAPL)", comparisonQuery);

    // Step 2: Synthesize comparison
    const finalComparison = await synthesizeComparison(researchResults);

    console.log("\n--- Final Comparison Report ---");
    console.log(finalComparison);
  } catch (error) {
    console.error("Error during comparison:", error);
  }
}

runAssetComparison();

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 });

// Sample research report text
const sampleReport = `
Apple Inc. (AAPL) reported Q4 2024 earnings with revenue of $94.9 billion,
up 8% year-over-year. Services revenue reached $23.1 billion, a new record.
The company announced plans to invest $500 billion in US infrastructure over 4 years.
iPhone sales grew 6% despite global smartphone market slowdown.
However, regulatory challenges in EU and China remain concerns.
Management expressed optimism about AI features coming to iPhone.
Operating margin improved to 28.5%, driven by services mix.
`;

// --- Define Parallel Processing Chains ---

// Chain 1: Extract Financial Metrics
const extractFinancials = async (report) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Extract key financial metrics from this earnings report:
{report}

Return: Revenue, Growth rate, Profit margin, Operating margin, Key highlights.`],
    ["user", "Extract financials:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ report });
};

// Chain 2: Identify Risk Factors
const identifyRisks = async (report) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Identify potential risk factors from this earnings report:
{report}

Return: Regulatory risks, Market risks, Operational risks, Competitive risks.`],
    ["user", "Identify risks:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ report });
};

// Chain 3: Sentiment Analysis on Management Tone
const analyzeTone = async (report) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `Analyze the tone and sentiment of management's comments in this report:
{report}

Return: Overall sentiment (Bullish/Neutral/Bearish), Key confidence indicators, Concerns mentioned.`],
    ["user", "Analyze tone:"],
  ]);
  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({ report });
};

// --- Parallel Processing (Fan-out) ---
async function processReportInParallel(report) {
  console.log("\n--- Processing Report with Multiple Analysis Chains ---");

  // Execute all three analysis chains in parallel on the same document
  const results = await new RunnableParallel({
    financials: () => extractFinancials(report),
    risks: () => identifyRisks(report),
    sentiment: () => analyzeTone(report),
  }).invoke();

  return results;
}

// --- Complete Processing Pipeline ---
async function analyzeEarningsReport() {
  try {
    // Process the report in parallel
    const analysisResults = await processReportInParallel(sampleReport);

    console.log("\n=== Analysis Results ===");
    console.log("\n--- Financials ---");
    console.log(analysisResults.financials);
    console.log("\n--- Risk Factors ---");
    console.log(analysisResults.risks);
    console.log("\n--- Sentiment Analysis ---");
    console.log(analysisResults.sentiment);
  } catch (error) {
    console.error("Error processing report:", error);
  }
}

analyzeEarningsReport();

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 researchLLM = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.7 });
const synthesisLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });

// --- Complete Investment Agent Class ---
class InvestmentAgent {
  constructor(symbol) {
    this.symbol = symbol;
    this.sessionState = {};
  }

  // Phase 1: Parallel Information Gathering (Fan-out)
  async gatherInformation() {
    console.log(`\n[Phase 1] Gathering information for ${this.symbol}...`);

    const gatherChain = new RunnableParallel({
      // Parallel data collection from multiple sources
      fundamentals: async () => {
        const prompt = ChatPromptTemplate.fromMessages([
          ["system", `Analyze fundamentals for {symbol}. Include: P/E, revenue, growth, margins.`],
          ["user", "Fundamental analysis:"],
        ]);
        return prompt.pipe(researchLLM).pipe(new StringOutputParser()).invoke({ symbol: this.symbol });
      },
      sentiment: async () => {
        const prompt = ChatPromptTemplate.fromMessages([
          ["system", `Analyze market sentiment for {symbol}. Include: news, social, analyst views.`],
          ["user", "Sentiment analysis:"],
        ]);
        return prompt.pipe(researchLLM).pipe(new StringOutputParser()).invoke({ symbol: this.symbol });
      },
      technical: async () => {
        const prompt = ChatPromptTemplate.fromMessages([
          ["system", `Analyze technicals for {symbol}. Include: trends, indicators, levels.`],
          ["user", "Technical analysis:"],
        ]);
        return prompt.pipe(researchLLM).pipe(new StringOutputParser()).invoke({ symbol: this.symbol });
      },
    });

    const results = await gatherChain.invoke();
    this.sessionState.gatheredData = results;
    console.log("[Phase 1] Complete - Data gathered in parallel");
    return results;
  }

  // Phase 2: Process and Validate Data (Parallel Processing)
  async processData() {
    console.log(`\n[Phase 2] Processing and validating data...`);

    const gathered = this.sessionState.gatheredData;

    const processChain = new RunnableParallel({
      // Validate fundamentals against sentiment
      crossValidation: async () => {
        const prompt = ChatPromptTemplate.fromMessages([
          ["system", `Cross-validate: Fundamentals say {fundamentals}. Sentiment says {sentiment}. Identify contradictions.`],
          ["user", "Validate:"],
        ]);
        return prompt.pipe(researchLLM).pipe(new StringOutputParser()).invoke({
          fundamentals: gathered.fundamentals,
          sentiment: gathered.sentiment,
        });
      },
      // Generate investment thesis
      thesis: async () => {
        const prompt = ChatPromptTemplate.fromMessages([
          ["system", `Based on fundamentals: {fundamentals}, technicals: {technical}, create investment thesis.`],
          ["user", "Generate thesis:"],
        ]);
        return prompt.pipe(researchLLM).pipe(new StringOutputParser()).invoke({
          fundamentals: gathered.fundamentals,
          technical: gathered.technical,
        });
      },
    });

    const results = await processChain.invoke();
    this.sessionState.processedData = results;
    console.log("[Phase 2] Complete - Data processed and validated");
    return results;
  }

  // Phase 3: Synthesis and Merger (Fan-in)
  async synthesize() {
    console.log(`\n[Phase 3] Synthesizing final report...`);

    const gathered = this.sessionState.gatheredData;
    const processed = this.sessionState.processedData;

    const synthesisPrompt = ChatPromptTemplate.fromMessages([
      ["system", `Create a comprehensive investment report for {symbol}.

**Fundamental Analysis:**
{fundamentals}

**Sentiment Analysis:**
{sentiment}

**Technical Analysis:**
{technical}

**Cross-Validation:**
{crossValidation}

**Investment Thesis:**
{thesis}

Provide:
1. Executive Summary
2. Investment Rating (BUY/HOLD/SELL)
3. Key Risks
4. Price Target Rationale
5. Time Horizon Recommendation`],
      ["user", "Create final report:"],
    ]);

    const finalReport = await synthesisPrompt
      .pipe(synthesisLLM)
      .pipe(new StringOutputParser())
      .invoke({
        symbol: this.symbol,
        fundamentals: gathered.fundamentals,
        sentiment: gathered.sentiment,
        technical: gathered.technical,
        crossValidation: processed.crossValidation,
        thesis: processed.thesis,
      });

    console.log("[Phase 3] Complete - Final report synthesized");
    return finalReport;
  }

  // Main分析方法 - orchestrates all phases
  async analyze() {
    console.log(`\n========================================`);
    console.log(`Starting Investment Analysis: ${this.symbol}`);
    console.log(`========================================`);

    try {
      await this.gatherInformation();
      await this.processData();
      const report = await this.synthesize();

      console.log(`\n========================================`);
      console.log(`Investment Analysis Complete for ${this.symbol}`);
      console.log(`========================================`);
      console.log(report);

      return report;
    } catch (error) {
      console.error("Analysis failed:", error);
      throw error;
    }
  }

  // Compare方法 - for multi-asset comparison
  async compare(otherSymbol) {
    console.log(`\n========================================`);
    console.log(`Comparing ${this.symbol} vs ${otherSymbol}`);
    console.log(`========================================`);

    // Parallel comparison
    const comparison = await new RunnableParallel({
      assetA: () => this.analyze(),
      assetB: async () => {
        const other = new InvestmentAgent(otherSymbol);
        return other.analyze();
      },
    }).invoke();

    return comparison;
  }
}

// --- Usage Examples ---

// Example 1: Single stock analysis
async function analyzeSingleStock() {
  const agent = new InvestmentAgent("TSLA");
  await agent.analyze();
}

// Example 2: Multi-asset comparison
async function compareStocks() {
  const agent = new InvestmentAgent("MSFT");
  await agent.compare("AAPL");
}

// Run single stock analysis
analyzeSingleStock();