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

const llm = new ChatOpenAI({ temperature: 0.7 });

// Step 1: Generate initial response
const generatePrompt = ChatPromptTemplate.fromTemplate('Write a short summary about: {topic}');

// Step 2: Self-reflection prompt
const reflectPrompt = ChatPromptTemplate.fromTemplate(
  `Evaluate the following summary and identify any issues or areas for improvement:

Summary: {summary}

Provide your feedback on:
1. Accuracy
2. Clarity
3. Completeness
If there are issues, provide an improved version.`,
);

// Generate chain
const generateChain = generatePrompt.pipe(llm).pipe(new StringOutputParser());

// Reflection chain
const reflectChain = reflectPrompt.pipe(llm).pipe(new StringOutputParser());

// Main reflection function
async function selfReflect(topic) {
  console.log('Generating initial response...');
  const initialResponse = await generateChain.invoke({ topic });

  console.log('Performing self-reflection...');
  const feedback = await reflectChain.invoke({ summary: initialResponse });

  return { initialResponse, feedback };
}

// Usage
const result = await selfReflect('artificial intelligence');
console.log('Initial:', result.initialResponse);
console.log('Feedback:', result.feedback);

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

const llm = new ChatOpenAI({ temperature: 0.7 });

// Simulated code execution function (external feedback)
async function executeCode(code) {
  // Simulate code execution
  console.log(`Executing: ${code}`);
  // In real scenario, this would actually execute the code
  try {
    // Simulate execution result
    return { success: true, output: 'Syntax OK', error: null };
  } catch (e) {
    return { success: false, output: null, error: e.message };
  }
}

// Generate code prompt
const codeGenPrompt = ChatPromptTemplate.fromTemplate('Write a function that {task}');

// Evaluation prompt with external feedback
const evaluatePrompt = ChatPromptTemplate.fromTemplate(
  `You wrote the following code:

{code}

The code was executed with this result:
- Success: {success}
- Output: {output}
- Error: {error}

If there were errors, fix them. Provide the corrected code:`,
);

const generateChain = codeGenPrompt.pipe(llm).pipe(new StringOutputParser());
const evaluateChain = evaluatePrompt.pipe(llm).pipe(new StringOutputParser());

// Main function with external feedback
async function codeWithExternalFeedback(task) {
  let code = await generateChain.invoke({ task });
  let maxIterations = 3;

  for (let i = 0; i < maxIterations; i++) {
    const result = await executeCode(code);

    if (result.success) {
      console.log('Code executed successfully!');
      return code;
    }

    console.log(`Iteration ${i + 1}: Fixing errors...`);
    code = await evaluateChain.invoke({
      code,
      success: result.success,
      output: result.output,
      error: result.error,
    });
  }

  return code;
}

// Usage
const fixedCode = await codeWithExternalFeedback('calculate factorial');
console.log('Final code:', fixedCode);

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

// Producer (generates the response)
const producer = new ChatOpenAI({ temperature: 0.7, model: 'gpt-4' });
// Critic (evaluates the response)
const critic = new ChatOpenAI({ temperature: 0, model: 'gpt-4' });

// Producer prompt
const producerPrompt = ChatPromptTemplate.fromTemplate('Provide investment advice for: {query}');

// Critic evaluation prompt
const criticPrompt = ChatPromptTemplate.fromTemplate(
  `You are a financial risk analyst. Evaluate the following investment advice:

Advice: {advice}

Evaluate:
1. Risk level (1-10)
2. Potential red flags or concerns
3. Factual accuracy
4. Whether it aligns with conservative investment principles

Provide detailed feedback:`,
);

// Producer chain
const producerChain = producerPrompt.pipe(producer).pipe(new StringOutputParser());

// Critic chain
const criticChain = criticPrompt.pipe(critic).pipe(new StringOutputParser());

// Main critique function
async function critiqueExample(query) {
  console.log('Producer: Generating advice...');
  const advice = await producerChain.invoke({ query });

  console.log('Critic: Evaluating advice...');
  const feedback = await criticChain.invoke({ advice });

  return { advice, feedback };
}

// Usage
const result = await critiqueExample('Should I invest all my savings in cryptocurrency?');
console.log('Advice:', result.advice);
console.log('Critique:', result.feedback);

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

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

// --- Producer (Trader Agent) ---
const traderPrompt = ChatPromptTemplate.fromMessages([
  ["system", `You are a Trading Analyst. Based on the following market data for {symbol}:

- Current Price: {price}
- P/E Ratio: {pe}
- Revenue Growth: {revenueGrowth}
- Recent News: {news}

Generate a trading recommendation (BUY/SELL/HOLD) with specific action (quantity, order type).`],
  ["user", "Generate trading recommendation:"],
]);

// --- Critic (Risk Review Agent) ---
const criticPrompt = ChatPromptTemplate.fromMessages([
  ["system", `You are a Risk Review Analyst. Evaluate the following trading recommendation for potential issues:

Trader's Recommendation: {recommendation}

Evaluate:
1. Factual accuracy of the data interpretation
2. Potential biases in the reasoning
3. Missing information or red flags
4. Risk level (1-10)

If approved, state "APPROVED". If rejected, state "REJECTED" and provide reasons.`],
  ["user", "Review trading recommendation:"],
]);

const traderChain = traderPrompt.pipe(traderLLM).pipe(new StringOutputParser());
const criticChain = criticPrompt.pipe(criticLLM).pipe(new StringOutputParser());

// --- Producer-Critic Validation Function ---
async function validateTrade(tradeRequest) {
  console.log("\n=== Producer-Critic Trading Validation ===");

  // Step 1: Producer generates recommendation
  console.log("[Producer] Generating trading recommendation...");
  const recommendation = await traderChain.invoke(tradeRequest);
  console.log("[Producer] Recommendation:", recommendation);

  // Step 2: Critic evaluates recommendation
  console.log("\n[Critic] Evaluating recommendation...");
  const review = await criticChain.invoke({ recommendation });
  console.log("[Critic] Review:", review);

  // Step 3: Decision
  const isApproved = review.toUpperCase().includes("APPROVED");
  return {
    recommendation,
    review,
    approved: isApproved,
  };
}

// --- Usage ---
const tradeRequest = {
  symbol: "TSLA",
  price: "$245.00",
  pe: "65.2",
  revenueGrowth: "24%",
  news: "Q4 earnings beat, new model announced, but increased competition in China",
};

validateTrade(tradeRequest).then(result => {
  console.log("\n=== Final Decision ===");
  console.log("Approved:", result.approved);
});

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

// --- Portfolio Constraints ---
const portfolioConstraints = {
  maxPositionPerStock: 0.05, // Max 5% per stock
  maxPortfolioRisk: 0.15, // Max 15% portfolio risk
  stopLossPercent: 0.10, // 10% stop loss
  maxStocks: 20, // Max 20 positions
};

// --- Guardrails Check Function ---
async function checkGuardrails(trade, portfolio) {
  console.log("\n=== Guardrails Compliance Check ===");

  const guardrailsPrompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Compliance Checker. Verify if this trade violates any rules.

**Portfolio Constraints:**
- Max position per stock: {maxPosition}%
- Max portfolio risk: {maxRisk}%
- Stop loss threshold: {stopLoss}%
- Max positions: {maxStocks}

**Current Portfolio:**
{portfolio}

**Proposed Trade:**
{trade}

Check each rule and return:
1. VIOLATED rules (if any)
2. PASSED rules
3. Final decision: APPROVED or REJECTED with reasons`],
    ["user", "Check compliance:"],
  ]);

  const chain = guardrailsPrompt.pipe(llm).pipe(new StringOutputParser());

  const result = await chain.invoke({
    maxPosition: (portfolioConstraints.maxPositionPerStock * 100),
    maxRisk: (portfolioConstraints.maxPortfolioRisk * 100),
    stopLoss: (portfolioConstraints.stopLossPercent * 100),
    maxStocks: portfolioConstraints.maxStocks,
    portfolio: JSON.stringify(portfolio, null, 2),
    trade: JSON.stringify(trade, null, 2),
  });

  console.log("Compliance Result:", result);
  return result;
}

// --- Simulated Portfolio ---
const currentPortfolio = [
  { symbol: "AAPL", value: 15000, percent: 0.15 }, // Already at max
  { symbol: "MSFT", value: 10000, percent: 0.10 },
  { symbol: "GOOGL", value: 5000, percent: 0.05 },
];

// --- Test Trade ---
const proposedTrade = {
  action: "BUY",
  symbol: "NVDA",
  quantity: 100,
  price: 450,
  totalValue: 45000,
};

checkGuardrails(proposedTrade, currentPortfolio);

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

const fundamentalLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.7 });
const technicalLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.7 });
const sentimentLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.7 });
const consensusLLM = new ChatOpenAI({ model: "gpt-4o", temperature: 0.2 });

// --- Debate Agents ---

// Fundamental Analysis Agent
const fundamentalAgent = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Fundamental Analysis Expert.
Provide your BUY/SELL/HOLD recommendation for {symbol} based on:
- P/E ratio, revenue growth, profit margins
- Financial health and debt levels

State your position and provide key arguments.`],
    ["user", "Fundamental analysis:"],
  ]);
  return prompt.pipe(fundamentalLLM).pipe(new StringOutputParser()).invoke({ symbol });
};

// Technical Analysis Agent
const technicalAgent = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Technical Analysis Expert.
Provide your BUY/SELL/HOLD recommendation for {symbol} based on:
- Price trends, support/resistance levels
- RSI, MACD, moving averages

State your position and provide key arguments.`],
    ["user", "Technical analysis:"],
  ]);
  return prompt.pipe(technicalLLM).pipe(new StringOutputParser()).invoke({ symbol });
};

// Sentiment Analysis Agent
const sentimentAgent = async (symbol) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Sentiment Analysis Expert.
Provide your BUY/SELL/HOLD recommendation for {symbol} based on:
- News sentiment, social media trends
- Analyst ratings and investor behavior

State your position and provide key arguments.`],
    ["user", "Sentiment analysis:"],
  ]);
  return prompt.pipe(sentimentLLM).pipe(new StringOutputParser()).invoke({ symbol });
};

// --- Consensus Agent ---
const consensusAgent = async (debates) => {
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are the Consensus Moderator. Review the debate and reach a final decision.

**Fundamental View:**
{fundamental}

**Technical View:**
{technical}

**Sentiment View:**
{sentiment}

Analyze each perspective, identify areas of agreement/disagreement, and provide:
1. Final recommendation (BUY/SELL/HOLD)
2. Confidence level
3. Key reasoning that combines all perspectives`],
    ["user", "Reach consensus:"],
  ]);

  return prompt.pipe(consensusLLM).pipe(new StringOutputParser()).invoke(debates);
};

// --- Chain of Debates Function ---
async function chainOfDebates(symbol) {
  console.log(`\n=== Chain of Debates for ${symbol} ===`);

  // Phase 1: Each agent provides initial view
  console.log("\n[Debate Phase] Each agent provides initial view...");
  const [fundamental, technical, sentiment] = await Promise.all([
    fundamentalAgent(symbol),
    technicalAgent(symbol),
    sentimentAgent(symbol),
  ]);

  console.log("\n--- Fundamental View ---", fundamental);
  console.log("\n--- Technical View ---", technical);
  console.log("\n--- Sentiment View ---", sentiment);

  // Phase 2: Reach consensus
  console.log("\n[Consensus Phase] Moderating debate...");
  const consensus = await consensusAgent({
    fundamental,
    technical,
    sentiment,
  });

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

// Run the debate
chainOfDebates("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.5 });

// --- Simulated Trade Execution ---
async function executeTrade(trade) {
  console.log(`\n[Execution] Attempting to execute: ${trade.action} ${trade.quantity} shares of ${trade.symbol}`);

  // Simulate execution logic
  const randomFailure = Math.random() < 0.3; // 30% chance of failure

  if (randomFailure) {
    return {
      success: false,
      error: "Insufficient funds",
      originalTrade: trade,
    };
  }

  return {
    success: true,
    executedPrice: trade.price * 1.02, // Assume slippage
    executedQuantity: trade.quantity,
  };
}

// --- Anomaly Reflection ---
async function reflectOnFailure(executionResult) {
  console.log("\n[Reflection] Analyzing execution failure...");

  const reflectionPrompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Trading Strategy Refiner. Analyze why this trade failed and propose adjustments.

**Original Trade:**
{trade}

**Error:**
{error}

Analyze the failure reason and propose:
1. Adjusted trade parameters (quantity, order type)
2. Alternative strategies
3. Whether to retry or abort`],
    ["user", "Reflect on failure:"],
  ]);

  const chain = reflectionPrompt.pipe(llm).pipe(new StringOutputParser());
  return chain.invoke({
    trade: JSON.stringify(executionResult.originalTrade),
    error: executionResult.error,
  });
}

// --- Trade Execution with Reflection ---
async function executeWithReflection(trade, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    console.log(`\n=== Attempt ${attempt} ===`);

    const result = await executeTrade(trade);

    if (result.success) {
      console.log("Trade executed successfully!");
      console.log("Result:", result);
      return result;
    }

    console.log("Trade failed:", result.error);

    if (attempt < maxRetries) {
      console.log("\n[Reflection] Analyzing failure...");
      const adjustment = await reflectOnFailure(result);
      console.log("Adjustment suggestion:", adjustment);

      // Adjust trade based on reflection
      if (result.error === "Insufficient funds") {
        trade.quantity = Math.floor(trade.quantity * 0.7); // Reduce quantity by 30%
        console.log(`[Adjustment] Reduced quantity to ${trade.quantity}`);
      }
    }
  }

  console.log("\n[Reflection] Max retries reached. Trade aborted.");
  return { success: false, aborted: true };
}

// --- Usage ---
const initialTrade = {
  action: "BUY",
  symbol: "TSLA",
  quantity: 100,
  price: 250,
};

executeWithReflection(initialTrade);

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

// --- Memory Store (Simulated) ---
class TradingMemory {
  constructor() {
    this.decisions = [];
  }

  async addDecision(decision) {
    this.decisions.push({
      ...decision,
      timestamp: new Date().toISOString(),
    });
    console.log(`[Memory] Stored decision: ${decision.symbol} ${decision.action}`);
  }

  getRecentDecisions(symbol, limit = 5) {
    return this.decisions
      .filter(d => d.symbol === symbol)
      .slice(-limit);
  }

  getAllDecisions() {
    return this.decisions;
  }
}

const memory = new TradingMemory();

// --- Trading Agent with Memory ---
class ReflectiveTradingAgent {
  constructor(symbol) {
    this.symbol = symbol;
    this.memory = memory;
  }

  // Generate trading decision
  async generateDecision(marketData) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are a Trading Agent for {symbol}.

Market Data: {marketData}

Provide a trading recommendation (BUY/SELL/HOLD) with reasoning.`],
      ["user", "Generate decision:"],
    ]);

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    return chain.invoke({ symbol: this.symbol, marketData });
  }

  // Reflect on decision with historical context
  async reflectWithMemory(decision) {
    const history = this.memory.getRecentDecisions(this.symbol, 5);

    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are reflecting on a trading decision.

**Current Decision:**
{decision}

**Historical Context (past decisions):**
{history}

Analyze:
1. Is this decision consistent with past patterns?
2. What lessons from past decisions should be considered?
3. Any red flags or confirmations from history?

Provide reflection and any adjustments to the decision.`],
      ["user", "Reflect with history:"],
    ]);

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    return chain.invoke({
      decision,
      history: JSON.stringify(history, null, 2),
    });
  }

  // Learn from outcome (called after trade result is known)
  async learnFromOutcome(decision, outcome) {
    const prompt = ChatPromptTemplate.fromMessages([
      ["system", `You are learning from a completed trade.

**Decision Made:**
{decision}

**Outcome (profit/loss):**
{outcome}

Analyze:
1. Was the decision correct? Why or why not?
2. What can be learned for future decisions?
3. Key insights to remember?`],
      ["user", "Learn from outcome:"],
    ]);

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    const lesson = await chain.invoke({ decision, outcome });

    // Store in memory
    await this.memory.addDecision({
      symbol: this.symbol,
      action: decision.action,
      reasoning: decision.reasoning,
      outcome: outcome,
      lesson: lesson,
    });

    return lesson;
  }

  // Main workflow
  async trade(marketData, outcome = null) {
    console.log(`\n=== Trading Workflow for ${this.symbol} ===`);

    // If we have an outcome, learn from it first
    if (outcome) {
      console.log("[Learning Phase] Learning from past outcome...");
      const lesson = await this.learnFromOutcome(this.lastDecision, outcome);
      console.log("Lesson learned:", lesson);
    }

    // Generate new decision
    console.log("\n[Generation Phase] Generating new decision...");
    const decision = await this.generateDecision(marketData);
    this.lastDecision = { action: decision, reasoning: "Generated", symbol: this.symbol };
    console.log("Decision:", decision);

    // Reflect with memory
    console.log("\n[Reflection Phase] Reflecting with historical context...");
    const reflection = await this.reflectWithMemory(decision);
    console.log("Reflection:", reflection);

    return { decision, reflection };
  }
}

// --- Usage ---
async function runReflectiveTrading() {
  const agent = new ReflectiveTradingAgent("NVDA");

  // First trade
  console.log("\n--- First Trade ---");
  await agent.trade("Price: $450, P/E: 65, News: Strong earnings");

  // Simulate outcome and learn
  console.log("\n--- Simulated Outcome: +15% profit ---");
  await agent.trade("Price: $460, P/E: 68, News: New product launch", "+15% profit");

  // Second trade with memory
  console.log("\n--- Second Trade (with memory) ---");
  await agent.trade("Price: $470, P/E: 70, News: Analyst upgrade");

  // Show all stored memories
  console.log("\n=== Stored Decisions ===");
  console.log(memory.getAllDecisions());
}

runReflectiveTrading();