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

// --- Define Custom Tools ---

// Tool 1: Weather Search
const weatherTool = new Tool({
  name: 'weather_search',
  description:
    'Search for current weather information in a specific city. Input should be a city name.',
  func: async (city) => {
    // In production, this would call a real weather API
    const weatherData = {
      'New York': { temp: '72°F', condition: 'Sunny', humidity: '45%' },
      London: { temp: '58°F', condition: 'Rainy', humidity: '78%' },
      Tokyo: { temp: '68°F', condition: 'Cloudy', humidity: '60%' },
    };
    return JSON.stringify(weatherData[city] || { error: 'City not found' });
  },
});

// Tool 2: Stock Price Lookup
const stockTool = new Tool({
  name: 'stock_price_lookup',
  description:
    'Get current stock price for a given ticker symbol. Input should be a stock symbol like AAPL, GOOGL, MSFT.',
  func: async (ticker) => {
    // In production, this would call a real stock API
    const stockData = {
      AAPL: { price: 178.52, change: '+1.2%', volume: '52.3M' },
      GOOGL: { price: 141.8, change: '-0.5%', volume: '21.1M' },
      MSFT: { price: 378.91, change: '+0.8%', volume: '18.7M' },
    };
    return JSON.stringify(stockData[ticker.toUpperCase()] || { error: 'Ticker not found' });
  },
  schema: z.string(),
});

// Tool 3: Calculator
const calculatorTool = new Tool({
  name: 'calculator',
  description:
    "Perform mathematical calculations. Input should be a mathematical expression like '2 + 2' or 'sqrt(16)'.",
  func: async (expression) => {
    try {
      // WARNING: eval() is used here for demonstration only. In production, use a safe math parser.
      const result = eval(expression);
      return JSON.stringify({ expression, result });
    } catch (error) {
      return JSON.stringify({ error: 'Invalid expression' });
    }
  },
});

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

const llmWithTools = llm.bind({
  tools: [weatherTool, stockTool, calculatorTool],
});

// --- Run Tool-Enabled Agent ---
async function runToolExample(userQuery) {
  console.log(`\n--- Running Tool Example for Query: '${userQuery}' ---`);

  const prompt = ChatPromptTemplate.fromMessages([
    ['system', 'You are a helpful assistant with access to tools. Use them when needed.'],
    ['user', '{query}'],
  ]);

  const chain = prompt.pipe(llmWithTools);

  const response = await chain.invoke({ query: userQuery });

  console.log('\n--- Response ---');
  console.log(response.content);

  // Check if the model wants to call a tool
  if (response.tool_calls && response.tool_calls.length > 0) {
    console.log('\n--- Tool Calls Requested ---');
    for (const toolCall of response.tool_calls) {
      console.log(`- Tool: ${toolCall.name}`);
      console.log(`  Args: ${JSON.stringify(toolCall.args)}`);
    }
  }
}

// Test queries
runToolExample("What's the weather like in New York?");
runToolExample("What's the current price of AAPL?");
runToolExample('Calculate 15 * 23 + 50');

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { Tool } from '@langchain/core/tools';
import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';

// --- Define Tools ---

// Search Tool
const searchTool = new Tool({
  name: 'web_search',
  description: 'Search the web for information. Input should be a search query.',
  func: async (query) => {
    // In production, integrate with Google, Bing, or other search APIs
    return `Search results for "${query}": [Mock results - In production, this would return real search results]`;
  },
});

// Calculator Tool
const calculatorTool = new Tool({
  name: 'calculator',
  description: 'Perform mathematical calculations.',
  func: async (expression) => {
    try {
      const result = eval(expression);
      return JSON.stringify({ expression, result });
    } catch {
      return JSON.stringify({ error: 'Invalid expression' });
    }
  },
});

// --- Create Agent with Tools ---

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

// Define the prompt template
const prompt = ChatPromptTemplate.fromMessages([
  [
    'system',
    `You are a helpful research assistant.
You have access to the following tools:
- web_search: Search the web for information
- calculator: Perform mathematical calculations

Use tools when necessary to answer user questions. Always show your reasoning.`,
  ],
  ['human', '{input}'],
  ['placeholder', '{agent_scratchpad}'],
]);

// Create the agent
const agent = await createOpenAIFunctionsAgent({
  llm,
  tools: [searchTool, calculatorTool],
  prompt,
});

// Create the executor
const agentExecutor = new AgentExecutor({
  agent,
  tools: [searchTool, calculatorTool],
});

// --- Run the Agent ---
async function runAgentQuery(query) {
  console.log(`\n--- Running Agent Query: '${query}' ---`);

  try {
    const result = await agentExecutor.invoke({ input: query });

    console.log('\n--- Agent Response ---');
    console.log(result.output);
  } catch (error) {
    console.error(`\nAn error occurred: ${error}`);
  }
}

// Test queries
runAgentQuery('What is the population of Tokyo?');
runAgentQuery(
  'If I have $10,000 invested at 7% annual interest for 5 years, how much will I have?',
);
runAgentQuery('What are the latest developments in AI?');

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

// --- Define Tools ---

const getStockPrice = new Tool({
  name: 'get_stock_price',
  description: 'Get the current stock price for a given ticker symbol.',
  func: async (ticker) => {
    const prices = {
      AAPL: 178.52,
      GOOGL: 141.8,
      MSFT: 378.91,
      AMZN: 178.25,
      TSLA: 248.5,
    };
    const price = prices[ticker.toUpperCase()];
    return price ? `$${price}` : 'Ticker not found';
  },
});

const getStockNews = new Tool({
  name: 'get_stock_news',
  description: 'Get recent news headlines for a given stock ticker.',
  func: async (ticker) => {
    // In production, call a news API
    const news = {
      AAPL: ['Apple announces new AI features', 'iPhone sales exceed expectations'],
      GOOGL: ['Google Cloud growth accelerates', 'AI investments pay off'],
      MSFT: ['Microsoft Teams reaches 300M users', 'Azure revenue up 29%'],
    };
    const headlines = news[ticker.toUpperCase()] || ['No recent news found'];
    return headlines.map((h, i) => `${i + 1}. ${h}`).join('\n');
  },
});

const getFinancialMetrics = new Tool({
  name: 'get_financial_metrics',
  description: 'Get key financial metrics for a stock (P/E ratio, EPS, etc.).',
  func: async (ticker) => {
    const metrics = {
      AAPL: { peRatio: 28.5, eps: 6.26, marketCap: '2.8T' },
      GOOGL: { peRatio: 24.2, eps: 5.86, marketCap: '1.7T' },
      MSFT: { peRatio: 35.1, eps: 10.81, marketCap: '2.8T' },
    };
    return JSON.stringify(metrics[ticker.toUpperCase()] || { error: 'Metrics not found' });
  },
});

// --- Parallel Tool Execution ---

async function analyzeStock(ticker) {
  console.log(`\n--- Analyzing Stock: ${ticker} ---`);

  // Execute all tools in parallel (Fan-out)
  const parallelTools = new RunnableParallel({
    price: () => getStockPrice.invoke(ticker),
    news: () => getStockNews.invoke(ticker),
    metrics: () => getFinancialMetrics.invoke(ticker),
  });

  const results = await parallelTools.invoke();

  console.log('\n--- Tool Results ---');
  console.log('Price:', results.price);
  console.log('News:', results.news);
  console.log('Metrics:', results.metrics);

  return results;
}

// --- Synthesis with LLM ---

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

async function generateStockReport(ticker, data) {
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      `You are a financial analyst. Based on the following data for {ticker}, provide a brief investment summary.`,
    ],
    ['user', `Stock: {ticker}\nPrice: {price}\nNews: {news}\nMetrics: {metrics}`],
  ]);

  const chain = prompt.pipe(llm).pipe(new StringOutputParser());
  const report = await chain.invoke({
    ticker,
    price: data.price,
    news: data.news,
    metrics: data.metrics,
  });

  return report;
}

// --- Main Pipeline ---

async function stockAnalysisPipeline(ticker) {
  // Step 1: Gather data in parallel
  const data = await analyzeStock(ticker);

  // Step 2: Generate synthesis report
  const report = await generateStockReport(ticker, data);

  console.log('\n--- Final Investment Report ---');
  console.log(report);
}

// Run the pipeline
stockAnalysisPipeline('AAPL');

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

// --- 1. Stock Market Data API Tool ---
const stockMarketDataTool = new Tool({
  name: "get_stock_price",
  description: "Get real-time stock price and market data. Input: stock ticker symbol (e.g., AAPL, TSLA).",
  async func(symbol) {
    // Simulated stock data - in production, call real market data API
    const marketData = {
      AAPL: { price: 178.52, change: "+1.2%", volume: "52.3M", high: 180.1, low: 176.8 },
      TSLA: { price: 248.50, change: "-2.3%", volume: "89.1M", high: 255.0, low: 245.2 },
      MSFT: { price: 378.91, change: "+0.8%", volume: "18.7M", high: 380.5, low: 375.2 },
    };
    const data = marketData[symbol.toUpperCase()];
    return data ? JSON.stringify(data) : JSON.stringify({ error: "Symbol not found" });
  },
});

// --- 2. Web Search API Tool ---
const webSearchTool = new Tool({
  name: "search_financial_news",
  description: "Search for latest financial news and market information. Input: search query.",
  async func(query) {
    // Simulated news search - in production, integrate with Google/Bing API
    const newsResults = {
      "AAPL earnings": "Apple reports Q4 earnings beat, revenue up 8% YoY, iPhone sales strong",
      "TSLA China": "Tesla faces increased competition in China, announces price adjustments",
      "Fed rates": "Federal Reserve signals potential rate cuts in upcoming meetings",
    };
    // Simple keyword matching
    for (const [key, value] of Object.entries(newsResults)) {
      if (query.toLowerCase().includes(key.toLowerCase())) {
        return value;
      }
    }
    return `News results for "${query}": [In production, return real search results]`;
  },
});

// --- 3. Knowledge Base / RAG Retrieval Tool ---
const knowledgeBaseTool = new Tool({
  name: "query_financial_kb",
  description: "Query internal financial knowledge base for company reports, budget data, or financial analysis. Input: search query.",
  async func(query) {
    // Simulated RAG/knowledge base - in production, use vector database
    const kbData = {
      "Alpha project Q1 budget": "Alpha project Q1 2024 budget: $2.5M allocated, $2.1M spent",
      "AAPL debt": "Apple total debt: $290B, Debt-to-Equity ratio: 1.8x",
      "MSFT cloud revenue": "Microsoft Azure cloud revenue: $21.7B in Q4 2024",
    };
    for (const [key, value] of Object.entries(kbData)) {
      if (query.toLowerCase().includes(key.toLowerCase())) {
        return value;
      }
    }
    return `Knowledge base results for "${query}": No specific match found`;
  },
});

// --- Bind Tools to LLM ---
const llm = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.3 });
const llmWithTools = llm.bind({
  tools: [stockMarketDataTool, webSearchTool, knowledgeBaseTool],
});

// --- Usage Example ---
async function queryInvestmentAgent(query) {
  console.log(`\n=== Investment Agent Query: ${query} ===`);

  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an Investment Research Assistant. Use available tools to gather data and answer questions.`],
    ["user", "{query}"],
  ]);

  const chain = prompt.pipe(llmWithTools);
  const response = await chain.invoke({ query });

  console.log("\n--- Response ---");
  console.log(response.content);

  if (response.tool_calls) {
    console.log("\n--- Tools Invoked ---");
    for (const call of response.tool_calls) {
      console.log(`- ${call.name}:`, call.args);
    }
  }
}

// Test queries
queryInvestmentAgent("What's the current price of AAPL?");
queryInvestmentAgent("Search for latest AAPL earnings news");
queryInvestmentAgent("What was the Alpha project Q1 budget?");

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

// --- 1. Calculator Tool ---
const calculatorTool = new Tool({
  name: "financial_calculator",
  description: "Perform precise financial calculations. Supports: profit/loss, percentage returns, portfolio allocation. Input: mathematical expression.",
  async func(expression) {
    try {
      // Safe evaluation - in production, use math.js or similar
      // Only allow specific patterns for safety
      const safeEval = (expr) => {
        const sanitized = expr.replace(/[^0-9+\-*/.()%]/g, "");
        return Function(`"use strict"; return (${sanitized})`)();
      };
      const result = safeEval(expression);
      return JSON.stringify({ expression, result, formatted: result.toFixed(2) });
    } catch (error) {
      return JSON.stringify({ error: "Invalid calculation expression" });
    }
  },
});

// --- 2. Code Interpreter / Executor Tool ---
const codeExecutorTool = new Tool({
  name: "run_financial_code",
  description: "Execute Python code for complex financial analysis, technical indicators, backtesting. Input: Python code string.",
  async func(code) {
    // Simulated code execution - in production, use Python sandbox
    console.log("\n[Code Executor] Running code...");

    // Simulate some common financial calculations
    if (code.includes("SMA") || code.includes("moving average")) {
      return JSON.stringify({
        output: "Simple Moving Average calculated",
        result: [100, 102, 105, 108, 110],
        interpretation: "Upward trend detected",
      });
    }
    if (code.includes("RSI")) {
      return JSON.stringify({
        output: "RSI calculated",
        result: 65.5,
        interpretation: "Overbought territory (>70)",
      });
    }

    return JSON.stringify({ output: "Code executed", result: "Simulation complete" });
  },
});

// --- 3. Spreadsheet Tool ---
const spreadsheetTool = new Tool({
  name: "analyze_spreadsheet",
  description: "Read and analyze financial data from spreadsheets. Input: file path or data query.",
  async func(query) {
    // Simulated spreadsheet analysis - in production, use proper spreadsheet API
    const spreadsheetData = {
      "portfolio holdings": [
        { symbol: "AAPL", shares: 100, avgCost: 150, currentPrice: 178.52 },
        { symbol: "MSFT", shares: 50, avgCost: 320, currentPrice: 378.91 },
        { symbol: "GOOGL", shares: 30, avgCost: 130, currentPrice: 141.80 },
      ],
      "expense report": [
        { category: "Marketing", amount: 50000 },
        { category: "R&D", amount: 120000 },
        { category: "Operations", amount: 85000 },
      ],
    };

    for (const [key, value] of Object.entries(spreadsheetData)) {
      if (query.toLowerCase().includes(key.toLowerCase())) {
        return JSON.stringify(value);
      }
    }
    return JSON.stringify({ error: "Data not found" });
  },
});

// --- Agent with Calculation Tools ---
const llm = new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.3 });
const llmWithTools = llm.bind({
  tools: [calculatorTool, codeExecutorTool, spreadsheetTool],
});

// --- Usage Example ---
async function runFinancialAnalysis(task) {
  console.log(`\n=== Financial Analysis Task: ${task} ===`);

  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are a Financial Analysis Assistant. Use calculation tools to perform precise financial analysis.`],
    ["user", "{task}"],
  ]);

  const chain = prompt.pipe(llmWithTools);
  const response = await chain.invoke({ task });

  console.log("\n--- Analysis Result ---");
  console.log(response.content);
}

// Test calculations
runFinancialAnalysis("Calculate profit for buying 100 shares at $150 and selling at $178.52");
runFinancialAnalysis("Run Python code to calculate 20-day SMA for AAPL");
runFinancialAnalysis("Show me the portfolio holdings spreadsheet data");

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

// --- Trading API Tool ---
const tradingApiTool = new Tool({
  name: "execute_trade",
  description: "Execute a trade order (BUY/SELL). Parameters: symbol, quantity, orderType (market/limit), price (for limit orders).",
  async func(params) {
    // Parse parameters
    let { symbol, action, quantity, orderType, price } = params;
    try {
      const parsed = typeof params === "string" ? JSON.parse(params) : params;
      symbol = parsed.symbol;
      action = parsed.action || "BUY";
      quantity = parsed.quantity;
      orderType = parsed.orderType || "market";
      price = parsed.price;
    } catch (e) {
      return JSON.stringify({ success: false, error: "Invalid parameters" });
    }

    // Simulate trade execution
    console.log(`\n[Trading API] Executing: ${action} ${quantity} shares of ${symbol} at ${orderType} order`);

    // Simulate execution result
    const executedPrice = orderType === "limit" ? price : 250.0; // Mock market price
    const commission = quantity * executedPrice * 0.001; // 0.1% commission

    return JSON.stringify({
      success: true,
      orderId: `ORD-${Date.now()}`,
      symbol,
      action,
      quantity,
      executedPrice: executedPrice.toFixed(2),
      orderType,
      commission: commission.toFixed(2),
      totalValue: (quantity * executedPrice).toFixed(2),
      status: "FILLED",
      timestamp: new Date().toISOString(),
    });
  },
});

// --- Portfolio Management Tool ---
const portfolioTool = new Tool({
  name: "manage_portfolio",
  description: "Get portfolio positions, account balance, or update portfolio settings. Actions: getPositions, getBalance, updateSettings.",
  async func(params) {
    const { action, ...rest } = typeof params === "string" ? JSON.parse(params) : params;

    if (action === "getPositions") {
      return JSON.stringify({
        positions: [
          { symbol: "AAPL", shares: 100, avgCost: 150, currentValue: 17852 },
          { symbol: "MSFT", shares: 50, avgCost: 320, currentValue: 18945.5 },
        ],
        totalValue: 36797.5,
        cashBalance: 5202.5,
      });
    }

    if (action === "getBalance") {
      return JSON.stringify({
        availableCash: 5202.5,
        buyingPower: 10405.0, // 2x margin
        totalValue: 36797.5,
        totalEquity: 42000.0,
      });
    }

    return JSON.stringify({ error: "Unknown action" });
  },
});

// --- Agent with Trading Tools ---
const llm = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });
const llmWithTools = llm.bind({
  tools: [tradingApiTool, portfolioTool],
});

// --- Usage Example ---
async function executeTradingCommand(command) {
  console.log(`\n=== Trading Command: ${command} ===`);

  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an Automated Trading Assistant. Execute trades based on user commands. Use trading tools.`],
    ["user", "{command}"],
  ]);

  const chain = prompt.pipe(llmWithTools);
  const response = await chain.invoke({ command });

  console.log("\n--- Trading Result ---");
  console.log(response.content);
}

// Test trading commands
executeTradingCommand("Buy 100 shares of TSLA at market price");
executeTradingCommand("Show my current positions");
executeTradingCommand("What's my account balance?");

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

// --- Risk Assessment Configuration ---
const riskThresholds = {
  maxPositionSize: 10000, // Max $10,000 per trade
  maxDailyLoss: 5000, // Max $5,000 daily loss
  requireApprovalAmount: 5000, // Require human approval for trades > $5,000
  maxPortfolioConcentration: 0.2, // Max 20% in single position
};

// --- 1. Risk Check Tool ---
const riskCheckTool = new Tool({
  name: "check_risk_compliance",
  description: "Check if a trade meets risk management rules. Returns: approved, requires_approval, or rejected.",
  async func(tradeParams) {
    const { symbol, quantity, price, action } = typeof tradeParams === "string" ? JSON.parse(tradeParams) : tradeParams;

    const tradeValue = quantity * price;
    const violations = [];
    let status = "approved";

    // Check position size
    if (tradeValue > riskThresholds.maxPositionSize) {
      violations.push(`Trade value $${tradeValue} exceeds max $${riskThresholds.maxPositionSize}`);
      status = "requires_approval";
    }

    // Check approval threshold
    if (tradeValue > riskThresholds.requireApprovalAmount) {
      violations.push(`Trade requires human approval (value > $${riskThresholds.requireApprovalAmount})`);
      status = "requires_approval";
    }

    // Check concentration
    // (In production, would check current portfolio)

    return JSON.stringify({
      status,
      tradeValue,
      violations,
      message: violations.length > 0 ? violations.join("; ") : "Trade approved",
    });
  },
});

// --- 2. Human Escalation Tool ---
const escalationTool = new Tool({
  name: "escalate_to_human",
  description: "Escalate complex or high-risk decisions to human analyst. Use when: ambiguous market conditions, high-value trades, risk rule violations.",
  async func(escalationRequest) {
    const { reason, tradeDetails, context } = typeof escalationRequest === "string" ? JSON.parse(escalationRequest) : escalationRequest;

    // In production, this would notify human via email/Slack/console
    console.log("\n[ESCALATION] =======================================");
    console.log("ESCALATION TO HUMAN ANALYST REQUIRED");
    console.log("================================================");
    console.log("Reason:", reason);
    console.log("Trade Details:", tradeDetails);
    console.log("Context:", context);
    console.log("================================================");

    return JSON.stringify({
      escalationId: `ESC-${Date.now()}`,
      status: "pending_human_review",
      message: "Escalated to human analyst. Awaiting decision.",
      timestamp: new Date().toISOString(),
    });
  },
});

// --- 3. Audit Log Tool ---
const auditLogTool = new Tool({
  name: "log_trade_audit",
  description: "Log all trading decisions for compliance and audit purposes.",
  async func(logEntry) {
    const { timestamp, action, symbol, quantity, price, status, approvedBy } = typeof logEntry === "string" ? JSON.parse(logEntry) : logEntry;

    // In production, store in secure audit database
    console.log("\n[AUDIT] =======================================");
    console.log("Trade Audit Log Entry:");
    console.log(`  Timestamp: ${timestamp || new Date().toISOString()}`);
    console.log(`  Action: ${action}`);
    console.log(`  Symbol: ${symbol}`);
    console.log(`  Quantity: ${quantity}`);
    console.log(`  Price: ${price}`);
    console.log(`  Status: ${status}`);
    console.log(`  Approved By: ${approvedBy || "System"}`);
    console.log("================================================");

    return JSON.stringify({ success: true, logId: `AUDIT-${Date.now()}` });
  },
});

// --- Agent with Safety Tools ---
const llm = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });
const llmWithTools = llm.bind({
  tools: [riskCheckTool, escalationTool, auditLogTool],
});

// --- Complete Trading Workflow with Safety ---
async function safeTradingWorkflow(tradeRequest) {
  console.log(`\n=== Safe Trading Workflow ===`);
  console.log("Trade Request:", tradeRequest);

  // Step 1: Risk Check
  const riskPrompt = ChatPromptTemplate.fromMessages([
    ["system", `Check if this trade meets risk compliance. Use the risk_check tool.`],
    ["user", "Check risk for: {trade}"],
  ]);

  const riskChain = riskPrompt.pipe(llmWithTools);
  const riskResult = await riskChain.invoke({ trade: JSON.stringify(tradeRequest) });

  console.log("\n--- Risk Check Result ---");
  console.log(riskResult.content);

  // Step 2: Decision based on risk
  if (riskResult.tool_calls) {
    for (const call of riskResult.tool_calls) {
      if (call.name === "check_risk_compliance") {
        // Execute risk check
        const riskOutput = await riskCheckTool.invoke(call.args);
        const riskData = JSON.parse(riskOutput);

        if (riskData.status === "requires_approval") {
          console.log("\n--- Escalating to Human ---");
          const escalationResult = await escalationTool.invoke({
            reason: "High-value trade requires approval",
            tradeDetails: tradeRequest,
            context: riskData.violations,
          });
          console.log("Escalation Result:", escalationResult);
        }

        // Step 3: Log to audit
        await auditLogTool.invoke({
          action: tradeRequest.action,
          symbol: tradeRequest.symbol,
          quantity: tradeRequest.quantity,
          price: tradeRequest.price,
          status: riskData.status,
          approvedBy: riskData.status === "approved" ? "System" : "Pending",
        });
      }
    }
  }
}

// Test with different trade amounts
safeTradingWorkflow({ action: "BUY", symbol: "AAPL", quantity: 10, price: 178.52 }); // Low value - auto approved
safeTradingWorkflow({ action: "BUY", symbol: "TSLA", quantity: 500, price: 250 }); // High value - requires approval

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { Tool } from "@langchain/core/tools";
import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";

// ============================================
// PART 1: Define All Tools
// ============================================

// Data Gathering Tools
const getStockPrice = new Tool({
  name: "get_stock_price",
  description: "Get current stock price. Input: ticker symbol",
  func: async (symbol) => JSON.stringify({ price: 250.0, symbol }),
});

const searchNews = new Tool({
  name: "search_news",
  description: "Search financial news. Input: search query",
  func: async (query) => `Latest news: Positive earnings report for ${query}`,
});

// Analysis Tools
const calculateROI = new Tool({
  name: "calculate_roi",
  description: "Calculate investment returns. Input: JSON with buyPrice, sellPrice, quantity",
  func: async (params) => {
    const { buyPrice, sellPrice, quantity } = JSON.parse(params);
    const profit = (sellPrice - buyPrice) * quantity;
    const roi = ((sellPrice - buyPrice) / buyPrice) * 100;
    return JSON.stringify({ profit, roi: roi.toFixed(2) + "%" });
  },
});

// Trading Tools
const executeTrade = new Tool({
  name: "execute_trade",
  description: "Execute a trade. Input: JSON with action, symbol, quantity",
  func: async (params) => JSON.stringify({ success: true, orderId: "ORD-123" }),
});

// Safety Tools
const checkRisk = new Tool({
  name: "check_risk",
  description: "Check risk compliance. Input: trade parameters",
  func: async (params) => JSON.stringify({ approved: true, riskLevel: "low" }),
});

const escalate = new Tool({
  name: "escalate_to_human",
  description: "Escalate to human analyst. Input: reason",
  func: async (reason) => JSON.stringify({ escalationId: "ESC-1", status: "pending" }),
});

// ============================================
// PART 2: Create the Agent
// ============================================

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

const tools = [getStockPrice, searchNews, calculateROI, executeTrade, checkRisk, escalate];

const prompt = ChatPromptTemplate.fromMessages([
  ["system", `You are an Investment Agent with access to financial tools.

Available Tools:
- get_stock_price: Get stock prices
- search_news: Search financial news
- calculate_roi: Calculate investment returns
- execute_trade: Execute buy/sell orders
- check_risk: Check risk compliance
- escalate_to_human: Escalate to human for review

Workflow:
1. Gather relevant data (prices, news)
2. Analyze the investment opportunity
3. Check risk compliance
4. If approved, execute trade
5. If high-risk, escalate to human

Always prioritize risk management.`],
  ["human", "{input}"],
  ["placeholder", "{agent_scratchpad}"],
]);

const agent = await createOpenAIFunctionsAgent({
  llm,
  tools,
  prompt,
});

const agentExecutor = new AgentExecutor({
  agent,
  tools,
  verbose: true,
});

// ============================================
// PART 3: Run the Agent
// ============================================

async function runInvestmentAgent(query) {
  console.log(`\n========================================`);
  console.log(`Investment Agent Query: ${query}`);
  console.log(`========================================`);

  try {
    const result = await agentExecutor.invoke({ input: query });
    console.log("\n--- Final Result ---");
    console.log(result.output);
  } catch (error) {
    console.error("Error:", error.message);
  }
}

// Test various queries
runInvestmentAgent("What's the current price of TSLA?");
runInvestmentAgent("Search for TSLA news");
runInvestmentAgent("Calculate potential profit if I buy 100 shares at $240 and sell at $260");
runInvestmentAgent("I want to buy 100 shares of TSLA");