FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
feat: Add new agents folder structure
rudrasheth0997da2cd16b
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/benjamin_graham_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/benjamin_graham_agent.pynew file mode 100644index 000000000..57783d74f--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/benjamin_graham_agent.py@@ -0,0 +1,373 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class GrahamSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def benjamin_graham_agent(state: AgentState, agent_id: str = "benjamin_graham_agent"):+ """+ Benjamin Graham: Margin of safety, net-net stocks, mathematical approach+ Focus: Quantitative screens, asset protection, statistical cheapness+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ graham_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Applying Graham's quantitative screens")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "total_assets", "current_assets",+ "current_liabilities", "total_debt", "cash_and_equivalents",+ "inventory", "accounts_receivable", "shareholders_equity"+ ],+ end_date,+ period="annual",+ limit=5,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Graham's systematic analyses+ net_net_analysis = analyze_net_net_value(financial_line_items, market_cap)+ defensive_criteria = analyze_defensive_investor_criteria(metrics, financial_line_items)+ margin_of_safety = calculate_margin_of_safety(metrics, financial_line_items, market_cap)+ earnings_stability = analyze_earnings_stability(financial_line_items)+ asset_protection = analyze_asset_protection(financial_line_items, market_cap)++ # Graham's systematic scoring+ total_score = (+ net_net_analysis["score"] * 0.3 ++ defensive_criteria["score"] * 0.25 ++ margin_of_safety["score"] * 0.2 ++ earnings_stability["score"] * 0.15 ++ asset_protection["score"] * 0.1+ )++ # Graham's mechanical approach+ if total_score >= 7.0:+ signal = "bullish"+ elif total_score <= 3.0:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "net_net_analysis": net_net_analysis,+ "defensive_criteria": defensive_criteria,+ "margin_of_safety": margin_of_safety,+ "earnings_stability": earnings_stability,+ "asset_protection": asset_protection+ }++ graham_output = generate_graham_output(ticker, analysis_data, state, agent_id)++ graham_analysis[ticker] = {+ "signal": graham_output.signal,+ "confidence": graham_output.confidence,+ "reasoning": graham_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=graham_output.reasoning)++ message = HumanMessage(content=json.dumps(graham_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(graham_analysis, "Benjamin Graham Agent")++ state["data"]["analyst_signals"][agent_id] = graham_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_net_net_value(financial_line_items: list, market_cap: float) -> dict:+ """Graham's net-net working capital analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for net-net analysis"}++ latest = financial_line_items[0]++ # Calculate Net-Net Working Capital+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0+ total_debt = latest.total_debt if latest.total_debt else 0++ # Conservative liquidation values+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0+ receivables = (latest.accounts_receivable * 0.85) if latest.accounts_receivable else 0+ inventory = (latest.inventory * 0.5) if latest.inventory else 0++ liquidation_value = cash + receivables + inventory+ net_net_value = liquidation_value - current_liabilities - total_debt++ if net_net_value > 0:+ nnwc_ratio = net_net_value / market_cap+ if nnwc_ratio > 0.5: # Trading below 50% of liquidation value+ score += 5+ details.append(f"Exceptional net-net: {nnwc_ratio:.1%} of market cap")+ elif nnwc_ratio > 0.2:+ score += 3+ details.append(f"Good net-net value: {nnwc_ratio:.1%} of market cap")+ else:+ score += 1+ details.append(f"Some net-net value: {nnwc_ratio:.1%} of market cap")+ else:+ details.append("No net-net working capital protection")++ return {"score": score, "details": "; ".join(details)}+++def analyze_defensive_investor_criteria(metrics: list, financial_line_items: list) -> dict:+ """Graham's 10 criteria for defensive investors"""+ score = 0+ criteria_met = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No data for defensive criteria"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # 1. Size requirement (large company)+ if latest_financial.revenue and latest_financial.revenue > 100_000_000: # $100M+ revenue+ criteria_met += 1+ details.append("✓ Adequate size")++ # 2. Strong financial condition (current ratio > 2)+ if latest_metrics.current_ratio and latest_metrics.current_ratio > 2.0:+ criteria_met += 1+ details.append(f"✓ Strong current ratio: {latest_metrics.current_ratio:.1f}")++ # 3. Earnings stability (positive earnings last 10 years)+ earnings_history = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings_history) >= 5:+ positive_years = sum(1 for e in earnings_history if e > 0)+ if positive_years == len(earnings_history):+ criteria_met += 1+ details.append(f"✓ Earnings stability: {positive_years}/{len(earnings_history)} positive years")++ # 4. Dividend record (consistent dividends)+ # Note: Would need dividend data, assuming if profitable and mature+ if latest_financial.net_income and latest_financial.net_income > 0:+ criteria_met += 0.5 # Partial credit+ details.append("? Dividend assumption based on profitability")++ # 5. Earnings growth (33% increase over 10 years)+ if len(earnings_history) >= 5:+ if earnings_history[0] > earnings_history[-1] * 1.33:+ criteria_met += 1+ details.append("✓ Adequate earnings growth")++ # 6. Moderate P/E ratio+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 15:+ criteria_met += 1+ details.append(f"✓ Reasonable P/E: {latest_metrics.price_to_earnings:.1f}")++ # 7. Moderate P/B ratio+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.5:+ criteria_met += 1+ details.append(f"✓ Conservative P/B: {latest_metrics.price_to_book:.1f}")++ # 8-10. Additional safety criteria+ if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity < 0.5:+ criteria_met += 1+ details.append(f"✓ Low debt: {latest_metrics.debt_to_equity:.2f} D/E")++ score = (criteria_met / 8) * 10 # Normalize to 10-point scale++ return {+ "score": score,+ "criteria_met": criteria_met,+ "details": "; ".join(details)+ }+++def calculate_margin_of_safety(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Graham's margin of safety calculation"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for margin of safety"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # Book value approach+ if latest_financial.shareholders_equity and latest_financial.shareholders_equity > 0:+ book_value = latest_financial.shareholders_equity+ pb_ratio = market_cap / book_value++ if pb_ratio < 0.67: # Trading below 2/3 of book value+ score += 4+ details.append(f"Excellent margin of safety: {pb_ratio:.2f} P/B")+ elif pb_ratio < 1.0:+ score += 2+ details.append(f"Good margin of safety: {pb_ratio:.2f} P/B")++ # Earnings approach (conservative P/E)+ if latest_financial.net_income and latest_financial.net_income > 0:+ pe_ratio = market_cap / latest_financial.net_income++ if pe_ratio < 10:+ score += 3+ details.append(f"Conservative earnings multiple: {pe_ratio:.1f} P/E")+ elif pe_ratio < 15:+ score += 1+ details.append(f"Reasonable earnings multiple: {pe_ratio:.1f} P/E")++ # Asset coverage+ if latest_financial.total_assets and latest_financial.total_debt:+ asset_coverage = latest_financial.total_assets / latest_financial.total_debt+ if asset_coverage > 2.0:+ score += 2+ details.append(f"Strong asset coverage: {asset_coverage:.1f}x")++ return {"score": score, "details": "; ".join(details)}+++def analyze_earnings_stability(financial_line_items: list) -> dict:+ """Graham emphasized earnings stability over growth"""+ score = 0+ details = []++ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) < 3:+ return {"score": 0, "details": "Insufficient earnings history"}++ # No losses in recent years+ losses = sum(1 for e in earnings if e < 0)+ if losses == 0:+ score += 3+ details.append("No losses in available periods")+ elif losses <= 1:+ score += 1+ details.append(f"Only {losses} loss year")++ # Earnings consistency (low volatility)+ if earnings:+ avg_earnings = sum(earnings) / len(earnings)+ volatility = sum((e - avg_earnings) ** 2 for e in earnings) / len(earnings)+ coefficient_of_variation = (volatility ** 0.5) / abs(avg_earnings) if avg_earnings != 0 else float('inf')++ if coefficient_of_variation < 0.3:+ score += 2+ details.append(f"Low earnings volatility: {coefficient_of_variation:.2f} CV")++ return {"score": score, "details": "; ".join(details)}+++def analyze_asset_protection(financial_line_items: list, market_cap: float) -> dict:+ """Graham's focus on asset protection for bondholders and stockholders"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No asset data"}++ latest = financial_line_items[0]++ # Working capital adequacy+ if latest.current_assets and latest.current_liabilities:+ working_capital = latest.current_assets - latest.current_liabilities+ if working_capital > 0:+ wc_ratio = working_capital / market_cap+ if wc_ratio > 0.3:+ score += 2+ details.append(f"Strong working capital: {wc_ratio:.1%} of market cap")++ # Debt coverage+ if latest.total_assets and latest.total_debt:+ if latest.total_debt == 0:+ score += 3+ details.append("Debt-free company")+ else:+ debt_ratio = latest.total_debt / latest.total_assets+ if debt_ratio < 0.3:+ score += 2+ details.append(f"Conservative debt: {debt_ratio:.1%} of assets")++ # Tangible book value+ if latest.shareholders_equity:+ tangible_equity = latest.shareholders_equity # Simplified+ if tangible_equity > market_cap * 0.5:+ score += 2+ details.append("Trading below tangible book value")++ return {"score": score, "details": "; ".join(details)}+++def generate_graham_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> GrahamSignal:+ """Generate Graham-style systematic investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Benjamin Graham's AI agent, the father of value investing. Follow his systematic approach:++ 1. Mathematical and quantitative analysis over speculation+ 2. Margin of safety: "Price is what you pay, value is what you get"+ 3. Net-net working capital for maximum safety+ 4. Defensive investor criteria: 10-point checklist+ 5. Asset protection: Focus on balance sheet strength+ 6. Earnings stability over growth+ 7. Systematic approach: Remove emotion from investing+ 8. Statistical cheapness: Buy groups of undervalued securities++ Reasoning style:+ - Emphasize quantitative metrics and ratios+ - Focus on asset protection and balance sheet+ - Stress margin of safety in every decision+ - Use systematic, unemotional language+ - Prefer statistical evidence over narratives+ - Always consider downside protection first++ Return bullish only for statistically cheap, safe companies with adequate margin of safety."""),++ ("human", """Apply Graham's systematic analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_graham_signal():+ return GrahamSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=GrahamSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_graham_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/bill_miller_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/bill_miller_agent.pynew file mode 100644index 000000000..0f09434d9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/bill_miller_agent.py@@ -0,0 +1,376 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class MillerSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def bill_miller_agent(state: AgentState, agent_id: str = "bill_miller_agent"):+ """+ Bill Miller: Concentrated value, contrarian timing+ Focus: Technology value plays, contrarian bets, concentrated positions+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ miller_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Analyzing contrarian value opportunity")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=7, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_assets",+ "shareholders_equity", "total_debt", "research_and_development",+ "operating_income", "outstanding_shares"+ ],+ end_date,+ period="annual",+ limit=7,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Miller's analytical framework+ contrarian_opportunity = analyze_contrarian_setup(metrics, financial_line_items, market_cap)+ technology_value = analyze_technology_value_potential(financial_line_items, market_cap)+ long_term_drivers = analyze_long_term_growth_drivers(financial_line_items)+ market_misperception = identify_market_misperceptions(metrics, financial_line_items)+ concentration_worthiness = evaluate_concentration_candidate(metrics, financial_line_items, market_cap)++ # Miller's conviction-weighted scoring+ total_score = (+ contrarian_opportunity["score"] * 0.3 ++ concentration_worthiness["score"] * 0.25 ++ technology_value["score"] * 0.2 ++ long_term_drivers["score"] * 0.15 ++ market_misperception["score"] * 0.1+ )++ # Miller's high-conviction approach+ if total_score >= 8.0:+ signal = "bullish"+ elif total_score <= 4.0:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "contrarian_opportunity": contrarian_opportunity,+ "technology_value": technology_value,+ "long_term_drivers": long_term_drivers,+ "market_misperception": market_misperception,+ "concentration_worthiness": concentration_worthiness+ }++ miller_output = generate_miller_output(ticker, analysis_data, state, agent_id)++ miller_analysis[ticker] = {+ "signal": miller_output.signal,+ "confidence": miller_output.confidence,+ "reasoning": miller_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=miller_output.reasoning)++ message = HumanMessage(content=json.dumps(miller_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(miller_analysis, "Bill Miller Agent")++ state["data"]["analyst_signals"][agent_id] = miller_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_contrarian_setup(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Miller's contrarian opportunity identification"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No contrarian data"}++ latest_metrics = metrics[0]++ # Extreme valuation as contrarian signal+ if latest_metrics.price_to_earnings:+ if latest_metrics.price_to_earnings < 8: # Extremely cheap+ score += 3+ details.append(f"Extreme valuation contrarian setup: {latest_metrics.price_to_earnings:.1f} P/E")+ elif latest_metrics.price_to_earnings < 12:+ score += 2+ details.append(f"Attractive contrarian valuation: {latest_metrics.price_to_earnings:.1f} P/E")++ # Market sentiment indicators+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.0:+ score += 2+ details.append(f"Market pessimism: {latest_metrics.price_to_book:.2f} P/B below 1.0")++ # Temporary business challenges creating opportunity+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(earnings) >= 5 and len(revenues) >= 5:+ recent_earnings_decline = earnings[0] < earnings[2] # Current vs 2 years ago+ revenue_resilience = revenues[0] > revenues[2] * 0.9 # Revenue holding up++ if recent_earnings_decline and revenue_resilience:+ score += 2+ details.append("Temporary earnings pressure with revenue resilience - contrarian opportunity")++ # Technology disruption creating value+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ if rd_vals and revenues:+ rd_intensity = sum(rd_vals[:3]) / sum(revenues[:3]) if len(revenues) >= 3 else 0+ if rd_intensity > 0.1: # 10%+ R&D intensity+ score += 1+ details.append(f"High R&D investment for future positioning: {rd_intensity:.1%}")++ return {"score": score, "details": "; ".join(details)}+++def analyze_technology_value_potential(financial_line_items: list, market_cap: float) -> dict:+ """Miller's technology value analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No technology data"}++ latest = financial_line_items[0]++ # Asset-light technology model+ if latest.total_assets and latest.revenue:+ asset_turnover = latest.revenue / latest.total_assets+ if asset_turnover > 1.0: # Efficient asset utilization+ score += 2+ details.append(f"Asset-efficient model: {asset_turnover:.1f}x turnover")++ # Scalability indicators+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ margins = []+ for item in financial_line_items:+ if item.operating_income and item.revenue and item.revenue > 0:+ margins.append(item.operating_income / item.revenue)++ if len(revenues) >= 3 and len(margins) >= 3:+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ margin_expansion = margins[0] - margins[-1]++ if revenue_growth > 0.1 and margin_expansion > 0.02: # Growth with margin expansion+ score += 3+ details.append(f"Scalable growth: {revenue_growth:.1%} revenue CAGR with margin expansion")++ # R&D efficiency+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ if rd_vals and revenues:+ rd_to_revenue = rd_vals[0] / revenues[0] if revenues[0] > 0 else 0+ if 0.05 <= rd_to_revenue <= 0.2: # 5-20% R&D ratio+ score += 1+ details.append(f"Strategic R&D investment: {rd_to_revenue:.1%} of revenue")++ # Network effects and switching costs (proxy)+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ fcf_margin = latest.free_cash_flow / latest.revenue if latest.revenue > 0 else 0+ if fcf_margin > 0.2: # 20%+ FCF margin+ score += 2+ details.append(f"High-margin business model: {fcf_margin:.1%} FCF margin")++ return {"score": score, "details": "; ".join(details)}+++def analyze_long_term_growth_drivers(financial_line_items: list) -> dict:+ """Miller's long-term growth potential analysis"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No growth data"}++ # Consistent revenue growth trend+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ if growth_years >= len(revenues) * 0.8: # 80%+ growth years+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ score += 2+ details.append(f"Consistent growth track record: {revenue_cagr:.1%} CAGR")++ # Reinvestment for growth+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ if rd_vals and len(rd_vals) >= 3:+ rd_growth = (rd_vals[0] / rd_vals[-1]) ** (1 / len(rd_vals)) - 1+ if rd_growth > 0.1: # 10%+ R&D growth+ score += 1+ details.append(f"Growing R&D investment: {rd_growth:.1%} CAGR")++ # Market expansion capability+ if latest.total_assets and latest.shareholders_equity:+ leverage_capacity = (latest.total_assets - latest.shareholders_equity) / latest.shareholders_equity+ if leverage_capacity < 0.5: # Low leverage = expansion capacity+ score += 1+ details.append("Balance sheet capacity for growth investments")++ # Free cash flow reinvestment+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if fcf_vals and revenues:+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)+ if positive_fcf_years >= len(fcf_vals) * 0.8: # Consistent cash generation+ score += 2+ details.append(f"Self-funding growth capability: {positive_fcf_years}/{len(fcf_vals)} positive FCF years")++ return {"score": score, "details": "; ".join(details)}+++def identify_market_misperceptions(metrics: list, financial_line_items: list) -> dict:+ """Miller's market misperception identification"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No misperception data"}++ latest_metrics = metrics[0]++ # Quality company trading at value multiple+ if (latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.15 and+ latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 15):+ score += 3+ details.append(+ f"Quality-value disconnect: {latest_metrics.return_on_equity:.1%} ROE at {latest_metrics.price_to_earnings:.1f} P/E")++ # Growth company with temporary headwinds+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(earnings) >= 5 and len(revenues) >= 5:+ historical_earnings_growth = (earnings[-1] / earnings[-3]) ** (1 / 2) - 1 # Earlier period growth+ recent_earnings_decline = earnings[0] < earnings[1]+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1++ if historical_earnings_growth > 0.15 and recent_earnings_decline and revenue_growth > 0.05:+ score += 2+ details.append("Historical growth company with temporary earnings setback")++ # Asset value not recognized+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.2:+ latest_financial = financial_line_items[0]+ if latest_financial.total_assets and latest_financial.total_debt:+ tangible_assets = latest_financial.total_assets - latest_financial.total_debt+ if tangible_assets > 0:+ score += 1+ details.append(f"Asset value misperception: {latest_metrics.price_to_book:.2f} P/B")++ return {"score": score, "details": "; ".join(details)}+++def evaluate_concentration_candidate(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Miller's concentrated portfolio candidate evaluation"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No concentration data"}++ latest_metrics = metrics[0]++ # High conviction criteria+ # Strong competitive position+ if latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.18:+ score += 2+ details.append(f"Strong competitive position: {latest_metrics.return_on_equity:.1%} ROE")++ # Significant upside potential+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 12:+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if earnings:+ # Assume normal multiple of 18x+ upside_potential = (18 * earnings[0]) / market_cap - 1+ if upside_potential > 0.5: # 50%+ upside+ score += 3+ details.append(f"Significant upside potential: {upside_potential:.1%}")++ # Business model durability+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues and len(revenues) >= 7:+ revenue_consistency = len([r for r in revenues if r > min(revenues) * 1.1]) / len(revenues)+ if revenue_consistency > 0.8: # 80%+ years above minimum+ score += 2+ details.append("Durable business model with consistent revenue growth")++ # Management execution track record+ if latest_metrics.return_on_invested_capital and latest_metrics.return_on_invested_capital > 0.12:+ score += 1+ details.append(f"Strong capital allocation: {latest_metrics.return_on_invested_capital:.1%} ROIC")++ return {"score": score, "details": "; ".join(details)}+++def generate_miller_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> MillerSignal:+ """Generate Miller-style contrarian value decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Bill Miller's AI agent, applying contrarian value investing with technology focus:++ 1. Contrarian timing: Buy when others are selling, especially in technology+ 2. Concentrated bets: Make large positions in high-conviction ideas+ 3. Technology value: Find undervalued technology and growth companies+ 4. Long-term perspective: Focus on 3-5 year value creation+ 5. Market misperceptions: Identify when market misprices quality companies+ 6. Fundamental analysis: Deep research into business models and competitive advantages+ 7. Patient opportunism: Wait for exceptional risk/reward opportunities++ Reasoning style:+ - Emphasize contrarian opportunities and market misperceptions+ - Focus on technology companies trading at value multiples+ - Discuss long-term growth drivers and competitive positioning+ - Consider concentration worthiness and conviction level+ - Express willingness to be different from consensus+ - Analyze both current challenges and future potential+ - Apply rigorous fundamental analysis++ Return bullish for high-conviction contrarian opportunities with significant upside potential."""),++ ("human", """Apply contrarian value analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_miller_signal():+ return MillerSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=MillerSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_miller_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/charlie_munger_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/charlie_munger_agent.pynew file mode 100644index 000000000..df950b993--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/charlie_munger_agent.py@@ -0,0 +1,374 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class MungerSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def charlie_munger_agent(state: AgentState, agent_id: str = "charlie_munger_agent"):+ """+ Charlie Munger: Mental models, quality businesses, patience+ Focus: Multidisciplinary thinking, concentrated bets, long-term compounding+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ munger_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Applying multidisciplinary mental models")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "shareholders_equity",+ "total_debt", "retained_earnings", "operating_margin",+ "research_and_development", "outstanding_shares", "total_assets"+ ],+ end_date,+ period="annual",+ limit=10,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Munger's mental model analyses+ business_quality = analyze_mental_model_quality(metrics, financial_line_items)+ moat_durability = analyze_competitive_moat_durability(metrics, financial_line_items)+ management_rationality = analyze_management_rationality(financial_line_items)+ compound_growth = analyze_compounding_potential(financial_line_items)+ incentive_alignment = analyze_incentive_structures(financial_line_items)++ # Munger's weighted approach (fewer, better decisions)+ total_score = (+ business_quality["score"] * 0.3 ++ moat_durability["score"] * 0.25 ++ management_rationality["score"] * 0.2 ++ compound_growth["score"] * 0.15 ++ incentive_alignment["score"] * 0.1+ )++ # Munger's high-conviction approach+ if total_score >= 8.5: # Very high bar+ signal = "bullish"+ elif total_score <= 3.0:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "business_quality": business_quality,+ "moat_durability": moat_durability,+ "management_rationality": management_rationality,+ "compound_growth": compound_growth,+ "incentive_alignment": incentive_alignment+ }++ munger_output = generate_munger_output(ticker, analysis_data, state, agent_id)++ munger_analysis[ticker] = {+ "signal": munger_output.signal,+ "confidence": munger_output.confidence,+ "reasoning": munger_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=munger_output.reasoning)++ message = HumanMessage(content=json.dumps(munger_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(munger_analysis, "Charlie Munger Agent")++ state["data"]["analyst_signals"][agent_id] = munger_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_mental_model_quality(metrics: list, financial_line_items: list) -> dict:+ """Munger's multidisciplinary analysis of business quality"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No data for quality analysis"}++ # Psychology model: Customer psychology and habits+ # Measured by revenue consistency and margin stability+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues and len(revenues) >= 5:+ revenue_volatility = (max(revenues) - min(revenues)) / max(revenues)+ if revenue_volatility < 0.2: # Stable customer behavior+ score += 2+ details.append(f"Stable customer psychology: {revenue_volatility:.1%} revenue volatility")++ # Economics model: High return on capital+ roic_vals = [m.return_on_invested_capital for m in metrics if m.return_on_invested_capital]+ if roic_vals:+ avg_roic = sum(roic_vals) / len(roic_vals)+ if avg_roic > 0.15: # 15%+ ROIC consistently+ score += 3+ details.append(f"Superior capital efficiency: {avg_roic:.1%} avg ROIC")++ # Math model: Compound growth potential+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if len(earnings) >= 5:+ cagr = (earnings[0] / earnings[-1]) ** (1 / len(earnings)) - 1+ if cagr > 0.1: # 10%+ earnings CAGR+ score += 2+ details.append(f"Compounding machine: {cagr:.1%} earnings CAGR")++ # Physics model: Competitive forces and market position+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins:+ avg_margin = sum(margins) / len(margins)+ if avg_margin > 0.2: # 20%+ operating margins+ score += 2+ details.append(f"Pricing power evidence: {avg_margin:.1%} avg operating margin")++ return {"score": score, "details": "; ".join(details)}+++def analyze_competitive_moat_durability(metrics: list, financial_line_items: list) -> dict:+ """Munger's focus on durable competitive advantages"""+ score = 0+ details = []++ if not metrics:+ return {"score": 0, "details": "No metrics for moat analysis"}++ # Consistent high returns (sign of moat)+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if roe_vals:+ high_roe_years = sum(1 for roe in roe_vals if roe > 0.15)+ if high_roe_years >= len(roe_vals) * 0.8: # 80% of years+ score += 3+ details.append(f"Durable high returns: {high_roe_years}/{len(roe_vals)} years ROE >15%")++ # Market share stability (revenue growth matching/exceeding market)+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ growth_consistency = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ if growth_consistency >= len(revenues) * 0.7:+ score += 2+ details.append("Market position strength: consistent revenue progression")++ # R&D efficiency (innovation moat)+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ if rd_vals and revenues:+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])+ if 0.05 <= rd_intensity <= 0.15: # Efficient innovation spend+ score += 2+ details.append(f"Innovation moat: {rd_intensity:.1%} R&D efficiency")++ # Capital requirements (barrier to entry)+ assets = [item.total_assets for item in financial_line_items if item.total_assets]+ if assets and revenues:+ asset_turnover = revenues[0] / assets[0] if assets[0] > 0 else 0+ if asset_turnover > 1.5: # Asset-light model+ score += 1+ details.append(f"Capital-efficient model: {asset_turnover:.1f}x asset turnover")+ elif asset_turnover < 0.5: # High barriers+ score += 1+ details.append(f"High barriers to entry: {asset_turnover:.1f}x asset turnover")++ return {"score": score, "details": "; ".join(details)}+++def analyze_management_rationality(financial_line_items: list) -> dict:+ """Munger's assessment of management decision-making"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No data for management analysis"}++ # Capital allocation rationality+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ retained_earnings = [item.retained_earnings for item in financial_line_items if item.retained_earnings]++ if len(retained_earnings) >= 3:+ # Check if retained earnings are creating value+ re_growth = (retained_earnings[0] - retained_earnings[-1]) / abs(retained_earnings[-1])+ if re_growth > 0.5: # 50%+ growth in retained earnings+ score += 2+ details.append(f"Value-creating reinvestment: {re_growth:.1%} retained earnings growth")++ # Share buyback rationality (buying when cheap)+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]++ if len(shares) >= 3 and len(earnings) >= 3:+ share_reduction = (shares[-1] - shares[0]) / shares[-1]+ earnings_growth = (earnings[0] - earnings[-1]) / earnings[-1]++ if share_reduction > 0.05 and earnings_growth > share_reduction:+ score += 2+ details.append("Rational buybacks: reducing shares while growing earnings")++ # Debt management+ debt_vals = [item.total_debt for item in financial_line_items if item.total_debt is not None]+ if debt_vals:+ if all(debt <= debt_vals[0] * 1.1 for debt in debt_vals): # Controlled debt growth+ score += 1+ details.append("Conservative debt management")++ # Dividend policy consistency+ # Note: Would need dividend data for full analysis+ if fcf_vals and all(fcf > 0 for fcf in fcf_vals):+ score += 1+ details.append("Consistent cash generation enables rational capital allocation")++ return {"score": score, "details": "; ".join(details)}+++def analyze_compounding_potential(financial_line_items: list) -> dict:+ """Munger's emphasis on long-term compounding"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No data for compounding analysis"}++ # Revenue compounding+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ if revenue_cagr > 0.1:+ score += 2+ details.append(f"Revenue compounding: {revenue_cagr:.1%} CAGR")++ # Earnings compounding quality+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if len(earnings) >= 5:+ earnings_cagr = (earnings[0] / earnings[-1]) ** (1 / len(earnings)) - 1+ if earnings_cagr > revenue_cagr if 'revenue_cagr' in locals() else 0.08:+ score += 2+ details.append(f"Earnings leverage: {earnings_cagr:.1%} CAGR")++ # Free cash flow compounding+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow and item.free_cash_flow > 0]+ if len(fcf_vals) >= 3:+ fcf_growth = (fcf_vals[0] / fcf_vals[-1]) ** (1 / len(fcf_vals)) - 1+ if fcf_growth > 0.12: # 12%+ FCF growth+ score += 3+ details.append(f"Cash compounding: {fcf_growth:.1%} FCF CAGR")++ # Reinvestment rate efficiency+ if retained_earnings and len(retained_earnings) >= 3:+ reinvestment_efficiency = earnings_cagr / (+ retained_earnings[0] / revenues[0]) if 'earnings_cagr' in locals() and revenues else 0+ if reinvestment_efficiency > 2.0: # High returns on reinvestment+ score += 1+ details.append("Efficient reinvestment compounding")++ return {"score": score, "details": "; ".join(details)}+++def analyze_incentive_structures(financial_line_items: list) -> dict:+ """Munger's focus on proper incentive alignment"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No data for incentive analysis"}++ # Management ownership alignment (proxy through performance)+ # If management is aligned, we should see improving metrics over time++ # Consistent margin improvement (management efficiency)+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if len(margins) >= 3:+ margin_trend = sum(1 for i in range(len(margins) - 1) if margins[i] >= margins[i + 1])+ if margin_trend >= len(margins) * 0.6:+ score += 2+ details.append("Management efficiency: improving operational margins")++ # Capital efficiency improvement+ assets = [item.total_assets for item in financial_line_items if item.total_assets]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(assets) >= 3 and len(revenues) >= 3:+ recent_efficiency = revenues[0] / assets[0] if assets[0] > 0 else 0+ older_efficiency = revenues[-1] / assets[-1] if assets[-1] > 0 else 0++ if recent_efficiency > older_efficiency * 1.1:+ score += 1+ details.append("Improving capital efficiency over time")++ # Long-term value creation focus+ shareholders_equity = [item.shareholders_equity for item in financial_line_items if item.shareholders_equity]+ if len(shareholders_equity) >= 5:+ equity_cagr = (shareholders_equity[0] / shareholders_equity[-1]) ** (1 / len(shareholders_equity)) - 1+ if equity_cagr > 0.1:+ score += 2+ details.append(f"Shareholder value creation: {equity_cagr:.1%} equity CAGR")++ return {"score": score, "details": "; ".join(details)}+++def generate_munger_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> MungerSignal:+ """Generate Munger-style investment decision using mental models"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Charlie Munger's AI agent, applying multidisciplinary mental models to investing:++ 1. Mental Models: Psychology, economics, math, physics applied to business analysis+ 2. Quality over quantity: "It's better to buy a wonderful company at a fair price"+ 3. Long-term compounding: "The first rule of compounding is to never interrupt it unnecessarily"+ 4. Rational management: Assess capital allocation and incentive alignment+ 5. Durable moats: Sustainable competitive advantages over decades+ 6. Concentrated bets: "Diversification is protection against ignorance"+ 7. Patience and discipline: Wait for exceptional opportunities++ Reasoning style:+ - Use multidisciplinary frameworks and analogies+ - Emphasize long-term thinking and compounding+ - Focus on business quality and management rationality+ - Apply inverse thinking: "What could go wrong?"+ - Reference mental models and psychological biases+ - Express strong convictions when warranted+ - Admit when outside circle of competence++ Return bullish only for exceptional businesses with durable moats and rational management."""),++ ("human", """Apply multidisciplinary mental models to analyze {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_munger_signal():+ return MungerSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=MungerSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_munger_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/david_einhorn_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/david_einhorn_agent.pynew file mode 100644index 000000000..5a2e4284b--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/david_einhorn_agent.py@@ -0,0 +1,410 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class EinhornSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def david_einhorn_agent(state: AgentState, agent_id: str = "david_einhorn_agent"):+ """+ David Einhorn: Short selling + value, forensic accounting+ Focus: Accounting irregularities, overvalued shorts, undervalued longs+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ einhorn_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Conducting forensic accounting analysis")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "operating_income", "free_cash_flow",+ "total_assets", "current_assets", "accounts_receivable",+ "inventory", "total_debt", "shareholders_equity", "depreciation"+ ],+ end_date,+ period="annual",+ limit=5,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Einhorn's analytical framework+ accounting_quality = analyze_accounting_quality(financial_line_items)+ earnings_quality = analyze_earnings_vs_cash_flow(financial_line_items)+ valuation_vs_reality = analyze_valuation_disconnect(metrics, financial_line_items, market_cap)+ red_flags = identify_red_flags(financial_line_items)+ fundamental_value = calculate_fundamental_value(financial_line_items, market_cap)++ # Einhorn's long/short framework+ total_score = (+ accounting_quality["score"] * 0.25 ++ earnings_quality["score"] * 0.25 ++ fundamental_value["score"] * 0.2 ++ valuation_vs_reality["score"] * 0.2 ++ red_flags["score"] * 0.1+ )++ # Einhorn's approach: strong convictions both ways+ if total_score >= 7.5:+ signal = "bullish"+ elif total_score <= 3.5:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "accounting_quality": accounting_quality,+ "earnings_quality": earnings_quality,+ "valuation_vs_reality": valuation_vs_reality,+ "red_flags": red_flags,+ "fundamental_value": fundamental_value+ }++ einhorn_output = generate_einhorn_output(ticker, analysis_data, state, agent_id)++ einhorn_analysis[ticker] = {+ "signal": einhorn_output.signal,+ "confidence": einhorn_output.confidence,+ "reasoning": einhorn_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=einhorn_output.reasoning)++ message = HumanMessage(content=json.dumps(einhorn_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(einhorn_analysis, "David Einhorn Agent")++ state["data"]["analyst_signals"][agent_id] = einhorn_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_accounting_quality(financial_line_items: list) -> dict:+ """Einhorn's forensic accounting analysis"""+ score = 0+ details = []+ red_flags = []++ if not financial_line_items:+ return {"score": 0, "details": "No accounting data"}++ # Revenue quality analysis+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ receivables = [item.accounts_receivable for item in financial_line_items if item.accounts_receivable]++ if len(revenues) >= 3 and len(receivables) >= 3:+ # Days sales outstanding trend+ recent_dso = (receivables[0] / revenues[0]) * 365 if revenues[0] > 0 else 0+ older_dso = (receivables[-1] / revenues[-1]) * 365 if revenues[-1] > 0 else 0++ if recent_dso > older_dso * 1.3: # 30%+ increase in DSO+ red_flags.append("Deteriorating receivables collection")+ score -= 2+ elif recent_dso < older_dso * 1.1: # Stable or improving+ score += 1+ details.append("Stable receivables management")++ # Inventory quality+ inventories = [item.inventory for item in financial_line_items if item.inventory]+ if len(inventories) >= 3 and len(revenues) >= 3:+ recent_inventory_turns = revenues[0] / inventories[0] if inventories[0] > 0 else 0+ older_inventory_turns = revenues[-1] / inventories[-1] if inventories[-1] > 0 else 0++ if recent_inventory_turns < older_inventory_turns * 0.8: # Slowing turns+ red_flags.append("Deteriorating inventory turns")+ score -= 1+ elif recent_inventory_turns > older_inventory_turns * 1.1:+ score += 1+ details.append("Improving inventory management")++ # Asset quality+ assets = [item.total_assets for item in financial_line_items if item.total_assets]+ if len(assets) >= 3:+ asset_growth = (assets[0] / assets[-1]) ** (1 / len(assets)) - 1+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 if revenues else 0++ if asset_growth > revenue_growth * 1.5: # Assets growing much faster than revenue+ red_flags.append("Asset growth exceeds revenue growth")+ score -= 1+ else:+ score += 1+ details.append("Reasonable asset growth relative to revenue")++ if red_flags:+ details.append(f"Red flags: {'; '.join(red_flags)}")++ return {"score": score, "details": "; ".join(details), "red_flags": red_flags}+++def analyze_earnings_vs_cash_flow(financial_line_items: list) -> dict:+ """Einhorn's earnings quality through cash flow analysis"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No cash flow data"}++ # Earnings vs cash flow divergence+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ cash_flows = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]++ if len(earnings) >= 3 and len(cash_flows) >= 3:+ # Compare cumulative earnings vs cash flow+ total_earnings = sum(earnings)+ total_cash_flow = sum(cash_flows)++ if total_cash_flow > total_earnings * 0.8: # FCF is 80%+ of earnings+ score += 2+ details.append(f"Strong cash conversion: FCF/Earnings = {total_cash_flow / total_earnings:.2f}")+ elif total_cash_flow < total_earnings * 0.5: # FCF is <50% of earnings+ score -= 2+ details.append(f"Poor cash conversion: FCF/Earnings = {total_cash_flow / total_earnings:.2f}")++ # Accruals analysis (simplified)+ if earnings and cash_flows:+ recent_accruals = earnings[0] - cash_flows[0] if len(earnings) > 0 and len(cash_flows) > 0 else 0+ if abs(recent_accruals) > abs(earnings[0]) * 0.3: # High accruals relative to earnings+ score -= 1+ details.append("High accruals relative to earnings - quality concern")+ else:+ score += 1+ details.append("Reasonable accruals level")++ # Consistency of cash generation+ if cash_flows:+ positive_fcf_years = sum(1 for fcf in cash_flows if fcf > 0)+ if positive_fcf_years == len(cash_flows):+ score += 2+ details.append(f"Consistent cash generation: {positive_fcf_years}/{len(cash_flows)} years")+ elif positive_fcf_years < len(cash_flows) * 0.6:+ score -= 1+ details.append("Inconsistent cash generation")++ return {"score": score, "details": "; ".join(details)}+++def analyze_valuation_disconnect(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Einhorn's analysis of valuation vs fundamental reality"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No valuation data"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # P/E vs growth analysis+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings > 0:+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if len(earnings) >= 3:+ earnings_growth = (earnings[0] / earnings[-1]) ** (1 / len(earnings)) - 1+ peg_ratio = latest_metrics.price_to_earnings / (earnings_growth * 100) if earnings_growth > 0 else float(+ 'inf')++ if peg_ratio < 1.0: # Undervalued relative to growth+ score += 2+ details.append(f"Attractive PEG ratio: {peg_ratio:.2f}")+ elif peg_ratio > 2.0: # Overvalued relative to growth+ score -= 2+ details.append(f"Expensive PEG ratio: {peg_ratio:.2f}")++ # Book value reality check+ if latest_metrics.price_to_book:+ if latest_metrics.price_to_book < 1.0: # Trading below book+ score += 1+ details.append(f"Trading below book value: {latest_metrics.price_to_book:.2f} P/B")+ elif latest_metrics.price_to_book > 3.0 and latest_metrics.return_on_equity and latest_metrics.return_on_equity < 0.15:+ score -= 2+ details.append(+ f"High P/B with mediocre ROE: {latest_metrics.price_to_book:.2f} P/B, {latest_metrics.return_on_equity:.1%} ROE")++ # Asset-based valuation+ if latest_financial.total_assets and latest_financial.total_debt:+ tangible_book = latest_financial.total_assets - latest_financial.total_debt+ if tangible_book > market_cap:+ score += 2+ details.append("Trading below tangible asset value")++ return {"score": score, "details": "; ".join(details)}+++def identify_red_flags(financial_line_items: list) -> dict:+ """Einhorn's red flag identification system"""+ score = 0+ details = []+ flags = []++ if not financial_line_items:+ return {"score": 0, "details": "No data for red flag analysis"}++ # Rapid asset growth without corresponding revenue growth+ assets = [item.total_assets for item in financial_line_items if item.total_assets]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(assets) >= 3 and len(revenues) >= 3:+ asset_cagr = (assets[0] / assets[-1]) ** (1 / len(assets)) - 1+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1++ if asset_cagr > revenue_cagr + 0.1: # Assets growing 10%+ faster than revenue+ flags.append("Asset growth exceeds revenue growth")+ score -= 2++ # Declining margins with flat/growing revenue+ margins = []+ for item in financial_line_items:+ if item.revenue and item.operating_income and item.revenue > 0:+ margins.append(item.operating_income / item.revenue)++ if len(margins) >= 3:+ margin_trend = margins[0] - margins[-1]+ if margin_trend < -0.05: # 5%+ margin decline+ flags.append("Significant margin compression")+ score -= 1++ # Inconsistent cash flow patterns+ cash_flows = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if cash_flows:+ negative_years = sum(1 for fcf in cash_flows if fcf < 0)+ if negative_years > len(cash_flows) * 0.4: # >40% negative FCF years+ flags.append("Inconsistent cash generation")+ score -= 1++ # High receivables growth+ receivables = [item.accounts_receivable for item in financial_line_items if item.accounts_receivable]+ if len(receivables) >= 3 and len(revenues) >= 3:+ receivables_growth = (receivables[0] / receivables[-1]) ** (1 / len(receivables)) - 1+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1++ if receivables_growth > revenue_growth + 0.15: # Receivables growing 15%+ faster+ flags.append("Receivables growing faster than revenue")+ score -= 1++ if not flags:+ score += 2+ details.append("No major red flags identified")+ else:+ details.append(f"Red flags: {'; '.join(flags)}")++ return {"score": score, "details": "; ".join(details), "flags": flags}+++def calculate_fundamental_value(financial_line_items: list, market_cap: float) -> dict:+ """Einhorn's fundamental valuation analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No fundamental data"}++ latest = financial_line_items[0]++ # Asset-based valuation+ if latest.total_assets and latest.total_debt:+ book_value = latest.total_assets - latest.total_debt+ pb_ratio = market_cap / book_value if book_value > 0 else float('inf')++ if pb_ratio < 1.0:+ score += 3+ details.append(f"Trading below book value: {pb_ratio:.2f} P/B")+ elif pb_ratio < 1.5:+ score += 1+ details.append(f"Reasonable book value: {pb_ratio:.2f} P/B")++ # Earnings-based valuation+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if earnings:+ avg_earnings = sum(earnings) / len(earnings)+ pe_ratio = market_cap / avg_earnings++ if pe_ratio < 12:+ score += 2+ details.append(f"Low earnings multiple: {pe_ratio:.1f} P/E")+ elif pe_ratio > 25:+ score -= 1+ details.append(f"High earnings multiple: {pe_ratio:.1f} P/E")++ # Cash flow valuation+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ fcf_yield = latest.free_cash_flow / market_cap+ if fcf_yield > 0.08: # 8%+ FCF yield+ score += 2+ details.append(f"Attractive FCF yield: {fcf_yield:.1%}")+ elif fcf_yield < 0.03: # <3% FCF yield+ score -= 1+ details.append(f"Low FCF yield: {fcf_yield:.1%}")++ return {"score": score, "details": "; ".join(details)}+++def generate_einhorn_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> EinhornSignal:+ """Generate Einhorn-style forensic analysis decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are David Einhorn's AI agent, applying forensic accounting and value analysis:++ 1. Forensic accounting: Scrutinize financial statements for quality and red flags+ 2. Earnings quality: Compare earnings to cash flows, analyze accruals+ 3. Value vs. price: Identify disconnects between valuation and reality+ 4. Short candidates: Find overvalued companies with accounting issues+ 5. Long candidates: Find undervalued companies with clean accounting+ 6. Red flag detection: Identify warning signs of financial manipulation+ 7. Contrarian positioning: Take positions opposite to market sentiment++ Reasoning style:+ - Emphasize accounting quality and financial statement analysis+ - Focus on earnings vs. cash flow divergences+ - Identify specific red flags and warning signs+ - Discuss valuation relative to fundamental reality+ - Express skepticism toward popular stocks+ - Provide detailed forensic analysis+ - Consider both long and short opportunities++ Return bullish for undervalued companies with clean accounting, bearish for overvalued companies with red flags."""),++ ("human", """Apply forensic accounting analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_einhorn_signal():+ return EinhornSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=EinhornSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_einhorn_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/howard_marks_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/howard_marks_agent.pynew file mode 100644index 000000000..c7fb040ce--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/howard_marks_agent.py@@ -0,0 +1,396 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class MarksSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def howard_marks_agent(state: AgentState, agent_id: str = "howard_marks_agent"):+ """+ Howard Marks: Second-level thinking, risk assessment, cycles+ Focus: Market psychology, risk-adjusted returns, contrarian positioning+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ marks_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Applying second-level thinking")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=7, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "total_assets", "operating_margin",+ "current_assets", "current_liabilities"+ ],+ end_date,+ period="annual",+ limit=7,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Marks' analytical framework+ risk_assessment = analyze_risk_factors(metrics, financial_line_items, market_cap)+ cycle_positioning = analyze_cycle_position(metrics, financial_line_items)+ second_level_thinking = apply_second_level_thinking(metrics, financial_line_items, market_cap)+ market_psychology = analyze_market_psychology_indicators(metrics, market_cap)+ asymmetric_returns = evaluate_asymmetric_opportunities(financial_line_items, market_cap)++ # Marks' risk-adjusted scoring+ total_score = (+ risk_assessment["score"] * 0.3 ++ second_level_thinking["score"] * 0.25 ++ asymmetric_returns["score"] * 0.2 ++ cycle_positioning["score"] * 0.15 ++ market_psychology["score"] * 0.1+ )++ # Marks' nuanced approach+ if total_score >= 7.5:+ signal = "bullish"+ elif total_score <= 4.5:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "risk_assessment": risk_assessment,+ "cycle_positioning": cycle_positioning,+ "second_level_thinking": second_level_thinking,+ "market_psychology": market_psychology,+ "asymmetric_returns": asymmetric_returns+ }++ marks_output = generate_marks_output(ticker, analysis_data, state, agent_id)++ marks_analysis[ticker] = {+ "signal": marks_output.signal,+ "confidence": marks_output.confidence,+ "reasoning": marks_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=marks_output.reasoning)++ message = HumanMessage(content=json.dumps(marks_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(marks_analysis, "Howard Marks Agent")++ state["data"]["analyst_signals"][agent_id] = marks_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_risk_factors(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Marks' comprehensive risk assessment framework"""+ score = 0+ details = []+ risk_factors = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No data for risk analysis"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # Financial leverage risk+ if latest_metrics.debt_to_equity:+ if latest_metrics.debt_to_equity < 0.3:+ score += 2+ details.append(f"Low leverage risk: {latest_metrics.debt_to_equity:.2f} D/E")+ elif latest_metrics.debt_to_equity > 1.0:+ risk_factors.append("High leverage risk")+ score -= 1++ # Earnings quality and sustainability+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings and len(earnings) >= 5:+ earnings_volatility = (max(earnings) - min(earnings)) / max(abs(max(earnings)), abs(min(earnings)))+ if earnings_volatility < 0.5:+ score += 2+ details.append(f"Stable earnings pattern: {earnings_volatility:.2f} volatility")+ else:+ risk_factors.append("High earnings volatility")++ # Liquidity risk+ if latest_metrics.current_ratio:+ if latest_metrics.current_ratio > 1.5:+ score += 1+ details.append(f"Adequate liquidity: {latest_metrics.current_ratio:.1f} current ratio")+ elif latest_metrics.current_ratio < 1.0:+ risk_factors.append("Liquidity concerns")+ score -= 2++ # Business model sustainability+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues and len(revenues) >= 5:+ revenue_trend = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ if revenue_trend >= len(revenues) * 0.7:+ score += 1+ details.append("Sustainable revenue pattern")+ else:+ risk_factors.append("Declining revenue trend")++ # Margin compression risk+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins and len(margins) >= 3:+ margin_trend = margins[0] - margins[-1]+ if margin_trend > 0.02: # 2% margin improvement+ score += 1+ details.append("Improving margin profile")+ elif margin_trend < -0.05: # 5% margin decline+ risk_factors.append("Margin compression risk")+ score -= 1++ if risk_factors:+ details.append(f"Risk factors: {'; '.join(risk_factors)}")++ return {"score": score, "details": "; ".join(details), "risk_factors": risk_factors}+++def analyze_cycle_position(metrics: list, financial_line_items: list) -> dict:+ """Marks' cycle awareness analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No cycle data"}++ # Revenue cycle analysis+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ # Analyze cyclical patterns+ recent_growth = (revenues[0] / revenues[2]) ** (1 / 2) - 1 # 2-year CAGR+ longer_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 # Full period CAGR++ if recent_growth < longer_growth * 0.5: # Significant slowdown+ score += 2 # Good time to buy in cycle+ details.append("Potential cyclical trough - contrarian opportunity")+ elif recent_growth > longer_growth * 2: # Acceleration+ score -= 1 # Potential cycle peak+ details.append("Potential cyclical peak - exercise caution")++ # Margin cycle analysis+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if len(margins) >= 5:+ current_margin = margins[0]+ avg_margin = sum(margins) / len(margins)++ if current_margin < avg_margin * 0.8: # Below average margins+ score += 1+ details.append("Below-average margins suggest cycle opportunity")++ # Return on equity cycle+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if len(roe_vals) >= 5:+ current_roe = roe_vals[0]+ avg_roe = sum(roe_vals) / len(roe_vals)++ if current_roe < avg_roe * 0.7: # Significantly below average+ score += 2+ details.append("Depressed ROE suggests cyclical opportunity")++ return {"score": score, "details": "; ".join(details)}+++def apply_second_level_thinking(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Marks' second-level thinking analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for second-level analysis"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # What is the market NOT seeing?+ # Low valuation with improving fundamentals+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.2:+ # Check if fundamentals are actually improving+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) >= 3 and earnings[0] > earnings[1] > 0:+ score += 3+ details.append("Market pessimism vs improving fundamentals - second-level opportunity")++ # Hidden asset value+ if latest_financial.total_assets and latest_financial.total_debt:+ net_asset_value = latest_financial.total_assets - latest_financial.total_debt+ if net_asset_value > market_cap * 1.3:+ score += 2+ details.append("Hidden asset value not reflected in price")++ # Temporary problems vs permanent impairment+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ recent_decline = revenues[0] < revenues[1]+ historical_growth = revenues[-1] < revenues[-3] # Was growing historically++ if recent_decline and historical_growth:+ score += 1+ details.append("Temporary setback in historically growing business")++ # Quality company at cyclical low+ if latest_metrics.return_on_equity:+ historical_roe = [m.return_on_equity for m in metrics if m.return_on_equity]+ if len(historical_roe) >= 5:+ avg_roe = sum(historical_roe[1:]) / len(historical_roe[1:]) # Exclude current+ if avg_roe > 0.15 and latest_metrics.return_on_equity < avg_roe * 0.6:+ score += 2+ details.append("Quality company at cyclical low ROE")++ return {"score": score, "details": "; ".join(details)}+++def analyze_market_psychology_indicators(metrics: list, market_cap: float) -> dict:+ """Marks' market psychology assessment"""+ score = 0+ details = []++ if not metrics or not market_cap:+ return {"score": 0, "details": "No psychology indicators"}++ latest_metrics = metrics[0]++ # Extreme valuation as psychology indicator+ if latest_metrics.price_to_earnings:+ if latest_metrics.price_to_earnings < 8: # Extreme pessimism+ score += 2+ details.append(f"Market pessimism: {latest_metrics.price_to_earnings:.1f} P/E")+ elif latest_metrics.price_to_earnings > 30: # Extreme optimism+ score -= 2+ details.append(f"Market euphoria: {latest_metrics.price_to_earnings:.1f} P/E")++ # Book value psychology+ if latest_metrics.price_to_book:+ if latest_metrics.price_to_book < 0.8: # Trading below book+ score += 1+ details.append("Market pricing below book value - potential pessimism")+ elif latest_metrics.price_to_book > 3: # High premium+ score -= 1+ details.append("Market paying high premium - potential optimism")++ # Contrarian indicators (simplified)+ # Would typically incorporate sentiment data, analyst revisions, etc.+ if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity > 0.8:+ score += 1 # High debt companies often overlooked+ details.append("High debt company - potential contrarian opportunity")++ return {"score": score, "details": "; ".join(details)}+++def evaluate_asymmetric_opportunities(financial_line_items: list, market_cap: float) -> dict:+ """Marks' asymmetric risk/return evaluation"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No asymmetric data"}++ latest = financial_line_items[0]++ # Downside protection analysis+ total_assets = latest.total_assets if latest.total_assets else 0+ total_debt = latest.total_debt if latest.total_debt else 0++ # Asset floor+ if total_assets > 0:+ net_assets = total_assets - total_debt+ if net_assets > market_cap * 0.8: # Strong asset backing+ score += 2+ details.append("Strong downside protection from asset backing")++ # Upside potential from normalized earnings+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if earnings and len(earnings) >= 3:+ # Use best historical earnings as proxy for potential+ best_earnings = max(earnings)+ current_earnings = earnings[0] if earnings[0] > 0 else earnings[1] if len(earnings) > 1 else 0++ if best_earnings > current_earnings * 1.5: # Significant upside potential+ normalized_value = best_earnings * 15 # 15x multiple+ upside_ratio = normalized_value / market_cap++ if upside_ratio > 2: # 100%+ upside potential+ score += 3+ details.append(f"Significant upside potential: {upside_ratio:.1f}x from normalized earnings")++ # Free cash flow asymmetry+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ fcf_yield = latest.free_cash_flow / market_cap+ if fcf_yield > 0.1: # 10%+ FCF yield+ score += 1+ details.append(f"Attractive FCF yield provides downside support: {fcf_yield:.1%}")++ return {"score": score, "details": "; ".join(details)}+++def generate_marks_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> MarksSignal:+ """Generate Marks-style risk-aware investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Howard Marks' AI agent, applying sophisticated risk-aware value investing:++ 1. Second-level thinking: "What is the market not seeing?"+ 2. Risk assessment: "Risk is the probability of loss, not volatility"+ 3. Cycle awareness: Understand where we are in the cycle+ 4. Market psychology: Recognize euphoria and pessimism+ 5. Asymmetric opportunities: Limited downside, significant upside+ 6. Contrarian positioning: Buy when others are selling+ 7. Risk-adjusted returns: Focus on risk-adjusted, not absolute returns++ Reasoning style:+ - Emphasize risk analysis and downside protection+ - Consider market psychology and sentiment+ - Apply second-level thinking to find hidden opportunities+ - Discuss cyclical positioning and timing+ - Focus on asymmetric risk/reward profiles+ - Express nuanced, probabilistic thinking+ - Acknowledge uncertainty and multiple scenarios++ Return bullish for asymmetric opportunities with limited downside and strong risk-adjusted returns."""),++ ("human", """Apply second-level thinking and risk analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_marks_signal():+ return MarksSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=MarksSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_marks_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/jean_marie_eveillard_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/jean_marie_eveillard_agent.pynew file mode 100644index 000000000..38bd7facf--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/jean_marie_eveillard_agent.py@@ -0,0 +1,407 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class EveillardSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def jean_marie_eveillard_agent(state: AgentState, agent_id: str = "jean_marie_eveillard_agent"):+ """+ Jean-Marie Eveillard: Global value, capital preservation+ Focus: Downside protection, global diversification, conservative value+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ eveillard_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Analyzing capital preservation potential")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=6, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_assets",+ "current_assets", "current_liabilities", "total_debt",+ "shareholders_equity", "cash_and_equivalents"+ ],+ end_date,+ period="annual",+ limit=6,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Eveillard's conservative framework+ capital_preservation = analyze_capital_preservation(financial_line_items, market_cap)+ balance_sheet_quality = analyze_conservative_balance_sheet(financial_line_items)+ valuation_safety = analyze_valuation_margin_of_safety(metrics, financial_line_items, market_cap)+ business_predictability = analyze_business_predictability(financial_line_items)+ downside_protection = calculate_downside_protection(financial_line_items, market_cap)++ # Eveillard's conservative scoring+ total_score = (+ capital_preservation["score"] * 0.3 ++ balance_sheet_quality["score"] * 0.25 ++ downside_protection["score"] * 0.2 ++ valuation_safety["score"] * 0.15 ++ business_predictability["score"] * 0.1+ )++ # Eveillard's very conservative approach+ if total_score >= 8.5:+ signal = "bullish"+ elif total_score <= 5.0:+ signal = "bearish"+ else:+ signal = "neutral" # Often neutral - very selective++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "capital_preservation": capital_preservation,+ "balance_sheet_quality": balance_sheet_quality,+ "valuation_safety": valuation_safety,+ "business_predictability": business_predictability,+ "downside_protection": downside_protection+ }++ eveillard_output = generate_eveillard_output(ticker, analysis_data, state, agent_id)++ eveillard_analysis[ticker] = {+ "signal": eveillard_output.signal,+ "confidence": eveillard_output.confidence,+ "reasoning": eveillard_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=eveillard_output.reasoning)++ message = HumanMessage(content=json.dumps(eveillard_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(eveillard_analysis, "Jean-Marie Eveillard Agent")++ state["data"]["analyst_signals"][agent_id] = eveillard_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_capital_preservation(financial_line_items: list, market_cap: float) -> dict:+ """Eveillard's capital preservation analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No capital preservation data"}++ latest = financial_line_items[0]++ # Strong cash position+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0+ if cash > market_cap * 0.1: # 10%+ cash relative to market cap+ score += 2+ details.append(f"Strong cash position: {(cash / market_cap):.1%} of market cap")++ # Asset backing+ if latest.total_assets and latest.total_debt:+ net_assets = latest.total_assets - latest.total_debt+ if net_assets > market_cap:+ score += 3+ details.append(f"Strong asset backing: {(net_assets / market_cap):.1f}x market cap")+ elif net_assets > market_cap * 0.7:+ score += 2+ details.append(f"Adequate asset backing: {(net_assets / market_cap):.1f}x market cap")++ # Working capital strength+ if latest.current_assets and latest.current_liabilities:+ working_capital = latest.current_assets - latest.current_liabilities+ if working_capital > market_cap * 0.2:+ score += 2+ details.append(f"Strong working capital: {(working_capital / market_cap):.1%} of market cap")++ # Dividend history (capital return)+ # Note: Would need dividend data, using profitability as proxy+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ positive_years = sum(1 for e in earnings if e > 0)+ if positive_years == len(earnings):+ score += 1+ details.append(f"Consistent profitability: {positive_years}/{len(earnings)} years")++ return {"score": score, "details": "; ".join(details)}+++def analyze_conservative_balance_sheet(financial_line_items: list) -> dict:+ """Eveillard's conservative balance sheet requirements"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No balance sheet data"}++ latest = financial_line_items[0]++ # Low debt levels+ if latest.total_debt and latest.shareholders_equity:+ debt_to_equity = latest.total_debt / latest.shareholders_equity+ if debt_to_equity < 0.2: # Very conservative+ score += 3+ details.append(f"Very low debt: {debt_to_equity:.2f} D/E")+ elif debt_to_equity < 0.4:+ score += 2+ details.append(f"Conservative debt: {debt_to_equity:.2f} D/E")+ elif debt_to_equity > 1.0:+ score -= 1+ details.append(f"High debt concern: {debt_to_equity:.2f} D/E")++ # Strong liquidity+ if latest.current_assets and latest.current_liabilities:+ current_ratio = latest.current_assets / latest.current_liabilities+ if current_ratio > 2.0:+ score += 2+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")+ elif current_ratio < 1.2:+ score -= 1+ details.append(f"Liquidity concern: {current_ratio:.1f} current ratio")++ # Asset quality+ if latest.cash_and_equivalents and latest.current_assets:+ cash_ratio = latest.cash_and_equivalents / latest.current_assets+ if cash_ratio > 0.3: # 30%+ cash in current assets+ score += 1+ details.append(f"High-quality liquid assets: {cash_ratio:.1%} cash ratio")++ # Equity base stability+ equity_vals = [item.shareholders_equity for item in financial_line_items if item.shareholders_equity]+ if len(equity_vals) >= 3:+ equity_growth = (equity_vals[0] / equity_vals[-1]) ** (1 / len(equity_vals)) - 1+ if equity_growth > 0.05: # 5%+ equity growth+ score += 1+ details.append(f"Growing equity base: {equity_growth:.1%} CAGR")++ return {"score": score, "details": "; ".join(details)}+++def analyze_valuation_margin_of_safety(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Eveillard's margin of safety requirements"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No valuation data"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # Conservative P/E analysis+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings > 0:+ if latest_metrics.price_to_earnings < 12:+ score += 3+ details.append(f"Conservative P/E: {latest_metrics.price_to_earnings:.1f}")+ elif latest_metrics.price_to_earnings < 18:+ score += 1+ details.append(f"Reasonable P/E: {latest_metrics.price_to_earnings:.1f}")++ # Book value safety+ if latest_metrics.price_to_book:+ if latest_metrics.price_to_book < 1.0:+ score += 3+ details.append(f"Trading below book: {latest_metrics.price_to_book:.2f} P/B")+ elif latest_metrics.price_to_book < 1.5:+ score += 2+ details.append(f"Conservative P/B: {latest_metrics.price_to_book:.2f}")++ # Free cash flow yield+ if latest_financial.free_cash_flow and latest_financial.free_cash_flow > 0:+ fcf_yield = latest_financial.free_cash_flow / market_cap+ if fcf_yield > 0.08: # 8%+ yield+ score += 2+ details.append(f"Attractive FCF yield: {fcf_yield:.1%}")+ elif fcf_yield > 0.05:+ score += 1+ details.append(f"Reasonable FCF yield: {fcf_yield:.1%}")++ # Dividend yield (simplified - would need actual dividend data)+ if latest_financial.net_income and latest_financial.net_income > 0:+ estimated_dividend_yield = (latest_financial.net_income * 0.3) / market_cap # Assume 30% payout+ if estimated_dividend_yield > 0.03: # 3%+ yield+ score += 1+ details.append(f"Potential dividend yield: {estimated_dividend_yield:.1%}")++ return {"score": score, "details": "; ".join(details)}+++def analyze_business_predictability(financial_line_items: list) -> dict:+ """Eveillard's preference for predictable businesses"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No predictability data"}++ # Revenue stability+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ revenue_volatility = (max(revenues) - min(revenues)) / max(revenues)+ if revenue_volatility < 0.2: # Low volatility+ score += 2+ details.append(f"Stable revenue pattern: {revenue_volatility:.1%} volatility")+ elif revenue_volatility > 0.5:+ score -= 1+ details.append(f"High revenue volatility: {revenue_volatility:.1%}")++ # Earnings consistency+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ negative_years = sum(1 for e in earnings if e < 0)+ if negative_years == 0:+ score += 2+ details.append(f"No loss years in {len(earnings)} periods")+ elif negative_years <= 1:+ score += 1+ details.append(f"Only {negative_years} loss year(s)")++ # Cash flow predictability+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if fcf_vals:+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)+ if positive_fcf_years >= len(fcf_vals) * 0.8: # 80%+ positive years+ score += 2+ details.append(f"Consistent cash generation: {positive_fcf_years}/{len(fcf_vals)} years")++ # Business model simplicity (proxy: stable margins)+ margins = []+ for item in financial_line_items:+ if item.net_income and item.revenue and item.revenue > 0:+ margins.append(item.net_income / item.revenue)++ if len(margins) >= 3:+ margin_stability = max(margins) - min(margins)+ if margin_stability < 0.05: # 5% margin range+ score += 1+ details.append(f"Stable profit margins: {margin_stability:.1%} range")++ return {"score": score, "details": "; ".join(details)}+++def calculate_downside_protection(financial_line_items: list, market_cap: float) -> dict:+ """Eveillard's downside protection calculation"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No downside protection data"}++ latest = financial_line_items[0]++ # Liquidation value analysis+ current_assets = latest.current_assets if latest.current_assets else 0+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0++ # Conservative liquidation values+ conservative_assets = cash + (current_assets - cash) * 0.7 # 70% recovery on non-cash+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0+ total_debt = latest.total_debt if latest.total_debt else 0++ net_liquidation_value = conservative_assets - current_liabilities - total_debt++ if net_liquidation_value > 0:+ liquidation_ratio = net_liquidation_value / market_cap+ if liquidation_ratio > 0.7: # 70%+ of market cap+ score += 4+ details.append(f"Excellent liquidation protection: {liquidation_ratio:.1%}")+ elif liquidation_ratio > 0.4:+ score += 2+ details.append(f"Good liquidation protection: {liquidation_ratio:.1%}")+ elif liquidation_ratio > 0.2:+ score += 1+ details.append(f"Some liquidation protection: {liquidation_ratio:.1%}")++ # Tangible book value protection+ if latest.shareholders_equity:+ book_protection = latest.shareholders_equity / market_cap+ if book_protection > 1.0:+ score += 2+ details.append(f"Trading below book value: {book_protection:.1f}x")+ elif book_protection > 0.8:+ score += 1+ details.append(f"Near book value protection: {book_protection:.1f}x")++ # Earnings floor+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ worst_earnings = min(earnings)+ if worst_earnings > 0:+ score += 2+ details.append("No historical losses provide earnings floor")+ elif worst_earnings > -market_cap * 0.03: # Small loss relative to market cap+ score += 1+ details.append("Limited historical downside from worst performance")++ return {"score": score, "details": "; ".join(details)}+++def generate_eveillard_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> EveillardSignal:+ """Generate Eveillard-style capital preservation decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Jean-Marie Eveillard's AI agent, applying global value investing with capital preservation focus:++ 1. Capital preservation: "Return of capital is more important than return on capital"+ 2. Conservative balance sheets: Low debt, strong liquidity, asset backing+ 3. Margin of safety: Buy with significant downside protection+ 4. Predictable businesses: Avoid complexity and volatility+ 5. Global perspective: Consider opportunities worldwide+ 6. Patient approach: Wait for exceptional opportunities+ 7. Risk awareness: Focus on what can go wrong++ Reasoning style:+ - Emphasize downside protection and risk management+ - Focus on balance sheet strength and financial conservatism+ - Discuss predictability and business simplicity+ - Consider liquidation values and asset backing+ - Express conservative skepticism+ - Require substantial margin of safety+ - Acknowledge when standards are not met++ Return bullish only for exceptionally safe investments with strong downside protection and reasonable upside."""),++ ("human", """Apply capital preservation analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_eveillard_signal():+ return EveillardSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=EveillardSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_eveillard_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/joel_greenblatt_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/joel_greenblatt_agent.pynew file mode 100644index 000000000..1f5fe7087--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/joel_greenblatt_agent.py@@ -0,0 +1,355 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class GreenblattSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def joel_greenblatt_agent(state: AgentState, agent_id: str = "joel_greenblatt_agent"):+ """+ Joel Greenblatt: Magic formula (high ROC + low P/E)+ Focus: Systematic value investing, high returns on capital, cheap valuations+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ greenblatt_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Applying Magic Formula criteria")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "total_assets", "current_assets",+ "current_liabilities", "total_debt", "shareholders_equity",+ "operating_income", "interest_expense", "free_cash_flow"+ ],+ end_date,+ period="annual",+ limit=5,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Greenblatt's Magic Formula components+ earnings_yield = calculate_earnings_yield(financial_line_items, market_cap)+ return_on_capital = calculate_return_on_capital(financial_line_items)+ magic_formula_rank = calculate_magic_formula_rank(earnings_yield, return_on_capital)+ business_quality = analyze_business_quality_greenblatt(metrics, financial_line_items)+ special_situations = analyze_special_situations(financial_line_items, market_cap)++ # Greenblatt's systematic scoring+ total_score = (+ magic_formula_rank["score"] * 0.4 ++ earnings_yield["score"] * 0.25 ++ return_on_capital["score"] * 0.25 ++ business_quality["score"] * 0.1+ )++ # Magic Formula approach: systematic and mechanical+ if total_score >= 8.0:+ signal = "bullish"+ elif total_score <= 4.0:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "earnings_yield": earnings_yield,+ "return_on_capital": return_on_capital,+ "magic_formula_rank": magic_formula_rank,+ "business_quality": business_quality,+ "special_situations": special_situations+ }++ greenblatt_output = generate_greenblatt_output(ticker, analysis_data, state, agent_id)++ greenblatt_analysis[ticker] = {+ "signal": greenblatt_output.signal,+ "confidence": greenblatt_output.confidence,+ "reasoning": greenblatt_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=greenblatt_output.reasoning)++ message = HumanMessage(content=json.dumps(greenblatt_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(greenblatt_analysis, "Joel Greenblatt Agent")++ state["data"]["analyst_signals"][agent_id] = greenblatt_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def calculate_earnings_yield(financial_line_items: list, market_cap: float) -> dict:+ """Calculate Greenblatt's earnings yield (EBIT / Enterprise Value)"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for earnings yield", "value": None}++ latest = financial_line_items[0]++ # Calculate EBIT (Operating Income)+ ebit = latest.operating_income if latest.operating_income else 0++ # Calculate Enterprise Value+ total_debt = latest.total_debt if latest.total_debt else 0+ cash = latest.current_assets * 0.2 if latest.current_assets else 0 # Rough cash estimate+ enterprise_value = market_cap + total_debt - cash++ if enterprise_value > 0 and ebit > 0:+ earnings_yield = ebit / enterprise_value++ # Greenblatt's scoring system+ if earnings_yield > 0.15: # 15%+ earnings yield+ score = 10+ details.append(f"Exceptional earnings yield: {earnings_yield:.1%}")+ elif earnings_yield > 0.12:+ score = 8+ details.append(f"Strong earnings yield: {earnings_yield:.1%}")+ elif earnings_yield > 0.09:+ score = 6+ details.append(f"Good earnings yield: {earnings_yield:.1%}")+ elif earnings_yield > 0.06:+ score = 4+ details.append(f"Fair earnings yield: {earnings_yield:.1%}")+ else:+ score = 2+ details.append(f"Low earnings yield: {earnings_yield:.1%}")+ else:+ earnings_yield = 0+ details.append("No positive earnings yield")++ return {+ "score": score,+ "value": earnings_yield,+ "details": "; ".join(details)+ }+++def calculate_return_on_capital(financial_line_items: list) -> dict:+ """Calculate Greenblatt's return on invested capital"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No data for ROIC", "value": None}++ latest = financial_line_items[0]++ # Calculate ROIC = EBIT / (Net Working Capital + Net Fixed Assets)+ ebit = latest.operating_income if latest.operating_income else 0++ # Working Capital+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0+ working_capital = current_assets - current_liabilities++ # Invested Capital (simplified)+ total_assets = latest.total_assets if latest.total_assets else 0+ invested_capital = max(working_capital + (total_assets - current_assets), total_assets * 0.5)++ if invested_capital > 0 and ebit > 0:+ roic = ebit / invested_capital++ # Greenblatt's ROIC scoring+ if roic > 0.25: # 25%+ ROIC+ score = 10+ details.append(f"Exceptional ROIC: {roic:.1%}")+ elif roic > 0.20:+ score = 8+ details.append(f"Strong ROIC: {roic:.1%}")+ elif roic > 0.15:+ score = 6+ details.append(f"Good ROIC: {roic:.1%}")+ elif roic > 0.10:+ score = 4+ details.append(f"Fair ROIC: {roic:.1%}")+ else:+ score = 2+ details.append(f"Low ROIC: {roic:.1%}")+ else:+ roic = 0+ details.append("No positive return on capital")++ return {+ "score": score,+ "value": roic,+ "details": "; ".join(details)+ }+++def calculate_magic_formula_rank(earnings_yield: dict, return_on_capital: dict) -> dict:+ """Combine earnings yield and ROIC for Magic Formula ranking"""+ score = 0+ details = []++ ey_score = earnings_yield.get("score", 0)+ roic_score = return_on_capital.get("score", 0)++ # Magic Formula combines both metrics+ combined_score = (ey_score + roic_score) / 2++ if combined_score >= 9:+ score = 10+ details.append("Magic Formula: Top tier (high ROIC + high earnings yield)")+ elif combined_score >= 7:+ score = 8+ details.append("Magic Formula: Strong candidate")+ elif combined_score >= 5:+ score = 6+ details.append("Magic Formula: Decent candidate")+ else:+ score = 3+ details.append("Magic Formula: Below average")++ # Bonus for exceptional combination+ ey_val = earnings_yield.get("value", 0)+ roic_val = return_on_capital.get("value", 0)++ if ey_val > 0.12 and roic_val > 0.20:+ score = min(10, score + 2)+ details.append("Exceptional Magic Formula combination")++ return {+ "score": score,+ "combined_score": combined_score,+ "details": "; ".join(details)+ }+++def analyze_business_quality_greenblatt(metrics: list, financial_line_items: list) -> dict:+ """Greenblatt's additional quality checks beyond Magic Formula"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No data for quality analysis"}++ # Consistent profitability+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ positive_years = sum(1 for e in earnings if e > 0)+ if positive_years == len(earnings):+ score += 3+ details.append(f"Consistent profitability: {positive_years}/{len(earnings)} years")++ # Revenue growth+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ if revenue_growth > 0.05:+ score += 2+ details.append(f"Revenue growth: {revenue_growth:.1%} CAGR")++ # Free cash flow generation+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if fcf_vals:+ positive_fcf = sum(1 for fcf in fcf_vals if fcf > 0)+ if positive_fcf >= len(fcf_vals) * 0.8:+ score += 2+ details.append(f"Strong FCF generation: {positive_fcf}/{len(fcf_vals)} years")++ return {"score": score, "details": "; ".join(details)}+++def analyze_special_situations(financial_line_items: list, market_cap: float) -> dict:+ """Greenblatt's special situation analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No special situation data"}++ latest = financial_line_items[0]++ # Net cash position (special situation value)+ current_assets = latest.current_assets if latest.current_assets else 0+ total_debt = latest.total_debt if latest.total_debt else 0++ if current_assets > total_debt * 1.5:+ net_cash = current_assets - total_debt+ if net_cash > market_cap * 0.2:+ score += 2+ details.append(f"Net cash opportunity: {(net_cash / market_cap):.1%} of market cap")++ # Asset value relative to market cap+ if latest.total_assets:+ asset_ratio = latest.total_assets / market_cap+ if asset_ratio > 1.5:+ score += 1+ details.append(f"Asset value: {asset_ratio:.1f}x market cap")++ return {"score": score, "details": "; ".join(details)}+++def generate_greenblatt_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> GreenblattSignal:+ """Generate Greenblatt-style Magic Formula investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Joel Greenblatt's AI agent, implementing the Magic Formula strategy:++ 1. Magic Formula: High return on invested capital + High earnings yield+ 2. Systematic approach: Remove emotion, follow the formula mechanically+ 3. Value investing: Buy good businesses at cheap prices+ 4. Special situations: Spinoffs, mergers, bankruptcies for extra returns+ 5. Long-term perspective: Hold for 2-3 years minimum+ 6. Diversification: Own 20-30 positions to reduce risk+ 7. Patience: Trust the process even during underperformance++ Reasoning style:+ - Emphasize quantitative Magic Formula metrics+ - Focus on ROIC and earnings yield primarily+ - Discuss systematic, mechanical approach+ - Reference statistical advantages of the formula+ - Consider special situations as bonus opportunities+ - Express confidence in proven methodology+ - Acknowledge short-term volatility but long-term outperformance++ Return bullish for high Magic Formula scores (top quartile companies)."""),++ ("human", """Apply Magic Formula analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_greenblatt_signal():+ return GreenblattSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=GreenblattSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_greenblatt_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/marty_whitman_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/marty_whitman_agent.pynew file mode 100644index 000000000..9b4d307d4--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/marty_whitman_agent.py@@ -0,0 +1,445 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class WhitmanSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def marty_whitman_agent(state: AgentState, agent_id: str = "marty_whitman_agent"):+ """+ Marty Whitman: Safe & cheap, asset-based investing+ Focus: Balance sheet analysis, asset values, financial safety+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ whitman_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Analyzing safe & cheap criteria")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "total_assets", "current_assets",+ "current_liabilities", "total_debt", "shareholders_equity",+ "cash_and_equivalents", "accounts_receivable", "inventory",+ "property_plant_equipment", "goodwill"+ ],+ end_date,+ period="annual",+ limit=5,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Whitman's asset-focused framework+ asset_value_analysis = analyze_asset_values(financial_line_items, market_cap)+ financial_safety = analyze_financial_safety(financial_line_items)+ balance_sheet_strength = analyze_balance_sheet_quality(financial_line_items)+ safe_and_cheap = evaluate_safe_and_cheap_criteria(metrics, financial_line_items, market_cap)+ credit_worthiness = analyze_credit_worthiness(financial_line_items)++ # Whitman's asset-based scoring+ total_score = (+ asset_value_analysis["score"] * 0.3 ++ financial_safety["score"] * 0.25 ++ safe_and_cheap["score"] * 0.2 ++ balance_sheet_strength["score"] * 0.15 ++ credit_worthiness["score"] * 0.1+ )++ # Whitman's safety-first approach+ if total_score >= 8.0:+ signal = "bullish"+ elif total_score <= 4.5:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "asset_value_analysis": asset_value_analysis,+ "financial_safety": financial_safety,+ "balance_sheet_strength": balance_sheet_strength,+ "safe_and_cheap": safe_and_cheap,+ "credit_worthiness": credit_worthiness+ }++ whitman_output = generate_whitman_output(ticker, analysis_data, state, agent_id)++ whitman_analysis[ticker] = {+ "signal": whitman_output.signal,+ "confidence": whitman_output.confidence,+ "reasoning": whitman_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=whitman_output.reasoning)++ message = HumanMessage(content=json.dumps(whitman_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(whitman_analysis, "Marty Whitman Agent")++ state["data"]["analyst_signals"][agent_id] = whitman_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_asset_values(financial_line_items: list, market_cap: float) -> dict:+ """Whitman's asset-based valuation analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No asset data"}++ latest = financial_line_items[0]++ # Tangible asset value+ total_assets = latest.total_assets if latest.total_assets else 0+ goodwill = latest.goodwill if latest.goodwill else 0+ tangible_assets = total_assets - goodwill+ total_debt = latest.total_debt if latest.total_debt else 0++ if tangible_assets > 0:+ net_tangible_assets = tangible_assets - total_debt+ if net_tangible_assets > market_cap:+ score += 4+ details.append(f"Trading below tangible assets: {(net_tangible_assets / market_cap):.1f}x")+ elif net_tangible_assets > market_cap * 0.8:+ score += 3+ details.append(f"Strong tangible asset backing: {(net_tangible_assets / market_cap):.1f}x")+ elif net_tangible_assets > market_cap * 0.6:+ score += 2+ details.append(f"Adequate tangible asset backing: {(net_tangible_assets / market_cap):.1f}x")++ # Working capital value+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0+ working_capital = current_assets - current_liabilities++ if working_capital > 0:+ wc_ratio = working_capital / market_cap+ if wc_ratio > 0.5:+ score += 2+ details.append(f"Strong working capital: {wc_ratio:.1%} of market cap")+ elif wc_ratio > 0.2:+ score += 1+ details.append(f"Positive working capital: {wc_ratio:.1%} of market cap")++ # Book value relationship+ shareholders_equity = latest.shareholders_equity if latest.shareholders_equity else 0+ if shareholders_equity > 0:+ price_to_book = market_cap / shareholders_equity+ if price_to_book < 0.8:+ score += 2+ details.append(f"Trading below 80% of book: {price_to_book:.2f} P/B")+ elif price_to_book < 1.2:+ score += 1+ details.append(f"Reasonable P/B ratio: {price_to_book:.2f}")++ return {"score": score, "details": "; ".join(details)}+++def analyze_financial_safety(financial_line_items: list) -> dict:+ """Whitman's financial safety analysis"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No safety data"}++ latest = financial_line_items[0]++ # Debt safety+ total_debt = latest.total_debt if latest.total_debt else 0+ shareholders_equity = latest.shareholders_equity if latest.shareholders_equity else 0++ if shareholders_equity > 0:+ debt_to_equity = total_debt / shareholders_equity+ if debt_to_equity < 0.3:+ score += 3+ details.append(f"Very safe debt level: {debt_to_equity:.2f} D/E")+ elif debt_to_equity < 0.6:+ score += 2+ details.append(f"Safe debt level: {debt_to_equity:.2f} D/E")+ elif debt_to_equity > 1.5:+ score -= 1+ details.append(f"High debt concern: {debt_to_equity:.2f} D/E")++ # Liquidity safety+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0++ if current_liabilities > 0:+ current_ratio = current_assets / current_liabilities+ if current_ratio > 2.0:+ score += 2+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")+ elif current_ratio > 1.5:+ score += 1+ details.append(f"Adequate liquidity: {current_ratio:.1f} current ratio")+ elif current_ratio < 1.0:+ score -= 2+ details.append(f"Liquidity concern: {current_ratio:.1f} current ratio")++ # Cash position+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0+ total_assets = latest.total_assets if latest.total_assets else 0++ if total_assets > 0:+ cash_ratio = cash / total_assets+ if cash_ratio > 0.15: # 15%+ cash+ score += 2+ details.append(f"Strong cash position: {cash_ratio:.1%} of assets")+ elif cash_ratio > 0.05:+ score += 1+ details.append(f"Reasonable cash position: {cash_ratio:.1%} of assets")++ return {"score": score, "details": "; ".join(details)}+++def analyze_balance_sheet_quality(financial_line_items: list) -> dict:+ """Whitman's balance sheet quality assessment"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No balance sheet data"}++ latest = financial_line_items[0]++ # Asset quality analysis+ current_assets = latest.current_assets if latest.current_assets else 0+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0+ receivables = latest.accounts_receivable if latest.accounts_receivable else 0+ inventory = latest.inventory if latest.inventory else 0++ # High-quality current assets+ if current_assets > 0:+ quality_assets = cash + receivables # Cash + receivables are higher quality+ quality_ratio = quality_assets / current_assets+ if quality_ratio > 0.7:+ score += 2+ details.append(f"High-quality current assets: {quality_ratio:.1%} cash+receivables")+ elif quality_ratio > 0.5:+ score += 1+ details.append(f"Reasonable asset quality: {quality_ratio:.1%} cash+receivables")++ # Fixed asset efficiency+ ppe = latest.property_plant_equipment if latest.property_plant_equipment else 0+ revenue = latest.revenue if latest.revenue else 0++ if ppe > 0 and revenue > 0:+ asset_turnover = revenue / ppe+ if asset_turnover > 3.0: # Efficient use of fixed assets+ score += 1+ details.append(f"Efficient fixed asset use: {asset_turnover:.1f}x turnover")++ # Goodwill concerns+ goodwill = latest.goodwill if latest.goodwill else 0+ total_assets = latest.total_assets if latest.total_assets else 0++ if total_assets > 0:+ goodwill_ratio = goodwill / total_assets+ if goodwill_ratio < 0.1: # Low goodwill+ score += 2+ details.append(f"Low goodwill risk: {goodwill_ratio:.1%} of assets")+ elif goodwill_ratio > 0.3: # High goodwill+ score -= 1+ details.append(f"High goodwill concern: {goodwill_ratio:.1%} of assets")++ # Equity growth+ equity_vals = [item.shareholders_equity for item in financial_line_items if item.shareholders_equity]+ if len(equity_vals) >= 3:+ equity_growth = (equity_vals[0] / equity_vals[-1]) ** (1 / len(equity_vals)) - 1+ if equity_growth > 0.08: # 8%+ equity growth+ score += 1+ details.append(f"Growing equity base: {equity_growth:.1%} CAGR")++ return {"score": score, "details": "; ".join(details)}+++def evaluate_safe_and_cheap_criteria(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Whitman's 'safe and cheap' evaluation"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No safe & cheap data"}++ latest_metrics = metrics[0]+ latest_financial = financial_line_items[0]++ # "Safe" criteria+ safety_score = 0++ # Low debt+ if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity < 0.5:+ safety_score += 1+ details.append(f"Safe debt level: {latest_metrics.debt_to_equity:.2f} D/E")++ # Strong balance sheet+ if latest_metrics.current_ratio and latest_metrics.current_ratio > 1.5:+ safety_score += 1+ details.append(f"Safe liquidity: {latest_metrics.current_ratio:.1f} current ratio")++ # Asset backing+ if latest_financial.total_assets and latest_financial.total_debt:+ asset_coverage = latest_financial.total_assets / latest_financial.total_debt+ if asset_coverage > 3.0:+ safety_score += 1+ details.append(f"Safe asset coverage: {asset_coverage:.1f}x")++ # "Cheap" criteria+ cheap_score = 0++ # Low P/B+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.5:+ cheap_score += 1+ details.append(f"Cheap P/B: {latest_metrics.price_to_book:.2f}")++ # Low P/E+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 15:+ cheap_score += 1+ details.append(f"Cheap P/E: {latest_metrics.price_to_earnings:.1f}")++ # Asset value+ if latest_financial.shareholders_equity and latest_financial.shareholders_equity > market_cap:+ cheap_score += 1+ details.append("Cheap relative to book value")++ # Combined safe & cheap score+ if safety_score >= 2 and cheap_score >= 2:+ score = 10 # Perfect safe & cheap+ details.append("Meets Whitman's safe & cheap criteria")+ elif safety_score >= 2:+ score = 6 # Safe but not cheap+ details.append("Safe but not particularly cheap")+ elif cheap_score >= 2:+ score = 4 # Cheap but not safe+ details.append("Cheap but safety concerns")+ else:+ score = 2 # Neither safe nor cheap+ details.append("Does not meet safe & cheap criteria")++ return {"score": score, "details": "; ".join(details)}+++def analyze_credit_worthiness(financial_line_items: list) -> dict:+ """Whitman's credit analysis approach"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No credit data"}++ latest = financial_line_items[0]++ # Interest coverage capability+ operating_income = latest.net_income if latest.net_income else 0 # Simplified+ total_debt = latest.total_debt if latest.total_debt else 0++ if total_debt > 0:+ # Estimate interest expense at 5%+ estimated_interest = total_debt * 0.05+ if operating_income > estimated_interest * 3: # 3x coverage+ score += 2+ details.append("Strong estimated interest coverage")+ elif operating_income > estimated_interest:+ score += 1+ details.append("Adequate estimated interest coverage")+ elif total_debt == 0:+ score += 3+ details.append("No debt - excellent credit position")++ # Cash flow coverage+ free_cash_flow = latest.free_cash_flow if latest.free_cash_flow else 0+ if free_cash_flow > 0 and total_debt > 0:+ debt_paydown_years = total_debt / free_cash_flow+ if debt_paydown_years < 5:+ score += 2+ details.append(f"Can pay down debt in {debt_paydown_years:.1f} years")+ elif debt_paydown_years < 10:+ score += 1+ details.append(f"Reasonable debt paydown period: {debt_paydown_years:.1f} years")++ # Working capital strength+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0++ if current_liabilities > 0:+ working_capital_ratio = current_assets / current_liabilities+ if working_capital_ratio > 2.0:+ score += 1+ details.append(f"Strong working capital for credit: {working_capital_ratio:.1f}x")++ return {"score": score, "details": "; ".join(details)}+++def generate_whitman_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> WhitmanSignal:+ """Generate Whitman-style safe & cheap investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Marty Whitman's AI agent, applying safe & cheap asset-based investing:++ 1. Safe & Cheap: Both criteria must be met - financial safety AND attractive valuation+ 2. Asset-based analysis: Focus on balance sheet values and asset backing+ 3. Financial safety: Low debt, strong liquidity, conservative capital structure+ 4. Credit analysis: Evaluate creditworthiness and financial flexibility+ 5. Tangible value: Prefer tangible assets over intangibles and goodwill+ 6. Balance sheet focus: Income statement is secondary to balance sheet strength+ 7. Risk management: Downside protection through asset values++ Reasoning style:+ - Emphasize balance sheet analysis and asset values+ - Focus on financial safety and conservative capital structure+ - Discuss tangible asset backing and liquidation values+ - Consider credit worthiness and debt capacity+ - Apply rigorous safe & cheap criteria+ - Express preference for asset-rich, debt-light companies+ - Acknowledge when safety or cheapness criteria are not met++ Return bullish only for companies that are both financially safe AND attractively cheap."""),++ ("human", """Apply safe & cheap asset-based analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_whitman_signal():+ return WhitmanSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=WhitmanSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_whitman_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/seth_klarman_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/seth_klarman_agent.pynew file mode 100644index 000000000..a13d44984--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/seth_klarman_agent.py@@ -0,0 +1,395 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class KlarmanSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def seth_klarman_agent(state: AgentState, agent_id: str = "seth_klarman_agent"):+ """+ Seth Klarman: Absolute return, risk-first approach, contrarian+ Focus: Capital preservation, asymmetric risk/reward, distressed opportunities+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ klarman_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Analyzing downside protection")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "total_assets", "current_assets",+ "current_liabilities", "total_debt", "cash_and_equivalents",+ "shareholders_equity", "free_cash_flow", "operating_income"+ ],+ end_date,+ period="annual",+ limit=5,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Klarman's risk-first analyses+ downside_protection = analyze_downside_protection(financial_line_items, market_cap)+ asymmetric_opportunity = analyze_asymmetric_risk_reward(metrics, financial_line_items, market_cap)+ contrarian_indicators = analyze_contrarian_opportunity(metrics, financial_line_items)+ balance_sheet_strength = analyze_balance_sheet_fortress(financial_line_items)+ margin_of_safety = calculate_klarman_margin_of_safety(financial_line_items, market_cap)++ # Klarman's conservative scoring (risk-adjusted)+ total_score = (+ downside_protection["score"] * 0.3 ++ balance_sheet_strength["score"] * 0.25 ++ margin_of_safety["score"] * 0.2 ++ asymmetric_opportunity["score"] * 0.15 ++ contrarian_indicators["score"] * 0.1+ )++ # Klarman's high bar for investment+ if total_score >= 8.0:+ signal = "bullish"+ elif total_score <= 4.0:+ signal = "bearish"+ else:+ signal = "neutral" # Most opportunities don't meet Klarman's standards++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "downside_protection": downside_protection,+ "asymmetric_opportunity": asymmetric_opportunity,+ "contrarian_indicators": contrarian_indicators,+ "balance_sheet_strength": balance_sheet_strength,+ "margin_of_safety": margin_of_safety+ }++ klarman_output = generate_klarman_output(ticker, analysis_data, state, agent_id)++ klarman_analysis[ticker] = {+ "signal": klarman_output.signal,+ "confidence": klarman_output.confidence,+ "reasoning": klarman_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=klarman_output.reasoning)++ message = HumanMessage(content=json.dumps(klarman_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(klarman_analysis, "Seth Klarman Agent")++ state["data"]["analyst_signals"][agent_id] = klarman_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_downside_protection(financial_line_items: list, market_cap: float) -> dict:+ """Klarman's obsession with downside protection"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for downside analysis"}++ latest = financial_line_items[0]++ # Asset coverage+ total_assets = latest.total_assets if latest.total_assets else 0+ total_debt = latest.total_debt if latest.total_debt else 0++ if total_assets > 0:+ asset_coverage = total_assets / market_cap+ if asset_coverage > 2.0:+ score += 3+ details.append(f"Strong asset coverage: {asset_coverage:.1f}x market cap")+ elif asset_coverage > 1.5:+ score += 2+ details.append(f"Adequate asset coverage: {asset_coverage:.1f}x market cap")++ # Liquidation value protection+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0++ # Conservative liquidation values+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0+ liquidation_value = cash + (current_assets - cash) * 0.7 # 70% recovery on non-cash assets+ net_liquidation = liquidation_value - current_liabilities - total_debt++ if net_liquidation > 0:+ liquidation_ratio = net_liquidation / market_cap+ if liquidation_ratio > 0.5:+ score += 4+ details.append(f"Exceptional liquidation protection: {liquidation_ratio:.1%}")+ elif liquidation_ratio > 0.2:+ score += 2+ details.append(f"Good liquidation value: {liquidation_ratio:.1%}")++ # Earnings floor+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ worst_earnings = min(earnings)+ if worst_earnings > 0:+ score += 2+ details.append("No losses in available periods")+ elif worst_earnings > -market_cap * 0.05: # Small losses relative to market cap+ score += 1+ details.append("Limited downside from worst historical performance")++ return {"score": score, "details": "; ".join(details)}+++def analyze_asymmetric_risk_reward(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Klarman's focus on asymmetric opportunities"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for asymmetric analysis"}++ latest = financial_line_items[0]++ # Upside potential vs downside risk+ # Calculate normalized earnings power+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if earnings:+ avg_earnings = sum(earnings) / len(earnings)+ normalized_pe = market_cap / avg_earnings if avg_earnings > 0 else 0++ # If trading at low multiple with asset protection, asymmetric opportunity+ if normalized_pe < 12 and latest.total_assets and latest.total_assets > market_cap:+ score += 3+ details.append(f"Asymmetric setup: {normalized_pe:.1f} P/E with asset backing")++ # Free cash flow yield vs risk+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ fcf_yield = latest.free_cash_flow / market_cap+ debt_ratio = (latest.total_debt / latest.total_assets) if latest.total_assets else 1++ # High FCF yield with low debt = good risk/reward+ if fcf_yield > 0.1 and debt_ratio < 0.3:+ score += 2+ details.append(f"Strong FCF yield ({fcf_yield:.1%}) with low debt")++ # Catalyst potential (simplified)+ # Look for companies with improving trends that market hasn't recognized+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ recent_growth = (revenues[0] / revenues[1]) - 1+ if recent_growth > 0.1: # 10%+ recent growth+ score += 1+ details.append(f"Potential catalyst: {recent_growth:.1%} recent revenue growth")++ return {"score": score, "details": "; ".join(details)}+++def analyze_contrarian_opportunity(metrics: list, financial_line_items: list) -> dict:+ """Klarman's contrarian approach to investing"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No data for contrarian analysis"}++ latest_metrics = metrics[0]++ # Low valuation multiples (contrarian indicator)+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.0:+ score += 2+ details.append(f"Contrarian P/B: {latest_metrics.price_to_book:.2f}")++ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 10:+ score += 2+ details.append(f"Contrarian P/E: {latest_metrics.price_to_earnings:.1f}")++ # Temporary earnings depression+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) >= 3:+ recent_earnings = earnings[0]+ historical_avg = sum(earnings[1:]) / len(earnings[1:])++ if recent_earnings < historical_avg * 0.7 and recent_earnings > 0:+ score += 2+ details.append("Potential temporary earnings depression")++ # Industry or company-specific distress signals+ # (Would typically require more external data, simplified here)+ if latest_metrics.current_ratio and latest_metrics.current_ratio < 1.2:+ # Low current ratio might indicate distress (opportunity for contrarian)+ score += 1+ details.append("Potential distress situation for contrarian investment")++ return {"score": score, "details": "; ".join(details)}+++def analyze_balance_sheet_fortress(financial_line_items: list) -> dict:+ """Klarman's requirement for fortress balance sheets"""+ score = 0+ details = []++ if not financial_line_items:+ return {"score": 0, "details": "No balance sheet data"}++ latest = financial_line_items[0]++ # Cash and liquidity+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0+ current_assets = latest.current_assets if latest.current_assets else 0+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0++ if current_liabilities > 0:+ current_ratio = current_assets / current_liabilities+ if current_ratio > 2.0:+ score += 2+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")++ # Debt levels+ total_debt = latest.total_debt if latest.total_debt else 0+ shareholders_equity = latest.shareholders_equity if latest.shareholders_equity else 0++ if shareholders_equity > 0:+ debt_to_equity = total_debt / shareholders_equity+ if debt_to_equity < 0.3:+ score += 3+ details.append(f"Conservative debt: {debt_to_equity:.2f} D/E")+ elif debt_to_equity < 0.5:+ score += 1+ details.append(f"Moderate debt: {debt_to_equity:.2f} D/E")++ # Working capital strength+ working_capital = current_assets - current_liabilities+ if working_capital > 0 and latest.total_assets:+ wc_ratio = working_capital / latest.total_assets+ if wc_ratio > 0.2:+ score += 2+ details.append(f"Strong working capital: {wc_ratio:.1%} of assets")++ # Interest coverage+ if latest.operating_income and total_debt > 0:+ # Simplified interest coverage (assume 5% interest rate)+ estimated_interest = total_debt * 0.05+ if latest.operating_income > estimated_interest * 5:+ score += 2+ details.append("Strong interest coverage capability")++ return {"score": score, "details": "; ".join(details)}+++def calculate_klarman_margin_of_safety(financial_line_items: list, market_cap: float) -> dict:+ """Klarman's conservative margin of safety calculation"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for margin of safety"}++ latest = financial_line_items[0]++ # Conservative asset-based valuation+ total_assets = latest.total_assets if latest.total_assets else 0+ total_debt = latest.total_debt if latest.total_debt else 0++ # Apply conservative haircuts to assets+ conservative_asset_value = total_assets * 0.7 # 30% haircut+ net_asset_value = conservative_asset_value - total_debt++ if net_asset_value > 0:+ asset_margin = (net_asset_value - market_cap) / market_cap+ if asset_margin > 0.5:+ score += 3+ details.append(f"Excellent asset margin of safety: {asset_margin:.1%}")+ elif asset_margin > 0.2:+ score += 2+ details.append(f"Good asset margin of safety: {asset_margin:.1%}")++ # Conservative earnings-based valuation+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]+ if earnings:+ # Use conservative multiple (10x) on average earnings+ avg_earnings = sum(earnings) / len(earnings)+ conservative_earnings_value = avg_earnings * 10++ earnings_margin = (conservative_earnings_value - market_cap) / market_cap+ if earnings_margin > 0.3:+ score += 2+ details.append(f"Earnings margin of safety: {earnings_margin:.1%}")++ # Free cash flow margin of safety+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ # Conservative 12x FCF multiple+ fcf_value = latest.free_cash_flow * 12+ fcf_margin = (fcf_value - market_cap) / market_cap++ if fcf_margin > 0.25:+ score += 2+ details.append(f"FCF margin of safety: {fcf_margin:.1%}")++ return {"score": score, "details": "; ".join(details)}+++def generate_klarman_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> KlarmanSignal:+ """Generate Klarman-style risk-first investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Seth Klarman's AI agent, following absolute return value investing principles:++ 1. Risk first: "Return OF capital is more important than return ON capital"+ 2. Margin of safety: Buy with significant downside protection+ 3. Contrarian approach: Buy when others are selling+ 4. Asymmetric risk/reward: Limited downside, substantial upside+ 5. Balance sheet fortress: Strong financial position required+ 6. Patient opportunism: Wait for exceptional opportunities+ 7. Absolute return focus: Preserve capital above all else++ Reasoning style:+ - Emphasize downside protection and risk analysis first+ - Focus on balance sheet strength and asset coverage+ - Discuss margin of safety quantitatively+ - Consider contrarian and distressed opportunities+ - Express skepticism and conservatism+ - Require exceptional risk/reward ratios+ - Acknowledge when opportunities don't meet standards++ Return bullish only for exceptional risk/reward opportunities with substantial downside protection."""),++ ("human", """Apply risk-first value analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_klarman_signal():+ return KlarmanSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=KlarmanSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_klarman_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/warren_buffett_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/warren_buffett_agent.pynew file mode 100644index 000000000..98dbd4b62--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/warren_buffett_agent.py@@ -0,0 +1,323 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class BuffettSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+++def warren_buffett_agent(state: AgentState, agent_id: str = "warren_buffett_agent"):+ """+ Warren Buffett: Buy wonderful companies at fair prices, hold forever+ Focus: Economic moats, predictable earnings, strong management, reasonable price+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ buffett_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Analyzing wonderful business qualities")+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)++ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "retained_earnings", "operating_margin",+ "research_and_development", "outstanding_shares"+ ],+ end_date,+ period="annual",+ limit=10,+ api_key=api_key,+ )++ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Buffett's key analyses+ moat_analysis = analyze_economic_moat(metrics, financial_line_items)+ earnings_predictability = analyze_earnings_predictability(financial_line_items)+ financial_strength = analyze_financial_fortress(metrics, financial_line_items)+ management_quality = analyze_capital_allocation(financial_line_items)+ valuation_analysis = buffett_valuation(financial_line_items, market_cap)++ total_score = (+ moat_analysis["score"] * 0.3 ++ earnings_predictability["score"] * 0.25 ++ financial_strength["score"] * 0.2 ++ management_quality["score"] * 0.15 ++ valuation_analysis["score"] * 0.1+ )++ # Buffett's binary approach: Wonderful business or pass+ if total_score >= 8.0:+ signal = "bullish"+ elif total_score <= 4.0:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "moat_analysis": moat_analysis,+ "earnings_predictability": earnings_predictability,+ "financial_strength": financial_strength,+ "management_quality": management_quality,+ "valuation_analysis": valuation_analysis+ }++ buffett_output = generate_buffett_output(ticker, analysis_data, state, agent_id)++ buffett_analysis[ticker] = {+ "signal": buffett_output.signal,+ "confidence": buffett_output.confidence,+ "reasoning": buffett_output.reasoning+ }++ progress.update_status(agent_id, ticker, "Done", analysis=buffett_output.reasoning)++ message = HumanMessage(content=json.dumps(buffett_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(buffett_analysis, "Warren Buffett Agent")++ state["data"]["analyst_signals"][agent_id] = buffett_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def analyze_economic_moat(metrics: list, financial_line_items: list) -> dict:+ """Buffett's moat analysis: High ROE, consistent margins, pricing power"""+ score = 0+ details = []++ if not metrics:+ return {"score": 0, "details": "No metrics data"}++ # High and consistent ROE (15%+ for 7+ years)+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if roe_vals:+ high_roe_count = sum(1 for roe in roe_vals if roe > 0.15)+ if high_roe_count >= 7:+ score += 3+ details.append(f"Exceptional ROE consistency: {high_roe_count}/10 years >15%")+ elif high_roe_count >= 5:+ score += 2+ details.append(f"Good ROE consistency: {high_roe_count}/10 years >15%")++ # Consistent operating margins (pricing power)+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins and len(margins) >= 5:+ margin_stability = max(margins) - min(margins)+ avg_margin = sum(margins) / len(margins)+ if margin_stability < 0.05 and avg_margin > 0.15:+ score += 2+ details.append(f"Stable high margins: {avg_margin:.1%} avg, {margin_stability:.1%} volatility")++ # Revenue growth without excessive capex+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ if 0.05 <= cagr <= 0.15: # Buffett likes steady, not explosive growth+ score += 2+ details.append(f"Steady revenue growth: {cagr:.1%} CAGR")++ return {"score": score, "details": "; ".join(details)}+++def analyze_earnings_predictability(financial_line_items: list) -> dict:+ """Buffett values predictable, growing earnings"""+ score = 0+ details = []++ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) < 5:+ return {"score": 0, "details": "Insufficient earnings history"}++ # Positive earnings in 8+ of last 10 years+ positive_years = sum(1 for e in earnings if e > 0)+ if positive_years >= 8:+ score += 3+ details.append(f"Consistent profitability: {positive_years}/10 years positive")++ # Earnings growth trend+ if len(earnings) >= 10:+ recent_avg = sum(earnings[:5]) / 5+ older_avg = sum(earnings[5:10]) / 5+ if recent_avg > older_avg * 1.5:+ score += 2+ details.append("Strong earnings growth trend over decade")++ # Low earnings volatility+ if earnings:+ volatility = (max(earnings) - min(earnings)) / max(abs(max(earnings)), abs(min(earnings)))+ if volatility < 1.0: # Relatively stable+ score += 2+ details.append(f"Low earnings volatility: {volatility:.2f}")++ return {"score": score, "details": "; ".join(details)}+++def analyze_financial_fortress(metrics: list, financial_line_items: list) -> dict:+ """Buffett's fortress balance sheet requirements"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No financial data"}++ latest = metrics[0]++ # Low debt-to-equity (financial safety)+ if latest.debt_to_equity and latest.debt_to_equity < 0.3:+ score += 3+ details.append(f"Conservative debt: {latest.debt_to_equity:.2f} D/E")++ # High current ratio (liquidity)+ if latest.current_ratio and latest.current_ratio > 1.5:+ score += 2+ details.append(f"Strong liquidity: {latest.current_ratio:.1f} current ratio")++ # Positive free cash flow consistency+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if fcf_vals:+ positive_fcf = sum(1 for fcf in fcf_vals if fcf > 0)+ if positive_fcf >= 8:+ score += 2+ details.append(f"Reliable cash generation: {positive_fcf}/10 years positive FCF")++ return {"score": score, "details": "; ".join(details)}+++def analyze_capital_allocation(financial_line_items: list) -> dict:+ """Buffett values management that allocates capital wisely"""+ score = 0+ details = []++ # Share buybacks when appropriate (declining share count)+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]+ if len(shares) >= 5:+ share_reduction = (shares[-1] - shares[0]) / shares[-1]+ if share_reduction > 0.1: # 10%+ reduction+ score += 2+ details.append(f"Shareholder-friendly buybacks: {share_reduction:.1%} share reduction")++ # Retained earnings growth (reinvestment effectiveness)+ retained_earnings = [item.retained_earnings for item in financial_line_items if item.retained_earnings]+ if len(retained_earnings) >= 5:+ re_growth = (retained_earnings[0] - retained_earnings[-1]) / abs(retained_earnings[-1])+ if re_growth > 0.5: # 50%+ growth in retained earnings+ score += 2+ details.append(f"Effective reinvestment: {re_growth:.1%} retained earnings growth")++ # Reasonable R&D (not excessive, not zero)+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if rd_vals and revenues:+ rd_intensity = sum(rd_vals) / sum(revenues)+ if 0.02 <= rd_intensity <= 0.08: # 2-8% of revenue+ score += 1+ details.append(f"Balanced R&D spend: {rd_intensity:.1%} of revenue")++ return {"score": score, "details": "; ".join(details)}+++def buffett_valuation(financial_line_items: list, market_cap: float) -> dict:+ """Buffett's 'fair price for wonderful business' approach"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No valuation data"}++ latest = financial_line_items[0]+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]++ if not earnings:+ return {"score": 0, "details": "No positive earnings for valuation"}++ # Owner earnings approximation (FCF)+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ fcf_yield = latest.free_cash_flow / market_cap+ if fcf_yield > 0.08: # 8%+ FCF yield+ score += 3+ details.append(f"Attractive FCF yield: {fcf_yield:.1%}")+ elif fcf_yield > 0.05:+ score += 1+ details.append(f"Reasonable FCF yield: {fcf_yield:.1%}")++ # PE ratio (Buffett likes reasonable multiples)+ if latest.net_income and latest.net_income > 0:+ pe_ratio = market_cap / latest.net_income+ if pe_ratio < 15:+ score += 2+ details.append(f"Reasonable valuation: {pe_ratio:.1f} P/E")+ elif pe_ratio < 25:+ score += 1+ details.append(f"Fair valuation: {pe_ratio:.1f} P/E")++ return {"score": score, "details": "; ".join(details)}+++def generate_buffett_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> BuffettSignal:+ """Generate Buffett-style investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Warren Buffett's AI agent. Follow his investment philosophy:++ 1. "Buy wonderful companies at fair prices" - Seek businesses with durable competitive advantages+ 2. Economic moats: High ROE, pricing power, brand strength, network effects+ 3. Predictable earnings: Consistent profitability over many years+ 4. Financial fortress: Low debt, strong balance sheet, reliable cash flow+ 5. Quality management: Efficient capital allocation, shareholder-friendly+ 6. Long-term perspective: "Our favorite holding period is forever"+ 7. Circle of competence: Understand the business model completely++ Reasoning style:+ - Focus on business fundamentals, not market movements+ - Emphasize competitive advantages and moats+ - Discuss management quality and capital allocation+ - Value predictability over growth+ - Use homespun analogies and simple explanations+ - Express high conviction for quality businesses++ Return signal: bullish (wonderful business at fair price), neutral (good business, wrong price), bearish (poor business fundamentals)"""),++ ("human", """Analyze {ticker} using Buffett's criteria:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string"+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_buffett_signal():+ return BuffettSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")++ return call_llm(+ prompt=prompt,+ pydantic_model=BuffettSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_buffett_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/arq_capital_hedge_fund_agent/arq_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/arq_capital_hedge_fund_agent/arq_agent.pynew file mode 100644index 000000000..1409eaae5--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/arq_capital_hedge_fund_agent/arq_agent.py@@ -0,0 +1,907 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+import math+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class AQRSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ factor_exposures: dict+++def aqr_capital_hedge_fund_agent(state: AgentState, agent_id: str = "aqr_capital_hedge_fund_agent"):+ """+ AQR Capital Management: Factor investing, value-momentum combination+ Structure: Academic Research → Factor Analysis → Portfolio Construction → Risk Management → Cliff Asness Decision+ Philosophy: Systematic factor investing, academic rigor, long-term evidence+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ aqr_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Academic research team analyzing factors")++ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "research_and_development"+ ],+ end_date,+ period="annual",+ limit=10,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # AQR's factor-based analysis structure+ progress.update_status(agent_id, ticker, "Academic research team analysis")+ academic_research = academic_research_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Factor analysis team")+ factor_analysis = factor_analysis_team(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Portfolio construction team")+ portfolio_construction = portfolio_construction_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk management analysis")+ risk_management = risk_management_analysis(metrics, financial_line_items)++ progress.update_status(agent_id, ticker, "Cliff Asness systematic decision")+ cliff_asness_decision = cliff_asness_systematic_decision(+ academic_research, factor_analysis, portfolio_construction, risk_management+ )++ # AQR's factor-weighted scoring+ total_score = (+ factor_analysis["score"] * 0.4 ++ academic_research["score"] * 0.25 ++ portfolio_construction["score"] * 0.2 ++ risk_management["score"] * 0.15+ )++ # AQR's systematic factor approach+ factor_strength = factor_analysis.get("combined_factor_score", 0)+ if total_score >= 7.5 and factor_strength > 0.6:+ signal = "bullish"+ elif total_score <= 4.0 or factor_strength < 0.3:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "academic_research": academic_research,+ "factor_analysis": factor_analysis,+ "portfolio_construction": portfolio_construction,+ "risk_management": risk_management,+ "cliff_asness_decision": cliff_asness_decision+ }++ aqr_output = generate_aqr_output(ticker, analysis_data, state, agent_id)++ aqr_analysis[ticker] = {+ "signal": aqr_output.signal,+ "confidence": aqr_output.confidence,+ "reasoning": aqr_output.reasoning,+ "factor_exposures": aqr_output.factor_exposures+ }++ progress.update_status(agent_id, ticker, "Done", analysis=aqr_output.reasoning)++ message = HumanMessage(content=json.dumps(aqr_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(aqr_analysis, "AQR Capital Management")++ state["data"]["analyst_signals"][agent_id] = aqr_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def academic_research_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """AQR's academic research team analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No academic research data"}++ # Long-term evidence analysis+ historical_performance = analyze_long_term_evidence(metrics, financial_line_items)+ if historical_performance > 0.7:+ score += 3+ details.append(f"Strong long-term evidence: {historical_performance:.2f}")++ # Academic factor validation+ factor_persistence = validate_factor_persistence(metrics, financial_line_items)+ if factor_persistence > 0.6:+ score += 2+ details.append(f"Factor persistence validated: {factor_persistence:.2f}")++ # Statistical significance testing+ statistical_significance = test_statistical_significance(financial_line_items)+ if statistical_significance > 0.95: # 95% confidence+ score += 2+ details.append(f"Statistically significant at {statistical_significance:.1%} level")++ # Out-of-sample performance+ out_of_sample_test = conduct_out_of_sample_test(financial_line_items)+ if out_of_sample_test > 0.6:+ score += 2+ details.append("Passes out-of-sample validation")++ # Literature review consistency+ literature_consistency = check_literature_consistency(metrics)+ if literature_consistency > 0.7:+ score += 1+ details.append("Consistent with academic literature")++ return {"score": score, "details": "; ".join(details)}+++def factor_analysis_team(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """AQR's factor analysis team"""+ score = 0+ details = []+ factor_scores = {}++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No factor data"}++ # Value factor analysis+ value_score = calculate_value_factor(metrics, market_cap)+ factor_scores["value"] = value_score+ if value_score > 0.6:+ score += 2.5+ details.append(f"Strong value factor: {value_score:.2f}")++ # Momentum factor analysis+ momentum_score = calculate_momentum_factor(financial_line_items)+ factor_scores["momentum"] = momentum_score+ if momentum_score > 0.6:+ score += 2.5+ details.append(f"Positive momentum factor: {momentum_score:.2f}")++ # Quality factor analysis+ quality_score = calculate_quality_factor(metrics, financial_line_items)+ factor_scores["quality"] = quality_score+ if quality_score > 0.7:+ score += 2+ details.append(f"High quality factor: {quality_score:.2f}")++ # Low volatility factor+ low_vol_score = calculate_low_volatility_factor(financial_line_items)+ factor_scores["low_volatility"] = low_vol_score+ if low_vol_score > 0.6:+ score += 1.5+ details.append(f"Low volatility characteristics: {low_vol_score:.2f}")++ # Profitability factor+ profitability_score = calculate_profitability_factor(metrics, financial_line_items)+ factor_scores["profitability"] = profitability_score+ if profitability_score > 0.7:+ score += 1.5+ details.append(f"Strong profitability factor: {profitability_score:.2f}")++ # Factor combination analysis (AQR's specialty)+ combined_factor_score = combine_factors_aqr_style(factor_scores)++ # Value-momentum crash protection+ crash_protection = analyze_value_momentum_crash_protection(factor_scores)+ if crash_protection > 0.6:+ score += 1+ details.append("Good crash protection from factor combination")++ return {+ "score": min(score, 10),+ "details": "; ".join(details),+ "factor_scores": factor_scores,+ "combined_factor_score": combined_factor_score+ }+++def portfolio_construction_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """AQR's portfolio construction team analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No portfolio construction data"}++ # Factor timing analysis+ factor_timing_score = analyze_factor_timing(financial_line_items)+ if factor_timing_score > 0.6:+ score += 2+ details.append(f"Good factor timing opportunity: {factor_timing_score:.2f}")++ # Position sizing optimization+ position_sizing = optimize_position_sizing(metrics, market_cap)+ if position_sizing > 0.7:+ score += 2+ details.append("Optimal position sizing for factor exposure")++ # Transaction cost analysis+ transaction_costs = analyze_transaction_costs_aqr(market_cap)+ if transaction_costs < 0.02: # Low transaction costs+ score += 1.5+ details.append(f"Low implementation costs: {transaction_costs:.2%}")++ # Capacity constraints+ strategy_capacity = assess_aqr_strategy_capacity(market_cap)+ if strategy_capacity > 0.8:+ score += 1.5+ details.append("High strategy capacity")++ # Risk budgeting+ risk_budgeting_score = analyze_risk_budgeting(financial_line_items)+ if risk_budgeting_score > 0.7:+ score += 1+ details.append("Efficient risk budgeting allocation")++ # Rebalancing frequency optimization+ rebalancing_analysis = optimize_rebalancing_frequency(financial_line_items)+ if rebalancing_analysis > 0.6:+ score += 1+ details.append("Optimal rebalancing frequency identified")++ return {"score": score, "details": "; ".join(details)}+++def risk_management_analysis(metrics: list, financial_line_items: list) -> dict:+ """AQR's risk management analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No risk data"}++ # Factor risk decomposition+ factor_risk_decomp = decompose_factor_risks(metrics, financial_line_items)+ if factor_risk_decomp.get("diversification_ratio", 0) > 0.7:+ score += 2+ details.append("Good factor diversification")++ # Drawdown control+ drawdown_analysis = analyze_drawdown_control(financial_line_items)+ if drawdown_analysis < 0.15: # <15% max drawdown+ score += 2+ details.append(f"Controlled drawdown risk: {drawdown_analysis:.1%}")++ # Regime analysis+ regime_analysis = conduct_regime_analysis(financial_line_items)+ if regime_analysis.get("regime_stability", 0) > 0.6:+ score += 1.5+ details.append("Stable across market regimes")++ # Tail risk hedging+ tail_risk_hedge = analyze_tail_risk_hedging(financial_line_items)+ if tail_risk_hedge > 0.6:+ score += 1.5+ details.append("Good tail risk characteristics")++ # Leverage optimization+ leverage_analysis = optimize_leverage_aqr(metrics, financial_line_items)+ if leverage_analysis > 0.7:+ score += 1+ details.append("Optimal leverage for factor exposure")++ return {"score": score, "details": "; ".join(details)}+++def cliff_asness_systematic_decision(academic_research: dict, factor_analysis: dict,+ portfolio_construction: dict, risk_management: dict) -> dict:+ """Cliff Asness' systematic factor-based decision"""+ details = []++ # Factor strength analysis+ factor_strength = factor_analysis.get("combined_factor_score", 0)+ academic_validation = academic_research["score"] / 10+ implementation_feasibility = portfolio_construction["score"] / 10+ risk_control = risk_management["score"] / 10++ # AQR's decision framework+ overall_attractiveness = (+ factor_strength * 0.4 ++ academic_validation * 0.3 ++ implementation_feasibility * 0.2 ++ risk_control * 0.1+ )++ # Factor timing considerations+ value_momentum_combination = factor_analysis.get("factor_scores", {})+ value_score = value_momentum_combination.get("value", 0)+ momentum_score = value_momentum_combination.get("momentum", 0)++ # Cliff's decision logic+ if overall_attractiveness > 0.7 and factor_strength > 0.6:+ if value_score > 0.6 and momentum_score > 0.6:+ decision = "High conviction factor combination"+ details.append("Strong value-momentum combination with academic support")+ else:+ decision = "Single factor exposure"+ details.append("Strong single factor with systematic evidence")+ elif overall_attractiveness > 0.5:+ decision = "Moderate factor allocation"+ details.append("Moderate factor exposure with risk controls")+ elif factor_strength < 0.3:+ decision = "Avoid - weak factor exposure"+ details.append("Insufficient factor exposure for systematic strategy")+ else:+ decision = "Hold for better factor timing"+ details.append("Wait for stronger factor signals")++ # Academic rigor check+ if academic_research["score"] < 6:+ decision = "Insufficient academic evidence"+ details.append("Does not meet AQR's academic rigor standards")++ return {+ "decision": decision,+ "overall_attractiveness": overall_attractiveness,+ "factor_strength": factor_strength,+ "details": "; ".join(details)+ }+++# Factor Analysis Helper Functions+def calculate_value_factor(metrics: list, market_cap: float) -> float:+ """Calculate AQR's value factor score"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ value_score = 0+ components = 0++ # Price-to-book+ if latest.price_to_book:+ pb_score = max(0, 1 - (latest.price_to_book / 2)) # Normalize by 2.0+ value_score += pb_score+ components += 1++ # Price-to-earnings+ if latest.price_to_earnings and latest.price_to_earnings > 0:+ pe_score = max(0, 1 - (latest.price_to_earnings / 20)) # Normalize by 20+ value_score += pe_score+ components += 1++ # Enterprise value to EBITDA (approximated)+ if latest.price_to_earnings and latest.price_to_earnings > 0:+ ev_ebitda_proxy = latest.price_to_earnings * 0.8 # Rough proxy+ ev_ebitda_score = max(0, 1 - (ev_ebitda_proxy / 15))+ value_score += ev_ebitda_score+ components += 1++ return value_score / components if components > 0 else 0.5+++def calculate_momentum_factor(financial_line_items: list) -> float:+ """Calculate AQR's momentum factor score"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) < 4:+ return 0.5++ # Revenue momentum (multiple time horizons)+ short_term_momentum = (revenues[0] / revenues[1]) - 1 # 1-year+ medium_term_momentum = (revenues[0] / revenues[2]) ** 0.5 - 1 # 2-year annualized+ long_term_momentum = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 # Full period++ # Weight recent momentum more heavily+ momentum_score = (+ short_term_momentum * 0.5 ++ medium_term_momentum * 0.3 ++ long_term_momentum * 0.2+ )++ # Normalize to 0-1 scale+ return min(max((momentum_score + 0.2) / 0.4, 0), 1) # -20% to +20% maps to 0-1+++def calculate_quality_factor(metrics: list, financial_line_items: list) -> float:+ """Calculate AQR's quality factor score"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ quality_components = []++ # Profitability metrics+ if latest.return_on_equity:+ roe_score = min(latest.return_on_equity / 0.2, 1.0) # Normalize by 20%+ quality_components.append(roe_score)++ if latest.return_on_assets:+ roa_score = min(latest.return_on_assets / 0.1, 1.0) # Normalize by 10%+ quality_components.append(roa_score)++ # Earnings stability+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ earnings_stability = 1 - min(calculate_coefficient_of_variation(earnings), 1.0)+ quality_components.append(earnings_stability)++ # Debt-to-equity (lower is better for quality)+ if latest.debt_to_equity is not None:+ debt_quality = max(0, 1 - latest.debt_to_equity) # 0 debt = 1.0 score+ quality_components.append(debt_quality)++ return sum(quality_components) / len(quality_components) if quality_components else 0.5+++def calculate_low_volatility_factor(financial_line_items: list) -> float:+ """Calculate low volatility factor score"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ earnings = [item.net_income for item in financial_line_items if item.net_income]++ if not revenues and not earnings:+ return 0.5++ volatility_scores = []++ if revenues:+ revenue_vol = calculate_coefficient_of_variation(revenues)+ volatility_scores.append(max(0, 1 - revenue_vol))++ if earnings:+ earnings_vol = calculate_coefficient_of_variation(earnings)+ volatility_scores.append(max(0, 1 - earnings_vol))++ return sum(volatility_scores) / len(volatility_scores) if volatility_scores else 0.5+++def calculate_profitability_factor(metrics: list, financial_line_items: list) -> float:+ """Calculate profitability factor score"""+ if not metrics or not financial_line_items:+ return 0.5++ latest = metrics[0]+ latest_financial = financial_line_items[0]++ profitability_components = []++ # Gross margins+ if latest_financial.operating_margin:+ margin_score = min(latest_financial.operating_margin / 0.2, 1.0) # Normalize by 20%+ profitability_components.append(margin_score)++ # Return on invested capital+ if latest.return_on_invested_capital:+ roic_score = min(latest.return_on_invested_capital / 0.15, 1.0)+ profitability_components.append(roic_score)++ # Free cash flow margin+ if latest_financial.free_cash_flow and latest_financial.revenue:+ fcf_margin = latest_financial.free_cash_flow / latest_financial.revenue+ fcf_score = min(max(fcf_margin / 0.1, 0), 1.0) # Normalize by 10%+ profitability_components.append(fcf_score)++ return sum(profitability_components) / len(profitability_components) if profitability_components else 0.5+++def combine_factors_aqr_style(factor_scores: dict) -> float:+ """Combine factors using AQR's methodology"""+ if not factor_scores:+ return 0.5++ # AQR's factor combination approach+ value_score = factor_scores.get("value", 0.5)+ momentum_score = factor_scores.get("momentum", 0.5)+ quality_score = factor_scores.get("quality", 0.5)++ # Value-momentum combination (AQR's specialty)+ if value_score > 0.6 and momentum_score > 0.6:+ # Strong combination bonus+ combined_score = (value_score + momentum_score) / 2 + 0.1+ else:+ # Standard combination+ combined_score = (+ value_score * 0.35 ++ momentum_score * 0.35 ++ quality_score * 0.3+ )++ return min(combined_score, 1.0)+++def analyze_value_momentum_crash_protection(factor_scores: dict) -> float:+ """Analyze crash protection from value-momentum combination"""+ value_score = factor_scores.get("value", 0.5)+ momentum_score = factor_scores.get("momentum", 0.5)+ quality_score = factor_scores.get("quality", 0.5)++ # Value provides crash protection, momentum can be risky+ crash_protection = value_score * 0.6 + quality_score * 0.4 - max(0, momentum_score - 0.5) * 0.2++ return min(max(crash_protection, 0), 1.0)+++def analyze_long_term_evidence(metrics: list, financial_line_items: list) -> float:+ """Analyze long-term evidence for factor performance"""+ if len(financial_line_items) < 5:+ return 0.3 # Insufficient data++ # Consistency over time+ consistent_performance = 0++ # Revenue consistency+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues:+ positive_growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ consistency = positive_growth_years / (len(revenues) - 1)+ consistent_performance += consistency * 0.5++ # Profitability consistency+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ positive_earnings_years = sum(1 for e in earnings if e > 0)+ profitability_consistency = positive_earnings_years / len(earnings)+ consistent_performance += profitability_consistency * 0.5++ return min(consistent_performance, 1.0)+++def validate_factor_persistence(metrics: list, financial_line_items: list) -> float:+ """Validate factor persistence over time"""+ if len(metrics) < 3:+ return 0.5++ # Check if factors persist over time+ persistence_score = 0++ # Value factor persistence+ pb_ratios = [m.price_to_book for m in metrics if m.price_to_book]+ if len(pb_ratios) >= 3:+ value_trend = pb_ratios[0] < pb_ratios[-1] # Becoming cheaper+ if value_trend:+ persistence_score += 0.3++ # Quality factor persistence+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if len(roe_vals) >= 3:+ avg_roe = sum(roe_vals) / len(roe_vals)+ if avg_roe > 0.12: # Consistently high quality+ persistence_score += 0.4++ # Momentum persistence+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ momentum_trend = revenues[0] > revenues[-1] # Growth trend+ if momentum_trend:+ persistence_score += 0.3++ return persistence_score+++def test_statistical_significance(financial_line_items: list) -> float:+ """Test statistical significance of factor performance"""+ if len(financial_line_items) < 5:+ return 0.6 # Insufficient data for strong significance++ # Simple t-test approximation for revenue growth+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ growth_rates = [(revenues[i] / revenues[i + 1]) - 1 for i in range(len(revenues) - 1)]++ if growth_rates:+ mean_growth = sum(growth_rates) / len(growth_rates)+ if len(growth_rates) > 1:+ variance = sum((g - mean_growth) ** 2 for g in growth_rates) / (len(growth_rates) - 1)+ std_error = math.sqrt(variance / len(growth_rates))++ if std_error > 0:+ t_stat = abs(mean_growth / std_error)+ # Rough conversion to confidence level+ return min(0.5 + t_stat * 0.1, 0.99)++ return 0.7 # Moderate significance+++def conduct_out_of_sample_test(financial_line_items: list) -> float:+ """Conduct out-of-sample test"""+ if len(financial_line_items) < 8:+ return 0.5++ # Split data and test performance+ in_sample = financial_line_items[len(financial_line_items) // 2:]+ out_sample = financial_line_items[:len(financial_line_items) // 2]++ # Test revenue growth persistence+ in_sample_revenues = [item.revenue for item in in_sample if item.revenue]+ out_sample_revenues = [item.revenue for item in out_sample if item.revenue]++ if len(in_sample_revenues) >= 2 and len(out_sample_revenues) >= 2:+ in_sample_growth = (in_sample_revenues[0] / in_sample_revenues[-1]) - 1+ out_sample_growth = (out_sample_revenues[0] / out_sample_revenues[-1]) - 1++ # Check if growth pattern persists+ if (in_sample_growth > 0 and out_sample_growth > 0) or (in_sample_growth < 0 and out_sample_growth < 0):+ return 0.8 # Good out-of-sample performance+ else:+ return 0.4 # Poor out-of-sample performance++ return 0.6 # Moderate out-of-sample performance+++def check_literature_consistency(metrics: list) -> float:+ """Check consistency with academic literature"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ consistency_score = 0++ # Value factor literature consistency+ if latest.price_to_book and latest.price_to_book < 1.5:+ consistency_score += 0.3 # Consistent with value literature++ # Quality factor literature consistency+ if latest.return_on_equity and latest.return_on_equity > 0.15:+ consistency_score += 0.4 # Consistent with quality literature++ # Size factor (smaller companies historically outperform)+ # This would require market cap data relative to universe+ consistency_score += 0.3 # Placeholder++ return consistency_score+++def analyze_factor_timing(financial_line_items: list) -> float:+ """Analyze factor timing opportunities"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) < 4:+ return 0.5++ # Check for inflection points in business cycle+ recent_acceleration = (revenues[0] / revenues[1]) > (revenues[1] / revenues[2])++ if recent_acceleration:+ return 0.8 # Good timing for momentum+ else:+ return 0.4 # Poor timing+++def optimize_position_sizing(metrics: list, market_cap: float) -> float:+ """Optimize position sizing for factor exposure"""+ if not metrics:+ return 0.5++ # Kelly criterion approximation+ latest = metrics[0]++ if latest.return_on_equity and latest.return_on_equity > 0:+ expected_return = latest.return_on_equity * 0.5 # Conservative estimate+ volatility = 0.2 # Assumed volatility++ if volatility > 0:+ kelly_fraction = expected_return / (volatility ** 2)+ optimal_size = min(max(kelly_fraction, 0), 0.1) # Cap at 10%+ return optimal_size * 10 # Scale to 0-1++ return 0.5+++def analyze_transaction_costs_aqr(market_cap: float) -> float:+ """Analyze transaction costs for AQR strategies"""+ if market_cap > 50_000_000_000: # $50B++ return 0.005 # 0.5 bps+ elif market_cap > 10_000_000_000: # $10B++ return 0.01 # 1 bps+ elif market_cap > 1_000_000_000: # $1B++ return 0.02 # 2 bps+ else:+ return 0.05 # 5 bps+++def assess_aqr_strategy_capacity(market_cap: float) -> float:+ """Assess strategy capacity for AQR factor strategies"""+ # Larger companies have higher capacity+ return min(math.log10(market_cap / 1_000_000_000) / 2, 1.0)+++def analyze_risk_budgeting(financial_line_items: list) -> float:+ """Analyze risk budgeting allocation"""+ # Simplified risk budgeting based on earnings stability+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ earnings_cv = calculate_coefficient_of_variation(earnings)+ return max(0, 1 - earnings_cv)++ return 0.5+++def optimize_rebalancing_frequency(financial_line_items: list) -> float:+ """Optimize rebalancing frequency"""+ # Based on persistence of factor signals+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ # Check signal persistence+ growth_consistency = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ persistence = growth_consistency / (len(revenues) - 1)++ if persistence > 0.7:+ return 0.8 # Low rebalancing frequency needed+ else:+ return 0.4 # High rebalancing frequency needed++ return 0.6+++def decompose_factor_risks(metrics: list, financial_line_items: list) -> dict:+ """Decompose factor risks"""+ return {+ "market_beta": 0.7,+ "value_loading": 0.6,+ "momentum_loading": 0.4,+ "quality_loading": 0.5,+ "size_loading": 0.3,+ "diversification_ratio": 0.8+ }+++def analyze_drawdown_control(financial_line_items: list) -> float:+ """Analyze drawdown control"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ peak = max(earnings)+ trough = min(earnings)+ if peak > 0:+ max_drawdown = (peak - trough) / peak+ return max_drawdown++ return 0.2 # Assumed 20% max drawdown+++def conduct_regime_analysis(financial_line_items: list) -> dict:+ """Conduct regime analysis"""+ return {+ "regime_stability": 0.7,+ "bull_market_performance": 0.8,+ "bear_market_performance": 0.6,+ "recession_performance": 0.5+ }+++def analyze_tail_risk_hedging(financial_line_items: list) -> float:+ """Analyze tail risk hedging characteristics"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ # Check for negative skewness (tail risk)+ sorted_earnings = sorted(earnings)+ worst_10pct = sorted_earnings[:max(1, len(earnings) // 10)]++ if worst_10pct:+ avg_earnings = sum(earnings) / len(earnings)+ worst_performance = sum(worst_10pct) / len(worst_10pct)++ if avg_earnings > 0:+ tail_ratio = worst_performance / avg_earnings+ return max(0, 1 + tail_ratio) # Better if tail ratio is less negative++ return 0.6+++def optimize_leverage_aqr(metrics: list, financial_line_items: list) -> float:+ """Optimize leverage for AQR factor strategies"""+ if not metrics:+ return 0.5++ latest = metrics[0]++ # Target leverage based on Sharpe ratio+ if latest.return_on_equity:+ estimated_sharpe = latest.return_on_equity * 2 # Rough proxy+ optimal_leverage = min(max(estimated_sharpe, 1.0), 3.0) # 1x to 3x leverage+ return optimal_leverage / 3.0 # Normalize to 0-1++ return 0.7 # Moderate leverage+++def calculate_coefficient_of_variation(data: list) -> float:+ """Calculate coefficient of variation"""+ if not data or len(data) < 2:+ return 1.0++ mean_val = sum(data) / len(data)+ if mean_val == 0:+ return 1.0++ variance = sum((x - mean_val) ** 2 for x in data) / (len(data) - 1)+ std_dev = math.sqrt(variance)++ return std_dev / abs(mean_val)+++def generate_aqr_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> AQRSignal:+ """Generate AQR's factor-based investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are AQR Capital Management's AI system, implementing Cliff Asness' factor investing approach:++ ORGANIZATIONAL STRUCTURE:+ - Academic Research Team: Literature review and statistical validation+ - Factor Analysis Team: Value, momentum, quality, and low-vol factor analysis+ - Portfolio Construction Team: Position sizing and implementation+ - Risk Management Team: Factor risk decomposition and drawdown control+ - Cliff Asness Systematic Decision: Factor combination and timing++ PHILOSOPHY:+ 1. Factor Investing: Systematic exposure to value, momentum, quality factors+ 2. Academic Rigor: Evidence-based investing with statistical validation+ 3. Factor Timing: Intelligent timing of factor exposures+ 4. Value-Momentum Combination: AQR's specialty in combining opposing factors+ 5. Risk Management: Sophisticated factor risk controls+ 6. Long-term Evidence: Focus on factors with decades of evidence+ 7. Implementation Focus: Minimize transaction costs and market impact++ REASONING STYLE:+ - Reference academic literature and statistical evidence+ - Discuss factor exposures and loadings quantitatively+ - Apply rigorous statistical testing and out-of-sample validation+ - Consider factor timing and regime analysis+ - Express confidence in factor persistence and literature consistency+ - Analyze implementation costs and capacity constraints+ - Focus on risk-adjusted returns and Sharpe ratios++ Return investment signal with detailed factor exposure analysis."""),++ ("human", """Apply AQR's factor analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "factor_exposures": {{+ "value": float,+ "momentum": float,+ "quality": float,+ "low_volatility": float,+ "profitability": float,+ "combined_factor_score": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_aqr_signal():+ return AQRSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ factor_exposures={+ "value": 0.5,+ "momentum": 0.5,+ "quality": 0.5,+ "low_volatility": 0.5,+ "profitability": 0.5,+ "combined_factor_score": 0.5+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=AQRSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_aqr_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.pynew file mode 100644index 000000000..4cb77fcd1--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py@@ -0,0 +1,511 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class BridgewaterSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ all_weather_allocation: dict+++def bridgewater_associates_agent(state: AgentState, agent_id: str = "bridgewater_associates_agent"):+ """+ Bridgewater Associates: All Weather portfolio, economic machine principles+ Structure: Economic Research → Portfolio Construction → Risk Management → Ray Dalio Final Decision+ Philosophy: Diversification across economic environments, systematic risk parity+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ bridgewater_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Economic research team analyzing macro environment")++ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "interest_expense"+ ],+ end_date,+ period="annual",+ limit=10,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Bridgewater's multi-team analysis structure+ progress.update_status(agent_id, ticker, "Economic research team analysis")+ economic_research = economic_research_team_analysis(metrics, financial_line_items)++ progress.update_status(agent_id, ticker, "Portfolio construction team analysis")+ portfolio_construction = portfolio_construction_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk management team analysis")+ risk_management = risk_management_team_analysis(financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "All Weather framework analysis")+ all_weather_analysis = all_weather_framework_analysis(metrics, financial_line_items)++ progress.update_status(agent_id, ticker, "Ray Dalio's synthesis and final decision")+ ray_dalio_synthesis = ray_dalio_final_decision(+ economic_research, portfolio_construction, risk_management, all_weather_analysis+ )++ # Bridgewater's risk-parity weighted scoring+ total_score = (+ economic_research["score"] * 0.3 ++ all_weather_analysis["score"] * 0.25 ++ risk_management["score"] * 0.25 ++ portfolio_construction["score"] * 0.2+ )++ # Bridgewater's systematic approach+ if total_score >= 7.5:+ signal = "bullish"+ elif total_score <= 4.0:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "economic_research": economic_research,+ "portfolio_construction": portfolio_construction,+ "risk_management": risk_management,+ "all_weather_analysis": all_weather_analysis,+ "ray_dalio_synthesis": ray_dalio_synthesis+ }++ bridgewater_output = generate_bridgewater_output(ticker, analysis_data, state, agent_id)++ bridgewater_analysis[ticker] = {+ "signal": bridgewater_output.signal,+ "confidence": bridgewater_output.confidence,+ "reasoning": bridgewater_output.reasoning,+ "all_weather_allocation": bridgewater_output.all_weather_allocation+ }++ progress.update_status(agent_id, ticker, "Done", analysis=bridgewater_output.reasoning)++ message = HumanMessage(content=json.dumps(bridgewater_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(bridgewater_analysis, "Bridgewater Associates")++ state["data"]["analyst_signals"][agent_id] = bridgewater_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def economic_research_team_analysis(metrics: list, financial_line_items: list) -> dict:+ """Bridgewater's economic research team analyzing macro environment impact"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No economic data"}++ # Economic cycle positioning+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ # Growth trend analysis+ recent_growth = (revenues[0] / revenues[2]) ** (1 / 2) - 1 # 2-year CAGR+ longer_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 # Full period++ # Economic machine principle: Growth and inflation environment+ if 0.02 <= recent_growth <= 0.08: # Goldilocks growth+ score += 2+ details.append(f"Sustainable growth environment: {recent_growth:.1%} recent growth")+ elif recent_growth > 0.15: # Overheating risk+ score -= 1+ details.append(f"Potential overheating: {recent_growth:.1%} growth")++ # Debt cycle analysis+ debt_metrics = [m.debt_to_equity for m in metrics if m.debt_to_equity]+ if debt_metrics:+ current_leverage = debt_metrics[0]+ avg_leverage = sum(debt_metrics) / len(debt_metrics)++ # Bridgewater's debt cycle framework+ if current_leverage < avg_leverage * 0.8: # Deleveraging phase+ score += 1+ details.append("Company in deleveraging phase - defensive positioning")+ elif current_leverage > avg_leverage * 1.3: # High leverage risk+ score -= 2+ details.append("High leverage in debt cycle - risk concern")++ # Currency and inflation hedging capability+ international_exposure = analyze_international_exposure(financial_line_items)+ if international_exposure > 0.3: # 30%+ international+ score += 1+ details.append("Natural currency hedging through international exposure")++ # Interest rate sensitivity+ interest_coverage = calculate_interest_coverage(financial_line_items)+ if interest_coverage > 5: # Low interest rate sensitivity+ score += 1+ details.append(f"Low interest rate risk: {interest_coverage:.1f}x coverage")+ elif interest_coverage < 2:+ score -= 1+ details.append(f"High interest rate sensitivity: {interest_coverage:.1f}x coverage")++ return {"score": score, "details": "; ".join(details)}+++def portfolio_construction_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Bridgewater's portfolio construction team analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No portfolio construction data"}++ latest_metrics = metrics[0]++ # Risk-adjusted returns+ if latest_metrics.return_on_equity:+ roe_consistency = len([m.return_on_equity for m in metrics if m.return_on_equity and m.return_on_equity > 0.1])+ if roe_consistency >= len(metrics) * 0.8: # Consistent returns+ score += 2+ details.append(f"Consistent risk-adjusted returns: {roe_consistency}/{len(metrics)} years ROE >10%")++ # Diversification benefits+ revenue_stability = analyze_revenue_diversification(financial_line_items)+ if revenue_stability > 0.8: # Stable revenue streams+ score += 1+ details.append("Revenue diversification provides portfolio stability")++ # Correlation with economic factors+ earnings_correlation = analyze_economic_correlation(financial_line_items)+ if earnings_correlation < 0.7: # Low correlation+ score += 2+ details.append("Low correlation with economic cycles - diversification benefit")++ # Liquidity for rebalancing+ if latest_metrics.current_ratio and latest_metrics.current_ratio > 1.5:+ score += 1+ details.append(f"Adequate liquidity for dynamic rebalancing: {latest_metrics.current_ratio:.1f}")++ # Valuation relative to fair value+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 18:+ score += 1+ details.append(f"Reasonable valuation for portfolio inclusion: {latest_metrics.price_to_earnings:.1f} P/E")++ return {"score": score, "details": "; ".join(details)}+++def risk_management_team_analysis(financial_line_items: list, market_cap: float) -> dict:+ """Bridgewater's risk management team analysis"""+ score = 0+ details = []+ risk_factors = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No risk data"}++ latest = financial_line_items[0]++ # Balance sheet risk+ if latest.total_debt and latest.shareholders_equity:+ leverage_ratio = latest.total_debt / latest.shareholders_equity+ if leverage_ratio < 0.4: # Low leverage risk+ score += 2+ details.append(f"Low balance sheet risk: {leverage_ratio:.2f} D/E")+ elif leverage_ratio > 1.0:+ risk_factors.append("High leverage risk")+ score -= 2++ # Liquidity risk+ if latest.current_assets and latest.current_liabilities:+ liquidity_ratio = latest.current_assets / latest.current_liabilities+ if liquidity_ratio > 2.0:+ score += 1+ details.append(f"Low liquidity risk: {liquidity_ratio:.1f} current ratio")+ elif liquidity_ratio < 1.2:+ risk_factors.append("Liquidity concerns")+ score -= 1++ # Earnings volatility risk+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings and len(earnings) >= 5:+ earnings_volatility = (max(earnings) - min(earnings)) / max(abs(max(earnings)), abs(min(earnings)))+ if earnings_volatility < 0.5:+ score += 1+ details.append(f"Low earnings volatility: {earnings_volatility:.2f}")+ elif earnings_volatility > 1.0:+ risk_factors.append("High earnings volatility")+ score -= 1++ # Concentration risk+ revenue_concentration = analyze_business_concentration(financial_line_items)+ if revenue_concentration < 0.6: # Diversified business+ score += 1+ details.append("Low business concentration risk")+ else:+ risk_factors.append("Business concentration risk")++ # Tail risk assessment+ worst_performance = analyze_worst_case_scenarios(financial_line_items)+ if worst_performance > -0.2: # Limited downside+ score += 2+ details.append("Limited tail risk exposure")++ if risk_factors:+ details.append(f"Risk factors identified: {'; '.join(risk_factors)}")++ return {"score": score, "details": "; ".join(details), "risk_factors": risk_factors}+++def all_weather_framework_analysis(metrics: list, financial_line_items: list) -> dict:+ """Bridgewater's All Weather framework analysis"""+ score = 0+ details = []+ environment_scores = {}++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No All Weather data"}++ # Four economic environments analysis+ # 1. Rising Growth+ growth_performance = analyze_growth_environment_performance(financial_line_items)+ environment_scores["rising_growth"] = growth_performance+ if growth_performance > 0.7:+ score += 2+ details.append("Strong performance in rising growth environment")++ # 2. Falling Growth+ recession_resilience = analyze_recession_resilience(financial_line_items)+ environment_scores["falling_growth"] = recession_resilience+ if recession_resilience > 0.6:+ score += 2+ details.append("Good resilience in falling growth environment")++ # 3. Rising Inflation+ inflation_protection = analyze_inflation_protection(financial_line_items)+ environment_scores["rising_inflation"] = inflation_protection+ if inflation_protection > 0.5:+ score += 1+ details.append("Some inflation protection characteristics")++ # 4. Falling Inflation+ deflation_performance = analyze_deflation_performance(metrics, financial_line_items)+ environment_scores["falling_inflation"] = deflation_performance+ if deflation_performance > 0.6:+ score += 1+ details.append("Good performance in falling inflation environment")++ # All Weather balance score+ environment_balance = min(environment_scores.values()) / max(environment_scores.values())+ if environment_balance > 0.7: # Balanced across environments+ score += 3+ details.append("Well-balanced performance across economic environments")++ return {+ "score": score,+ "details": "; ".join(details),+ "environment_scores": environment_scores+ }+++def ray_dalio_final_decision(economic_research: dict, portfolio_construction: dict,+ risk_management: dict, all_weather_analysis: dict) -> dict:+ """Ray Dalio's final synthesis and decision"""+ details = []++ # Synthesis of team inputs+ total_team_score = (+ economic_research["score"] ++ portfolio_construction["score"] ++ risk_management["score"] ++ all_weather_analysis["score"]+ ) / 4++ # Ray's decision framework+ if total_team_score >= 7:+ decision = "Strong conviction buy"+ details.append("All teams align on strong fundamental and risk-adjusted opportunity")+ elif total_team_score >= 5:+ decision = "Moderate allocation"+ details.append("Mixed signals from teams - moderate position appropriate")+ elif len(risk_management.get("risk_factors", [])) > 2:+ decision = "Risk concerns override"+ details.append("Risk management team identifies too many risk factors")+ else:+ decision = "Pass on opportunity"+ details.append("Insufficient conviction across research teams")++ # Economic machine principles+ if all_weather_analysis.get("environment_scores", {}).get("rising_growth", 0) > 0.8:+ details.append("Strong positioning for current economic environment")++ return {+ "decision": decision,+ "team_alignment": total_team_score,+ "details": "; ".join(details)+ }+++# Helper functions for economic analysis+def analyze_international_exposure(financial_line_items: list) -> float:+ """Estimate international exposure (simplified)"""+ # In practice, would analyze geographic revenue breakdown+ return 0.4 # Placeholder - 40% international exposure+++def calculate_interest_coverage(financial_line_items: list) -> float:+ """Calculate interest coverage ratio"""+ latest = financial_line_items[0]+ if latest.interest_expense and latest.interest_expense > 0:+ operating_income = latest.net_income + latest.interest_expense # Simplified+ return operating_income / latest.interest_expense+ return 10.0 # High coverage if no debt+++def analyze_revenue_diversification(financial_line_items: list) -> float:+ """Analyze revenue stream diversification"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues:+ volatility = (max(revenues) - min(revenues)) / max(revenues)+ return 1 - min(volatility, 1.0) # Higher score for more stable revenue+ return 0.5+++def analyze_economic_correlation(financial_line_items: list) -> float:+ """Analyze correlation with economic cycles (simplified)"""+ return 0.6 # Placeholder correlation coefficient+++def analyze_business_concentration(financial_line_items: list) -> float:+ """Analyze business line concentration risk"""+ return 0.5 # Placeholder - would analyze business segments+++def analyze_worst_case_scenarios(financial_line_items: list) -> float:+ """Analyze worst-case performance"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ worst_earnings = min(earnings)+ avg_earnings = sum(earnings) / len(earnings)+ return worst_earnings / avg_earnings if avg_earnings > 0 else -1.0+ return -0.5+++def analyze_growth_environment_performance(financial_line_items: list) -> float:+ """Performance in rising growth environment"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ growth_periods = sum(1 for i in range(len(revenues) - 1) if revenues[i] > revenues[i + 1])+ return growth_periods / (len(revenues) - 1)+ return 0.5+++def analyze_recession_resilience(financial_line_items: list) -> float:+ """Resilience in falling growth environment"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ negative_years = sum(1 for e in earnings if e < 0)+ return 1 - (negative_years / len(earnings))+ return 0.5+++def analyze_inflation_protection(financial_line_items: list) -> float:+ """Inflation protection characteristics"""+ # Would analyze pricing power, asset-light model, etc.+ return 0.5 # Placeholder+++def analyze_deflation_performance(metrics: list, financial_line_items: list) -> float:+ """Performance in falling inflation environment"""+ # Would analyze bond-like characteristics, stable cash flows+ return 0.6 # Placeholder+++def generate_bridgewater_output(ticker: str, analysis_data: dict, state: AgentState,+ agent_id: str) -> BridgewaterSignal:+ """Generate Bridgewater's systematic investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Bridgewater Associates' AI system, implementing Ray Dalio's All Weather and economic machine principles:++ ORGANIZATIONAL STRUCTURE:+ - Economic Research Team: Macro environment and debt cycle analysis+ - Portfolio Construction Team: Risk-adjusted returns and diversification+ - Risk Management Team: Comprehensive risk assessment+ - All Weather Framework: Performance across four economic environments+ - Ray Dalio Synthesis: Final decision integration++ PHILOSOPHY:+ 1. All Weather: Balanced performance across economic environments (growth/inflation up/down)+ 2. Economic Machine: Understanding debt cycles and economic principles+ 3. Risk Parity: Equal risk contribution, not equal dollar allocation+ 4. Systematic Approach: Remove emotion, follow systematic principles+ 5. Diversification: True diversification across uncorrelated return streams+ 6. Transparency: Radical transparency in decision-making process++ REASONING STYLE:+ - Reference team analyses and organizational structure+ - Apply economic machine principles to company analysis+ - Consider All Weather framework and environmental balance+ - Discuss risk parity and diversification benefits+ - Synthesize multiple team perspectives+ - Express systematic, principle-based reasoning+ - Consider position sizing based on risk contribution++ Return the investment signal with All Weather allocation recommendations."""),++ ("human", """Apply Bridgewater's systematic analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "all_weather_allocation": {{+ "rising_growth_weight": float,+ "falling_growth_weight": float,+ "rising_inflation_weight": float,+ "falling_inflation_weight": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_bridgewater_signal():+ return BridgewaterSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ all_weather_allocation={+ "rising_growth_weight": 0.25,+ "falling_growth_weight": 0.25,+ "rising_inflation_weight": 0.25,+ "falling_inflation_weight": 0.25+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=BridgewaterSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_bridgewater_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/citadel_hedge_fund_agent/citadel_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/citadel_hedge_fund_agent/citadel_agent.pynew file mode 100644index 000000000..5f1ef08e5--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/citadel_hedge_fund_agent/citadel_agent.py@@ -0,0 +1,754 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class CitadelSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ strategy_allocation: dict+++def citadel_hedge_fund_agent(state: AgentState, agent_id: str = "citadel_hedge_fund_agent"):+ """+ Citadel: Multi-strategy quantitative approach+ Structure: Fundamental Research → Quantitative Research → Global Macro → Trading → Ken Griffin Final Decision+ Philosophy: Multi-strategy approach, technological edge, risk management, market making+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ citadel_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Fundamental research team analyzing company")++ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=8, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "research_and_development"+ ],+ end_date,+ period="annual",+ limit=8,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Citadel's multi-department analysis+ progress.update_status(agent_id, ticker, "Fundamental research department")+ fundamental_research = fundamental_research_department(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Quantitative research department")+ quantitative_research = quantitative_research_department(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Global macro department")+ global_macro = global_macro_department(metrics, financial_line_items)++ progress.update_status(agent_id, ticker, "Trading department analysis")+ trading_department = trading_department_analysis(financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk management oversight")+ risk_management = risk_management_oversight(financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Ken Griffin's multi-strategy synthesis")+ ken_griffin_decision = ken_griffin_multi_strategy_synthesis(+ fundamental_research, quantitative_research, global_macro,+ trading_department, risk_management+ )++ # Citadel's multi-strategy scoring+ total_score = (+ fundamental_research["score"] * 0.25 ++ quantitative_research["score"] * 0.25 ++ trading_department["score"] * 0.2 ++ global_macro["score"] * 0.15 ++ risk_management["score"] * 0.15+ )++ # Citadel's multi-strategy decision framework+ if total_score >= 8.0 and ken_griffin_decision.get("risk_adjusted_return", 0) > 0.15:+ signal = "bullish"+ elif total_score <= 4.0 or len(risk_management.get("risk_flags", [])) > 2:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "fundamental_research": fundamental_research,+ "quantitative_research": quantitative_research,+ "global_macro": global_macro,+ "trading_department": trading_department,+ "risk_management": risk_management,+ "ken_griffin_decision": ken_griffin_decision+ }++ citadel_output = generate_citadel_output(ticker, analysis_data, state, agent_id)++ citadel_analysis[ticker] = {+ "signal": citadel_output.signal,+ "confidence": citadel_output.confidence,+ "reasoning": citadel_output.reasoning,+ "strategy_allocation": citadel_output.strategy_allocation+ }++ progress.update_status(agent_id, ticker, "Done", analysis=citadel_output.reasoning)++ message = HumanMessage(content=json.dumps(citadel_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(citadel_analysis, "Citadel")++ state["data"]["analyst_signals"][agent_id] = citadel_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def fundamental_research_department(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Citadel's fundamental research department analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No fundamental data"}++ latest_metrics = metrics[0]++ # Deep value analysis+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.5:+ score += 2+ details.append(f"Attractive book value: {latest_metrics.price_to_book:.2f} P/B")++ # Quality metrics+ if latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.15:+ score += 2+ details.append(f"High quality: {latest_metrics.return_on_equity:.1%} ROE")++ # Growth sustainability+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ if 0.05 <= revenue_cagr <= 0.25: # Sustainable growth+ score += 2+ details.append(f"Sustainable growth: {revenue_cagr:.1%} revenue CAGR")++ # Competitive position+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins:+ avg_margin = sum(margins) / len(margins)+ if avg_margin > 0.15: # Strong competitive moat+ score += 2+ details.append(f"Strong margins: {avg_margin:.1%} average operating margin")++ # Management capital allocation+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if fcf_vals:+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)+ if positive_fcf_years >= len(fcf_vals) * 0.8:+ score += 1+ details.append(f"Strong capital allocation: {positive_fcf_years}/{len(fcf_vals)} positive FCF years")++ # Catalyst identification+ if len(revenues) >= 3 and revenues[0] > revenues[1] * 1.1: # 10%+ recent acceleration+ score += 1+ details.append("Recent business acceleration identified")++ return {"score": score, "details": "; ".join(details)}+++def quantitative_research_department(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Citadel's quantitative research department analysis"""+ score = 0+ details = []+ quant_metrics = {}++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No quant data"}++ # Factor model analysis+ factor_loadings = calculate_factor_loadings(metrics, financial_line_items)+ quant_metrics["factors"] = factor_loadings++ if factor_loadings.get("value_factor", 0) > 0.6:+ score += 2+ details.append("Strong value factor loading")++ if factor_loadings.get("quality_factor", 0) > 0.7:+ score += 2+ details.append("High quality factor exposure")++ # Statistical signals+ mean_reversion_signal = calculate_mean_reversion_score(metrics)+ quant_metrics["mean_reversion"] = mean_reversion_signal+ if abs(mean_reversion_signal) > 0.6:+ score += 1.5+ details.append(f"Strong mean reversion signal: {mean_reversion_signal:.2f}")++ # Momentum analysis+ momentum_score = calculate_momentum_score(financial_line_items)+ quant_metrics["momentum"] = momentum_score+ if momentum_score > 0.6:+ score += 1.5+ details.append(f"Positive momentum: {momentum_score:.2f}")++ # Volatility analysis+ volatility_score = analyze_volatility_patterns(financial_line_items)+ quant_metrics["volatility"] = volatility_score+ if volatility_score < 0.4: # Low volatility is good+ score += 1+ details.append("Low volatility profile")++ # Cross-sectional ranking+ percentile_rank = calculate_cross_sectional_rank(metrics)+ quant_metrics["percentile_rank"] = percentile_rank+ if percentile_rank > 0.8: # Top 20%+ score += 2+ details.append(f"Top quintile ranking: {percentile_rank:.1%}")++ return {+ "score": score,+ "details": "; ".join(details),+ "quant_metrics": quant_metrics+ }+++def global_macro_department(metrics: list, financial_line_items: list) -> dict:+ """Citadel's global macro department analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No macro data"}++ # Economic cycle positioning+ latest = financial_line_items[0]++ # Interest rate sensitivity+ if latest.total_debt and latest.total_assets:+ debt_ratio = latest.total_debt / latest.total_assets+ if debt_ratio < 0.3: # Low interest rate sensitivity+ score += 2+ details.append(f"Low interest rate risk: {debt_ratio:.1%} debt/assets")+ elif debt_ratio > 0.6:+ score -= 1+ details.append(f"High interest rate sensitivity: {debt_ratio:.1%} debt/assets")++ # Currency exposure analysis+ international_revenue_proxy = analyze_international_exposure(financial_line_items)+ if 0.2 <= international_revenue_proxy <= 0.6: # Balanced exposure+ score += 1+ details.append("Balanced international exposure")++ # Inflation hedging capability+ pricing_power = analyze_pricing_power(financial_line_items)+ if pricing_power > 0.7:+ score += 2+ details.append("Strong pricing power - inflation hedge")++ # Economic cycle resilience+ recession_resilience = analyze_recession_performance(financial_line_items)+ if recession_resilience > 0.6:+ score += 1+ details.append("Good recession resilience")++ # Commodity exposure+ commodity_sensitivity = analyze_commodity_exposure(financial_line_items)+ if commodity_sensitivity < 0.3: # Low commodity risk+ score += 1+ details.append("Low commodity price sensitivity")++ return {"score": score, "details": "; ".join(details)}+++def trading_department_analysis(financial_line_items: list, market_cap: float) -> dict:+ """Citadel's trading department analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No trading data"}++ # Liquidity analysis+ liquidity_score = assess_trading_liquidity(market_cap)+ if liquidity_score > 0.8:+ score += 3+ details.append("High liquidity for large position sizes")+ elif liquidity_score > 0.6:+ score += 2+ details.append("Adequate liquidity for trading")++ # Market making opportunities+ volatility = estimate_trading_volatility(financial_line_items)+ if 0.15 <= volatility <= 0.35: # Optimal volatility for market making+ score += 2+ details.append(f"Good market making opportunity: {volatility:.1%} volatility")++ # Execution efficiency+ market_impact = estimate_market_impact_cost(market_cap)+ if market_impact < 0.02: # Low market impact+ score += 2+ details.append(f"Low execution costs: {market_impact:.2%} market impact")++ # Options market opportunities+ options_opportunity = analyze_options_opportunities(financial_line_items, market_cap)+ if options_opportunity > 0.6:+ score += 1+ details.append("Good options trading opportunities")++ # High-frequency trading signals+ hft_signals = analyze_hft_opportunities(financial_line_items)+ if hft_signals > 0.5:+ score += 1+ details.append("Positive high-frequency signals")++ return {"score": score, "details": "; ".join(details)}+++def risk_management_oversight(financial_line_items: list, market_cap: float) -> dict:+ """Citadel's risk management oversight"""+ score = 0+ details = []+ risk_flags = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No risk data"}++ latest = financial_line_items[0]++ # Leverage risk+ if latest.total_debt and latest.shareholders_equity:+ leverage = latest.total_debt / latest.shareholders_equity+ if leverage < 0.5:+ score += 2+ details.append(f"Conservative leverage: {leverage:.2f} D/E")+ elif leverage > 1.5:+ risk_flags.append("High leverage risk")+ score -= 2++ # Liquidity risk+ if latest.current_assets and latest.current_liabilities:+ current_ratio = latest.current_assets / latest.current_liabilities+ if current_ratio > 1.5:+ score += 1+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")+ elif current_ratio < 1.0:+ risk_flags.append("Liquidity concerns")+ score -= 1++ # Earnings quality risk+ earnings_quality = assess_earnings_quality(financial_line_items)+ if earnings_quality > 0.7:+ score += 2+ details.append("High earnings quality")+ elif earnings_quality < 0.4:+ risk_flags.append("Earnings quality concerns")+ score -= 1++ # Concentration risk+ business_concentration = assess_business_concentration_risk(financial_line_items)+ if business_concentration < 0.6:+ score += 1+ details.append("Diversified business model")+ elif business_concentration > 0.8:+ risk_flags.append("High business concentration")++ # Tail risk assessment+ tail_risk = calculate_tail_risk_metrics(financial_line_items)+ if tail_risk < 0.3:+ score += 2+ details.append("Low tail risk profile")+ elif tail_risk > 0.7:+ risk_flags.append("High tail risk")+ score -= 1++ # Regulatory risk+ regulatory_risk = assess_regulatory_risk(financial_line_items)+ if regulatory_risk < 0.4:+ score += 1+ details.append("Low regulatory risk")++ if risk_flags:+ details.append(f"Risk flags: {'; '.join(risk_flags)}")++ return {+ "score": score,+ "details": "; ".join(details),+ "risk_flags": risk_flags+ }+++def ken_griffin_multi_strategy_synthesis(fundamental_research: dict, quantitative_research: dict,+ global_macro: dict, trading_department: dict,+ risk_management: dict) -> dict:+ """Ken Griffin's multi-strategy synthesis and final decision"""+ details = []++ # Multi-strategy scoring+ fundamental_score = fundamental_research["score"] / 10+ quant_score = quantitative_research["score"] / 10+ macro_score = global_macro["score"] / 10+ trading_score = trading_department["score"] / 10+ risk_score = risk_management["score"] / 10++ # Ken Griffin's decision framework+ overall_attractiveness = (+ fundamental_score * 0.3 ++ quant_score * 0.25 ++ trading_score * 0.2 ++ macro_score * 0.15 ++ risk_score * 0.1+ )++ # Risk-adjusted return estimation+ risk_adjustment = 1 - (len(risk_management.get("risk_flags", [])) * 0.2)+ risk_adjusted_return = overall_attractiveness * risk_adjustment++ # Strategy allocation decision+ strategy_weights = {+ "equity_long_short": 0.4,+ "quantitative": 0.25,+ "macro": 0.15,+ "market_making": 0.1,+ "convertible_arbitrage": 0.1+ }++ # Adjust weights based on departmental strengths+ if quant_score > 0.7:+ strategy_weights["quantitative"] += 0.1+ strategy_weights["equity_long_short"] -= 0.05+ strategy_weights["macro"] -= 0.05++ if trading_score > 0.8:+ strategy_weights["market_making"] += 0.1+ strategy_weights["equity_long_short"] -= 0.1++ # Final decision logic+ if risk_adjusted_return > 0.15 and len(risk_management.get("risk_flags", [])) <= 1:+ decision = "Multi-strategy allocation"+ details.append("Strong opportunity across multiple strategies")+ elif risk_adjusted_return > 0.1:+ decision = "Selective strategy allocation"+ details.append("Moderate opportunity with selective strategy focus")+ elif len(risk_management.get("risk_flags", [])) > 2:+ decision = "Risk override - pass"+ details.append("Risk management concerns override opportunity")+ else:+ decision = "Insufficient multi-strategy edge"+ details.append("No clear edge across Citadel's strategy platforms")++ return {+ "decision": decision,+ "overall_attractiveness": overall_attractiveness,+ "risk_adjusted_return": risk_adjusted_return,+ "strategy_weights": strategy_weights,+ "details": "; ".join(details)+ }+++# Helper functions for Citadel analysis+def calculate_factor_loadings(metrics: list, financial_line_items: list) -> dict:+ """Calculate factor model loadings"""+ if not metrics:+ return {}++ latest = metrics[0]+ factors = {}++ # Value factor+ if latest.price_to_book:+ factors["value_factor"] = max(0, 1 - (latest.price_to_book / 2)) # Lower P/B = higher value++ # Quality factor+ if latest.return_on_equity:+ factors["quality_factor"] = min(latest.return_on_equity / 0.2, 1.0) # Normalize by 20%++ # Growth factor+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ factors["growth_factor"] = min(growth / 0.15, 1.0) # Normalize by 15%++ return factors+++def calculate_mean_reversion_score(metrics: list) -> float:+ """Calculate mean reversion signal"""+ if len(metrics) < 4:+ return 0.0++ pe_ratios = [m.price_to_earnings for m in metrics if m.price_to_earnings and m.price_to_earnings > 0]+ if len(pe_ratios) >= 4:+ current_pe = pe_ratios[0]+ historical_mean = sum(pe_ratios[1:]) / len(pe_ratios[1:])++ if historical_mean > 0:+ deviation = (current_pe - historical_mean) / historical_mean+ return -deviation # Negative deviation = positive signal++ return 0.0+++def calculate_momentum_score(financial_line_items: list) -> float:+ """Calculate momentum signal"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ recent_growth = (revenues[0] / revenues[1]) - 1+ longer_growth = (revenues[1] / revenues[-1]) ** (1 / (len(revenues) - 2)) - 1++ if longer_growth > 0:+ momentum = (recent_growth - longer_growth) / longer_growth+ return max(min(momentum, 1.0), -1.0)++ return 0.0+++def analyze_volatility_patterns(financial_line_items: list) -> float:+ """Analyze earnings volatility"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) >= 4:+ mean_earnings = sum(earnings) / len(earnings)+ if mean_earnings != 0:+ variance = sum((e - mean_earnings) ** 2 for e in earnings) / len(earnings)+ cv = (variance ** 0.5) / abs(mean_earnings)+ return min(cv, 1.0)++ return 0.5+++def calculate_cross_sectional_rank(metrics: list) -> float:+ """Calculate cross-sectional ranking (simplified)"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ rank_components = []++ if latest.return_on_equity:+ rank_components.append(min(latest.return_on_equity / 0.2, 1.0))++ if latest.price_to_earnings and latest.price_to_earnings > 0:+ rank_components.append(max(0, 1 - (latest.price_to_earnings / 25)))++ if rank_components:+ return sum(rank_components) / len(rank_components)++ return 0.5+++def analyze_international_exposure(financial_line_items: list) -> float:+ """Estimate international revenue exposure"""+ return 0.4 # Placeholder - would analyze geographic segments+++def analyze_pricing_power(financial_line_items: list) -> float:+ """Analyze pricing power through margin stability"""+ margins = []+ for item in financial_line_items:+ if item.operating_margin:+ margins.append(item.operating_margin)++ if len(margins) >= 3:+ margin_stability = 1 - ((max(margins) - min(margins)) / max(margins))+ return max(margin_stability, 0)++ return 0.5+++def analyze_recession_performance(financial_line_items: list) -> float:+ """Analyze performance during economic downturns"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ negative_years = sum(1 for e in earnings if e < 0)+ return 1 - (negative_years / len(earnings))++ return 0.5+++def analyze_commodity_exposure(financial_line_items: list) -> float:+ """Analyze commodity price sensitivity"""+ return 0.3 # Placeholder - would analyze input cost sensitivity+++def assess_trading_liquidity(market_cap: float) -> float:+ """Assess trading liquidity based on market cap"""+ if market_cap > 50_000_000_000: # $50B++ return 0.95+ elif market_cap > 10_000_000_000: # $10B++ return 0.85+ elif market_cap > 1_000_000_000: # $1B++ return 0.65+ else:+ return 0.3+++def estimate_trading_volatility(financial_line_items: list) -> float:+ """Estimate trading volatility"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues:+ mean_rev = sum(revenues) / len(revenues)+ if mean_rev > 0:+ variance = sum((r - mean_rev) ** 2 for r in revenues) / len(revenues)+ return (variance ** 0.5) / mean_rev++ return 0.25+++def estimate_market_impact_cost(market_cap: float) -> float:+ """Estimate market impact costs"""+ if market_cap > 100_000_000_000: # $100B++ return 0.005+ elif market_cap > 10_000_000_000: # $10B++ return 0.01+ elif market_cap > 1_000_000_000: # $1B++ return 0.03+ else:+ return 0.08+++def analyze_options_opportunities(financial_line_items: list, market_cap: float) -> float:+ """Analyze options trading opportunities"""+ if market_cap > 5_000_000_000: # Large cap with active options+ return 0.8+ elif market_cap > 1_000_000_000:+ return 0.6+ else:+ return 0.3+++def analyze_hft_opportunities(financial_line_items: list) -> float:+ """Analyze high-frequency trading opportunities"""+ return 0.6 # Placeholder for HFT signal analysis+++def assess_earnings_quality(financial_line_items: list) -> float:+ """Assess earnings quality"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]++ if earnings and fcf_vals and len(earnings) == len(fcf_vals):+ total_earnings = sum(earnings)+ total_fcf = sum(fcf_vals)++ if total_earnings > 0:+ cash_conversion = total_fcf / total_earnings+ return min(max(cash_conversion, 0), 1.0)++ return 0.5+++def assess_business_concentration_risk(financial_line_items: list) -> float:+ """Assess business concentration risk"""+ return 0.5 # Placeholder - would analyze business segment data+++def calculate_tail_risk_metrics(financial_line_items: list) -> float:+ """Calculate tail risk metrics"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ sorted_earnings = sorted(earnings)+ worst_5pct = sorted_earnings[:max(1, len(earnings) // 20)]+ if worst_5pct:+ avg_earnings = sum(earnings) / len(earnings)+ worst_performance = min(worst_5pct)+ if avg_earnings > 0:+ return abs(worst_performance) / avg_earnings++ return 0.5+++def assess_regulatory_risk(financial_line_items: list) -> float:+ """Assess regulatory risk"""+ return 0.3 # Placeholder - would analyze regulatory environment+++def generate_citadel_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> CitadelSignal:+ """Generate Citadel's multi-strategy investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Citadel's AI system, implementing Ken Griffin's multi-strategy hedge fund approach:++ ORGANIZATIONAL STRUCTURE:+ - Fundamental Research Department: Deep value and quality analysis+ - Quantitative Research Department: Factor models and statistical signals+ - Global Macro Department: Economic cycle and currency analysis+ - Trading Department: Liquidity, execution, and market making+ - Risk Management: Comprehensive risk oversight+ - Ken Griffin Multi-Strategy Synthesis: Integration across all platforms++ PHILOSOPHY:+ 1. Multi-Strategy Approach: Diversify across equity long/short, quant, macro, market making+ 2. Technological Edge: Advanced technology and data analytics+ 3. Risk Management: Sophisticated risk controls and position sizing+ 4. Market Making: Provide liquidity while capturing spreads+ 5. Systematic Execution: Minimize market impact and transaction costs+ 6. Global Perspective: Opportunities across markets and asset classes+ 7. Performance Focus: Risk-adjusted returns and alpha generation++ REASONING STYLE:+ - Reference multiple departmental analyses and perspectives+ - Integrate fundamental, quantitative, and macro insights+ - Consider trading feasibility and execution efficiency+ - Apply rigorous risk management overlay+ - Discuss multi-strategy allocation and position sizing+ - Express confidence in technological and analytical edge+ - Consider market making and liquidity provision opportunities++ Return investment signal with multi-strategy allocation recommendations."""),++ ("human", """Apply Citadel's multi-strategy analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "strategy_allocation": {{+ "equity_long_short": float,+ "quantitative": float,+ "global_macro": float,+ "market_making": float,+ "convertible_arbitrage": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_citadel_signal():+ return CitadelSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ strategy_allocation={+ "equity_long_short": 0.4,+ "quantitative": 0.25,+ "global_macro": 0.15,+ "market_making": 0.1,+ "convertible_arbitrage": 0.1+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=CitadelSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_citadel_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/de_shaw_hedge_fund_agent/de_shaw_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/de_shaw_hedge_fund_agent/de_shaw_agent.pynew file mode 100644index 000000000..0cfb4de80--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/de_shaw_hedge_fund_agent/de_shaw_agent.py@@ -0,0 +1,913 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+import math+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class DEShawSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ computational_models: dict+++def de_shaw_hedge_fund_agent(state: AgentState, agent_id: str = "de_shaw_hedge_fund_agent"):+ """+ D.E. Shaw: Computational finance, quantitative hedge fund+ Structure: Research → Computational Finance → Trading Systems → Risk Control → David Shaw Decision+ Philosophy: Scientific approach, computational methods, systematic strategies+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ de_shaw_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Research team computational analysis")++ metrics = get_financial_metrics(ticker, end_date, period="quarterly", limit=20, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "research_and_development"+ ],+ end_date,+ period="quarterly",+ limit=20,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # DE Shaw's computational analysis structure+ progress.update_status(agent_id, ticker, "Research team analysis")+ research_team = research_team_computational_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Computational finance models")+ computational_finance = computational_finance_models(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Trading systems analysis")+ trading_systems = trading_systems_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk control systems")+ risk_control = risk_control_systems(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "David Shaw systematic decision")+ david_shaw_decision = david_shaw_systematic_decision(+ research_team, computational_finance, trading_systems, risk_control+ )++ # DE Shaw's computational scoring+ total_score = (+ computational_finance["score"] * 0.35 ++ research_team["score"] * 0.25 ++ trading_systems["score"] * 0.2 ++ risk_control["score"] * 0.2+ )++ # DE Shaw's systematic decision framework+ model_confidence = computational_finance.get("model_confidence", 0)+ if total_score >= 8.0 and model_confidence > 0.8:+ signal = "bullish"+ elif total_score <= 3.5 or model_confidence < 0.4:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "research_team": research_team,+ "computational_finance": computational_finance,+ "trading_systems": trading_systems,+ "risk_control": risk_control,+ "david_shaw_decision": david_shaw_decision+ }++ de_shaw_output = generate_de_shaw_output(ticker, analysis_data, state, agent_id)++ de_shaw_analysis[ticker] = {+ "signal": de_shaw_output.signal,+ "confidence": de_shaw_output.confidence,+ "reasoning": de_shaw_output.reasoning,+ "computational_models": de_shaw_output.computational_models+ }++ progress.update_status(agent_id, ticker, "Done", analysis=de_shaw_output.reasoning)++ message = HumanMessage(content=json.dumps(de_shaw_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(de_shaw_analysis, "D.E. Shaw")++ state["data"]["analyst_signals"][agent_id] = de_shaw_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def research_team_computational_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """DE Shaw's research team computational analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No computational research data"}++ # Computational valuation models+ dcf_model_score = run_dcf_computational_model(financial_line_items, market_cap)+ if dcf_model_score > 0.7:+ score += 2.5+ details.append(f"DCF model indicates undervaluation: {dcf_model_score:.2f}")++ # Factor decomposition analysis+ factor_decomp_score = perform_factor_decomposition(metrics, financial_line_items)+ score += factor_decomp_score+ details.append(f"Factor decomposition score: {factor_decomp_score:.2f}")++ # Time series analysis+ time_series_score = conduct_time_series_analysis(financial_line_items)+ if time_series_score > 0.6:+ score += 2+ details.append(f"Time series analysis positive: {time_series_score:.2f}")++ # Cross-sectional analysis+ cross_sectional_score = perform_cross_sectional_analysis(metrics, market_cap)+ score += cross_sectional_score+ details.append(f"Cross-sectional ranking: {cross_sectional_score:.2f}")++ # Alternative data integration+ alt_data_score = integrate_alternative_data(financial_line_items)+ if alt_data_score > 0.5:+ score += 1.5+ details.append(f"Alternative data signals: {alt_data_score:.2f}")++ return {"score": score, "details": "; ".join(details)}+++def computational_finance_models(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """DE Shaw's computational finance models"""+ score = 0+ details = []+ model_outputs = {}++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No computational finance data"}++ # Monte Carlo simulation+ monte_carlo_result = run_monte_carlo_simulation(financial_line_items, market_cap)+ model_outputs["monte_carlo"] = monte_carlo_result+ if monte_carlo_result.get("probability_of_profit", 0) > 0.7:+ score += 3+ details.append(f"Monte Carlo: {monte_carlo_result['probability_of_profit']:.1%} profit probability")++ # Stochastic differential equations+ sde_model_result = apply_sde_models(financial_line_items)+ model_outputs["sde"] = sde_model_result+ score += sde_model_result.get("score", 0)+ details.append(f"SDE model score: {sde_model_result.get('score', 0):.2f}")++ # Machine learning ensemble+ ml_ensemble_result = run_ml_ensemble_models(metrics, financial_line_items)+ model_outputs["ml_ensemble"] = ml_ensemble_result+ if ml_ensemble_result.get("prediction_confidence", 0) > 0.8:+ score += 2.5+ details.append(f"ML ensemble high confidence: {ml_ensemble_result['prediction_confidence']:.1%}")++ # Options pricing models+ options_model_score = analyze_options_pricing_opportunities(market_cap)+ model_outputs["options"] = {"score": options_model_score}+ if options_model_score > 1:+ score += options_model_score+ details.append(f"Options pricing opportunity: {options_model_score:.2f}")++ # Risk-neutral valuation+ risk_neutral_value = calculate_risk_neutral_valuation(financial_line_items, market_cap)+ model_outputs["risk_neutral"] = risk_neutral_value+ if risk_neutral_value.get("upside_potential", 0) > 0.2:+ score += 2+ details.append(f"Risk-neutral upside: {risk_neutral_value['upside_potential']:.1%}")++ # Model confidence calculation+ model_confidence = calculate_model_confidence(model_outputs)++ return {+ "score": score,+ "details": "; ".join(details),+ "model_outputs": model_outputs,+ "model_confidence": model_confidence+ }+++def trading_systems_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """DE Shaw's trading systems analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No trading systems data"}++ # Algorithmic execution analysis+ execution_score = analyze_algorithmic_execution(market_cap)+ score += execution_score+ details.append(f"Execution efficiency score: {execution_score:.2f}")++ # Market microstructure analysis+ microstructure_score = analyze_market_microstructure(financial_line_items, market_cap)+ if microstructure_score > 0.6:+ score += 2+ details.append(f"Microstructure opportunity: {microstructure_score:.2f}")++ # High-frequency signals+ hf_signals = generate_high_frequency_signals(financial_line_items)+ if hf_signals > 0.5:+ score += 1.5+ details.append(f"HF signals positive: {hf_signals:.2f}")++ # Latency arbitrage potential+ latency_arb_score = assess_latency_arbitrage(market_cap)+ score += latency_arb_score+ details.append(f"Latency arbitrage score: {latency_arb_score:.2f}")++ # Market making opportunities+ market_making_score = evaluate_market_making_opportunity(market_cap)+ if market_making_score > 0.7:+ score += 2+ details.append(f"Market making opportunity: {market_making_score:.2f}")++ return {"score": score, "details": "; ".join(details)}+++def risk_control_systems(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """DE Shaw's risk control systems"""+ score = 0+ details = []+ risk_metrics = {}++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No risk control data"}++ # Value-at-Risk calculation+ var_calculation = calculate_advanced_var(financial_line_items)+ risk_metrics["var"] = var_calculation+ if var_calculation < 0.15: # 15% VaR threshold+ score += 2+ details.append(f"Acceptable VaR: {var_calculation:.1%}")++ # Stress testing+ stress_test_results = conduct_comprehensive_stress_testing(financial_line_items)+ risk_metrics["stress_tests"] = stress_test_results+ if stress_test_results.get("pass_rate", 0) > 0.8:+ score += 2+ details.append(f"Stress tests passed: {stress_test_results['pass_rate']:.1%}")++ # Correlation analysis+ correlation_analysis = perform_correlation_analysis(metrics, financial_line_items)+ risk_metrics["correlation"] = correlation_analysis+ if correlation_analysis < 0.5: # Low correlation+ score += 1.5+ details.append("Low correlation with portfolio")++ # Liquidity risk assessment+ liquidity_risk = assess_advanced_liquidity_risk(market_cap)+ risk_metrics["liquidity"] = liquidity_risk+ if liquidity_risk < 0.3:+ score += 1.5+ details.append("Low liquidity risk")++ # Dynamic hedging requirements+ hedging_requirements = calculate_dynamic_hedging_needs(financial_line_items)+ risk_metrics["hedging"] = hedging_requirements+ if hedging_requirements < 0.2: # Low hedging needs+ score += 1+ details.append("Low hedging requirements")++ return {+ "score": score,+ "details": "; ".join(details),+ "risk_metrics": risk_metrics+ }+++def david_shaw_systematic_decision(research_team: dict, computational_finance: dict,+ trading_systems: dict, risk_control: dict) -> dict:+ """David Shaw's systematic computational decision"""+ details = []++ # Computational model synthesis+ research_score = research_team["score"] / 10+ model_confidence = computational_finance.get("model_confidence", 0)+ execution_feasibility = trading_systems["score"] / 10+ risk_acceptability = risk_control["score"] / 8++ # Shaw's decision framework+ overall_systematic_edge = (+ model_confidence * 0.35 ++ research_score * 0.3 ++ execution_feasibility * 0.2 ++ risk_acceptability * 0.15+ )++ # Computational conviction analysis+ model_outputs = computational_finance.get("model_outputs", {})+ monte_carlo_prob = model_outputs.get("monte_carlo", {}).get("probability_of_profit", 0.5)++ # Shaw's systematic decision logic+ if overall_systematic_edge > 0.8 and model_confidence > 0.85:+ if monte_carlo_prob > 0.75:+ decision = "High conviction systematic position"+ details.append("Strong computational edge with high model confidence")+ else:+ decision = "Moderate systematic position"+ details.append("Good computational signals with moderate probability")+ elif overall_systematic_edge > 0.6:+ decision = "Systematic position with enhanced monitoring"+ details.append("Adequate systematic edge requiring close monitoring")+ elif execution_feasibility < 0.4:+ decision = "Pass - execution constraints"+ details.append("Computational edge limited by execution constraints")+ else:+ decision = "Insufficient systematic edge"+ details.append("Computational models do not indicate sufficient edge")++ # Expected Sharpe ratio+ expected_sharpe = overall_systematic_edge * 2 # Target 2.0 Sharpe for top decile++ # Computational complexity assessment+ model_complexity = len(model_outputs) * 0.1++ return {+ "decision": decision,+ "overall_systematic_edge": overall_systematic_edge,+ "expected_sharpe": expected_sharpe,+ "model_complexity": model_complexity,+ "details": "; ".join(details)+ }+++# Computational Finance Helper Functions+def run_dcf_computational_model(financial_line_items: list, market_cap: float) -> float:+ """Run computational DCF model"""+ if not financial_line_items or not market_cap:+ return 0.5++ latest = financial_line_items[0]+ if not latest.free_cash_flow or latest.free_cash_flow <= 0:+ return 0.3++ # Advanced DCF with multiple scenarios+ base_fcf = latest.free_cash_flow++ # Scenario analysis+ scenarios = [+ {"growth": 0.05, "terminal_multiple": 12, "probability": 0.3},+ {"growth": 0.08, "terminal_multiple": 15, "probability": 0.4},+ {"growth": 0.12, "terminal_multiple": 18, "probability": 0.3}+ ]++ expected_value = 0+ for scenario in scenarios:+ scenario_value = 0+ for year in range(1, 6):+ future_fcf = base_fcf * (1 + scenario["growth"]) ** year+ pv = future_fcf / (1.1 ** year) # 10% discount rate+ scenario_value += pv++ # Terminal value+ terminal_fcf = base_fcf * (1 + scenario["growth"]) ** 5+ terminal_value = terminal_fcf * scenario["terminal_multiple"] / (1.1 ** 5)+ scenario_value += terminal_value++ expected_value += scenario_value * scenario["probability"]++ # Compare to market cap+ if expected_value > market_cap:+ upside = (expected_value - market_cap) / market_cap+ return min(upside / 0.5, 1.0) # Normalize by 50% upside++ return 0.3+++def perform_factor_decomposition(metrics: list, financial_line_items: list) -> float:+ """Perform advanced factor decomposition"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ factor_score = 0++ # Value factor+ if latest.price_to_book:+ value_score = max(0, 1 - (latest.price_to_book / 2))+ factor_score += value_score * 0.3++ # Quality factor+ if latest.return_on_equity:+ quality_score = min(latest.return_on_equity / 0.2, 1.0)+ factor_score += quality_score * 0.3++ # Growth factor+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ growth_rate = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ growth_score = min(growth_rate / 0.15, 1.0)+ factor_score += growth_score * 0.4++ return factor_score+++def conduct_time_series_analysis(financial_line_items: list) -> float:+ """Conduct advanced time series analysis"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) < 8:+ return 0.4++ # Trend analysis using linear regression+ n = len(revenues)+ x_mean = (n - 1) / 2+ y_mean = sum(revenues) / n++ numerator = sum((i - x_mean) * (revenues[i] - y_mean) for i in range(n))+ denominator = sum((i - x_mean) ** 2 for i in range(n))++ if denominator > 0:+ slope = numerator / denominator+ r_squared = (numerator ** 2) / (denominator * sum((y - y_mean) ** 2 for y in revenues))++ # Positive trend with good fit+ if slope > 0 and r_squared > 0.6:+ return min((slope / y_mean) * 10 * r_squared, 1.0)++ return 0.4+++def perform_cross_sectional_analysis(metrics: list, market_cap: float) -> float:+ """Perform cross-sectional ranking analysis"""+ if not metrics:+ return 0.5++ latest = metrics[0]++ # Multi-factor ranking+ ranking_score = 0++ if latest.return_on_equity:+ roe_percentile = min(latest.return_on_equity / 0.25, 1.0)+ ranking_score += roe_percentile * 0.3++ if latest.price_to_earnings and latest.price_to_earnings > 0:+ pe_percentile = max(0, 1 - (latest.price_to_earnings / 25))+ ranking_score += pe_percentile * 0.3++ # Size factor+ size_factor = min(math.log10(market_cap / 1_000_000_000) / 2, 1.0)+ ranking_score += size_factor * 0.4++ return ranking_score+++def integrate_alternative_data(financial_line_items: list) -> float:+ """Integrate alternative data signals"""+ # Simulated alternative data integration+ base_fundamentals = 0.5++ # Would integrate satellite data, credit card transactions, etc.+ alt_data_boost = 0.2 # Placeholder++ return min(base_fundamentals + alt_data_boost, 1.0)+++def run_monte_carlo_simulation(financial_line_items: list, market_cap: float) -> dict:+ """Run Monte Carlo simulation for price prediction"""+ if not financial_line_items:+ return {"probability_of_profit": 0.5}++ # Simulate 10,000 paths+ num_simulations = 1000 # Reduced for computational efficiency+ profitable_outcomes = 0++ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ # Calculate historical volatility+ growth_rates = [(revenues[i] / revenues[i + 1]) - 1 for i in range(len(revenues) - 1)]+ mean_growth = sum(growth_rates) / len(growth_rates)+ volatility = (sum((g - mean_growth) ** 2 for g in growth_rates) / len(growth_rates)) ** 0.5++ # Monte Carlo simulation+ for _ in range(num_simulations):+ # Simulate 1-year forward performance+ random_shock = (hash(str(_)) % 1000 - 500) / 500 # Pseudo-random between -1 and 1+ simulated_return = mean_growth + random_shock * volatility++ if simulated_return > 0.05: # 5% profit threshold+ profitable_outcomes += 1++ probability_of_profit = profitable_outcomes / num_simulations+ else:+ probability_of_profit = 0.5++ return {+ "probability_of_profit": probability_of_profit,+ "simulations": num_simulations+ }+++def apply_sde_models(financial_line_items: list) -> dict:+ """Apply stochastic differential equation models"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) < 6:+ return {"score": 0.5}++ # Geometric Brownian Motion model for revenue evolution+ # dS = μS dt + σS dW++ # Calculate drift (μ) and volatility (σ)+ growth_rates = [(revenues[i] / revenues[i + 1]) - 1 for i in range(len(revenues) - 1)]+ drift = sum(growth_rates) / len(growth_rates)+ volatility = (sum((g - drift) ** 2 for g in growth_rates) / len(growth_rates)) ** 0.5++ # SDE score based on favorable drift and manageable volatility+ if drift > 0.05 and volatility < 0.3:+ sde_score = min(drift / volatility, 1.0) if volatility > 0 else 0.5+ else:+ sde_score = 0.3++ return {"score": sde_score, "drift": drift, "volatility": volatility}+++def run_ml_ensemble_models(metrics: list, financial_line_items: list) -> dict:+ """Run machine learning ensemble models"""+ if not metrics or not financial_line_items:+ return {"prediction_confidence": 0.5}++ # Simulate ensemble of models+ models = ["random_forest", "gradient_boosting", "neural_network", "svm"]+ predictions = []++ for model in models:+ # Simplified model predictions based on fundamentals+ latest = metrics[0]+ if latest.return_on_equity and latest.price_to_earnings:+ if model == "random_forest":+ pred = min(latest.return_on_equity * 3, 1.0)+ elif model == "gradient_boosting":+ pred = max(0, 1 - (latest.price_to_earnings / 20))+ elif model == "neural_network":+ pred = (latest.return_on_equity * 2 + (1 - latest.price_to_earnings / 25)) / 2+ else: # SVM+ pred = 0.5 + (latest.return_on_equity - 0.1) * 2++ predictions.append(max(0, min(pred, 1.0)))+ else:+ predictions.append(0.5)++ # Ensemble prediction+ ensemble_pred = sum(predictions) / len(predictions)++ # Confidence based on model agreement+ variance = sum((p - ensemble_pred) ** 2 for p in predictions) / len(predictions)+ confidence = max(0, 1 - variance * 4)++ return {+ "ensemble_prediction": ensemble_pred,+ "prediction_confidence": confidence,+ "individual_predictions": dict(zip(models, predictions))+ }+++def analyze_options_pricing_opportunities(market_cap: float) -> float:+ """Analyze options pricing opportunities"""+ # Larger companies have more liquid options markets+ if market_cap > 50_000_000_000: # $50B++ return 1.5+ elif market_cap > 10_000_000_000: # $10B++ return 1.0+ elif market_cap > 1_000_000_000: # $1B++ return 0.5+ else:+ return 0.2+++def calculate_risk_neutral_valuation(financial_line_items: list, market_cap: float) -> dict:+ """Calculate risk-neutral valuation"""+ if not financial_line_items or not market_cap:+ return {"upside_potential": 0}++ latest = financial_line_items[0]+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ # Risk-neutral DCF at risk-free rate+ risk_free_rate = 0.03 # 3% risk-free rate+ risk_neutral_value = latest.free_cash_flow / risk_free_rate # Perpetuity++ upside_potential = (risk_neutral_value - market_cap) / market_cap+ return {"upside_potential": max(0, upside_potential)}++ return {"upside_potential": 0}+++def calculate_model_confidence(model_outputs: dict) -> float:+ """Calculate overall model confidence"""+ confidence_scores = []++ if "monte_carlo" in model_outputs:+ mc_prob = model_outputs["monte_carlo"].get("probability_of_profit", 0.5)+ confidence_scores.append(abs(mc_prob - 0.5) * 2) # Distance from 50%++ if "ml_ensemble" in model_outputs:+ ml_conf = model_outputs["ml_ensemble"].get("prediction_confidence", 0.5)+ confidence_scores.append(ml_conf)++ if "sde" in model_outputs:+ sde_score = model_outputs["sde"].get("score", 0.5)+ confidence_scores.append(sde_score)++ return sum(confidence_scores) / len(confidence_scores) if confidence_scores else 0.5+++def analyze_algorithmic_execution(market_cap: float) -> float:+ """Analyze algorithmic execution efficiency"""+ # Execution efficiency based on market cap and liquidity+ if market_cap > 100_000_000_000: # $100B++ return 2.0+ elif market_cap > 20_000_000_000: # $20B++ return 1.5+ elif market_cap > 5_000_000_000: # $5B++ return 1.0+ else:+ return 0.5+++def analyze_market_microstructure(financial_line_items: list, market_cap: float) -> float:+ """Analyze market microstructure opportunities"""+ # Microstructure opportunities in larger, more liquid names+ liquidity_score = min(market_cap / 10_000_000_000, 1.0) # Normalize by $10B++ # Add fundamental volatility component+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues:+ volatility = calculate_coefficient_of_variation(revenues)+ volatility_score = min(volatility, 1.0)+ return (liquidity_score + volatility_score) / 2++ return liquidity_score+++def generate_high_frequency_signals(financial_line_items: list) -> float:+ """Generate high-frequency trading signals"""+ # HF signals based on earnings volatility and predictability+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) >= 8:+ # Look for patterns in quarterly earnings+ earnings_changes = [earnings[i] - earnings[i + 1] for i in range(len(earnings) - 1)]+ if earnings_changes:+ autocorr = calculate_autocorrelation(earnings_changes, 1)+ return min(abs(autocorr), 1.0)++ return 0.4+++def assess_latency_arbitrage(market_cap: float) -> float:+ """Assess latency arbitrage opportunities"""+ # Latency arbitrage more viable in larger, more traded stocks+ if market_cap > 50_000_000_000: # $50B++ return 1.0+ elif market_cap > 10_000_000_000: # $10B++ return 0.7+ else:+ return 0.3+++def evaluate_market_making_opportunity(market_cap: float) -> float:+ """Evaluate market making opportunity"""+ # Market making viability based on trading volume proxy (market cap)+ if market_cap > 20_000_000_000: # $20B++ return 0.9+ elif market_cap > 5_000_000_000: # $5B++ return 0.7+ elif market_cap > 1_000_000_000: # $1B++ return 0.5+ else:+ return 0.2+++def calculate_advanced_var(financial_line_items: list) -> float:+ """Calculate advanced Value-at-Risk"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) >= 8:+ # Calculate 95% VaR using historical simulation+ sorted_earnings = sorted(earnings)+ var_index = int(len(sorted_earnings) * 0.05)+ worst_5pct = sorted_earnings[:var_index + 1]++ if worst_5pct and max(earnings) > 0:+ var_loss = (max(earnings) - min(worst_5pct)) / max(earnings)+ return var_loss++ return 0.2 # Default 20% VaR+++def conduct_comprehensive_stress_testing(financial_line_items: list) -> dict:+ """Conduct comprehensive stress testing"""+ stress_scenarios = [+ "market_crash", "recession", "sector_downturn",+ "liquidity_crisis", "interest_rate_shock"+ ]++ passed_tests = 0++ # Simplified stress testing based on historical performance+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if earnings and revenues:+ # Test earnings stability (recession scenario)+ negative_earnings = sum(1 for e in earnings if e < 0)+ if negative_earnings <= len(earnings) * 0.2: # <20% negative years+ passed_tests += 2++ # Test revenue resilience+ revenue_declines = sum(1 for i in range(len(revenues) - 1) if revenues[i] < revenues[i + 1])+ if revenue_declines <= len(revenues) * 0.3: # <30% declining years+ passed_tests += 2++ # Test margin stability (sector downturn)+ if len(earnings) == len(revenues):+ margins = [earnings[i] / revenues[i] if revenues[i] > 0 else 0 for i in range(len(earnings))]+ margin_volatility = calculate_coefficient_of_variation(margins)+ if margin_volatility < 0.5:+ passed_tests += 1++ pass_rate = passed_tests / len(stress_scenarios)++ return {+ "pass_rate": pass_rate,+ "tests_passed": passed_tests,+ "total_tests": len(stress_scenarios)+ }+++def perform_correlation_analysis(metrics: list, financial_line_items: list) -> float:+ """Perform correlation analysis with market factors"""+ # Simplified correlation analysis+ # In practice, would correlate with market indices, sector ETFs, etc.++ if not metrics or not financial_line_items:+ return 0.6 # Default moderate correlation++ # Proxy correlation using business fundamentals+ latest = metrics[0]++ # High ROE, reasonable valuation suggests lower market correlation+ if latest.return_on_equity and latest.price_to_earnings:+ if latest.return_on_equity > 0.15 and latest.price_to_earnings < 20:+ return 0.3 # Low correlation - idiosyncratic opportunity++ return 0.6 # Moderate correlation+++def assess_advanced_liquidity_risk(market_cap: float) -> float:+ """Assess advanced liquidity risk"""+ # Liquidity risk inversely related to market cap+ if market_cap > 100_000_000_000: # $100B++ return 0.05+ elif market_cap > 20_000_000_000: # $20B++ return 0.1+ elif market_cap > 5_000_000_000: # $5B++ return 0.2+ elif market_cap > 1_000_000_000: # $1B++ return 0.4+ else:+ return 0.7+++def calculate_dynamic_hedging_needs(financial_line_items: list) -> float:+ """Calculate dynamic hedging requirements"""+ # Hedging needs based on business volatility+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ earnings = [item.net_income for item in financial_line_items if item.net_income]++ hedging_score = 0++ if revenues:+ revenue_volatility = calculate_coefficient_of_variation(revenues)+ hedging_score += revenue_volatility * 0.5++ if earnings:+ earnings_volatility = calculate_coefficient_of_variation(earnings)+ hedging_score += earnings_volatility * 0.5++ return min(hedging_score, 1.0)+++def calculate_coefficient_of_variation(data: list) -> float:+ """Calculate coefficient of variation"""+ if not data or len(data) < 2:+ return 1.0++ mean_val = sum(data) / len(data)+ if mean_val == 0:+ return 1.0++ variance = sum((x - mean_val) ** 2 for x in data) / len(data)+ std_dev = (variance ** 0.5)++ return std_dev / abs(mean_val)+++def calculate_autocorrelation(data: list, lag: int) -> float:+ """Calculate autocorrelation with given lag"""+ if len(data) <= lag:+ return 0++ mean_val = sum(data) / len(data)+ numerator = sum((data[i] - mean_val) * (data[i + lag] - mean_val)+ for i in range(len(data) - lag))+ denominator = sum((x - mean_val) ** 2 for x in data)++ return numerator / denominator if denominator != 0 else 0+++def generate_de_shaw_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> DEShawSignal:+ """Generate DE Shaw's computational finance investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are D.E. Shaw's AI system, implementing David Shaw's computational finance approach:++ ORGANIZATIONAL STRUCTURE:+ - Research Team: Computational analysis and quantitative research+ - Computational Finance: Monte Carlo, SDE models, ML ensemble, options pricing+ - Trading Systems: Algorithmic execution, HFT, market microstructure+ - Risk Control: Advanced VaR, stress testing, correlation analysis+ - David Shaw Systematic Decision: Scientific computational synthesis++ PHILOSOPHY:+ 1. Computational Finance: Advanced mathematical and computational methods+ 2. Scientific Approach: Rigorous quantitative analysis and modeling+ 3. Systematic Strategies: Algorithm-driven investment decisions+ 4. Risk Management: Sophisticated risk control and hedging+ 5. Technology Edge: Cutting-edge computational infrastructure+ 6. Market Efficiency: Exploit computational advantages and inefficiencies+ 7. Diversification: Multiple uncorrelated computational strategies++ REASONING STYLE:+ - Reference computational models and mathematical analysis+ - Discuss Monte Carlo simulations and stochastic processes+ - Apply machine learning and statistical methods+ - Consider execution algorithms and market microstructure+ - Express confidence in computational edge and model validation+ - Analyze risk-adjusted returns and Sharpe ratios+ - Focus on systematic, repeatable investment processes++ Return investment signal with computational model outputs and confidence metrics."""),++ ("human", """Apply D.E. Shaw's computational analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "computational_models": {{+ "monte_carlo_probability": float,+ "ml_ensemble_prediction": float,+ "sde_model_score": float,+ "risk_neutral_upside": float,+ "model_confidence": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_de_shaw_signal():+ return DEShawSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ computational_models={+ "monte_carlo_probability": 0.5,+ "ml_ensemble_prediction": 0.5,+ "sde_model_score": 0.5,+ "risk_neutral_upside": 0.0,+ "model_confidence": 0.5+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=DEShawSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_de_shaw_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/elliott_management_hedge_fund_agent/elliott_management_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/elliott_management_hedge_fund_agent/elliott_management_agent.pynew file mode 100644index 000000000..85f19418f--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/elliott_management_hedge_fund_agent/elliott_management_agent.py@@ -0,0 +1,825 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class ElliottSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ activist_potential: dict+++def elliott_management_hedge_fund_agent(state: AgentState, agent_id: str = "elliott_management_hedge_fund_agent"):+ """+ Elliott Management: Activist investing, event-driven strategies+ Structure: Research → Legal → Activism → Event-Driven → Paul Singer Decision+ Philosophy: Catalyst-driven value creation, shareholder activism, distressed opportunities+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ elliott_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Research team analyzing activist opportunity")++ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=6, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "research_and_development"+ ],+ end_date,+ period="annual",+ limit=6,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Elliott's activist-focused analysis structure+ progress.update_status(agent_id, ticker, "Research team fundamental analysis")+ research_team = research_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Legal team governance analysis")+ legal_team = legal_team_governance_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Activism team catalyst identification")+ activism_team = activism_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Event-driven team analysis")+ event_driven_team = event_driven_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Paul Singer strategic decision")+ paul_singer_decision = paul_singer_strategic_decision(+ research_team, legal_team, activism_team, event_driven_team+ )++ # Elliott's catalyst-weighted scoring+ total_score = (+ activism_team["score"] * 0.35 ++ research_team["score"] * 0.25 ++ event_driven_team["score"] * 0.2 ++ legal_team["score"] * 0.2+ )++ # Elliott's activist decision framework+ activist_potential = activism_team.get("activist_score", 0)+ if total_score >= 7.5 and activist_potential > 0.7:+ signal = "bullish"+ elif total_score <= 4.0 or legal_team.get("governance_score", 0) < 0.3:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "research_team": research_team,+ "legal_team": legal_team,+ "activism_team": activism_team,+ "event_driven_team": event_driven_team,+ "paul_singer_decision": paul_singer_decision+ }++ elliott_output = generate_elliott_output(ticker, analysis_data, state, agent_id)++ elliott_analysis[ticker] = {+ "signal": elliott_output.signal,+ "confidence": elliott_output.confidence,+ "reasoning": elliott_output.reasoning,+ "activist_potential": elliott_output.activist_potential+ }++ progress.update_status(agent_id, ticker, "Done", analysis=elliott_output.reasoning)++ message = HumanMessage(content=json.dumps(elliott_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(elliott_analysis, "Elliott Management")++ state["data"]["analyst_signals"][agent_id] = elliott_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def research_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Elliott's research team fundamental analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No research data"}++ # Hidden asset value+ asset_value_opportunity = analyze_hidden_asset_value(financial_line_items, market_cap)+ if asset_value_opportunity > 0.3:+ score += 3+ details.append(f"Hidden asset value opportunity: {asset_value_opportunity:.1%} of market cap")++ # Underperforming business segments+ business_optimization = identify_business_optimization_opportunities(financial_line_items)+ if business_optimization > 0.6:+ score += 2.5+ details.append("Significant business optimization opportunities identified")++ # Capital allocation inefficiencies+ capital_allocation_issues = analyze_capital_allocation_inefficiencies(financial_line_items)+ if capital_allocation_issues > 0.7:+ score += 2+ details.append("Poor capital allocation creating value opportunity")++ # Margin improvement potential+ margin_expansion_potential = analyze_margin_expansion_potential(financial_line_items)+ if margin_expansion_potential > 0.5:+ score += 1.5+ details.append(f"Margin expansion potential: {margin_expansion_potential:.1%}")++ # Sum-of-the-parts analysis+ sotp_discount = calculate_sum_of_parts_discount(financial_line_items, market_cap)+ if sotp_discount > 0.2:+ score += 2+ details.append(f"Sum-of-parts discount: {sotp_discount:.1%}")++ return {"score": score, "details": "; ".join(details)}+++def legal_team_governance_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Elliott's legal team corporate governance analysis"""+ score = 0+ details = []+ governance_issues = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No governance data"}++ # Management accountability+ management_performance = assess_management_performance(metrics, financial_line_items)+ if management_performance < 0.4:+ governance_issues.append("Poor management performance")+ score += 2 # Opportunity for change+ details.append("Management underperformance creates activist opportunity")++ # Board composition analysis+ board_independence = analyze_board_independence_proxy(financial_line_items)+ if board_independence < 0.6:+ governance_issues.append("Board independence concerns")+ score += 1.5+ details.append("Board independence issues identified")++ # Executive compensation analysis+ compensation_alignment = analyze_executive_compensation_proxy(financial_line_items)+ if compensation_alignment < 0.5:+ governance_issues.append("Executive compensation misalignment")+ score += 1.5+ details.append("Executive compensation not aligned with performance")++ # Shareholder rights+ shareholder_rights_score = assess_shareholder_rights_proxy(market_cap)+ if shareholder_rights_score > 0.7:+ score += 2+ details.append("Strong shareholder rights framework")++ # Acquisition defense analysis+ takeover_defenses = analyze_takeover_defenses_proxy(market_cap)+ if takeover_defenses < 0.5:+ score += 1+ details.append("Limited takeover defenses")++ governance_score = score / 8 # Normalize to 0-1++ if governance_issues:+ details.append(f"Governance issues: {'; '.join(governance_issues)}")++ return {+ "score": score,+ "details": "; ".join(details),+ "governance_issues": governance_issues,+ "governance_score": governance_score+ }+++def activism_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Elliott's activism team catalyst and campaign analysis"""+ score = 0+ details = []+ activist_catalysts = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No activism data"}++ # Strategic alternatives analysis+ strategic_alternatives = identify_strategic_alternatives(financial_line_items, market_cap)+ if strategic_alternatives > 0.7:+ score += 3+ activist_catalysts.append("Strategic alternatives")+ details.append("Strong case for strategic alternatives (spin-offs, sales)")++ # Operational turnaround potential+ turnaround_potential = assess_operational_turnaround_potential(financial_line_items)+ if turnaround_potential > 0.6:+ score += 2.5+ activist_catalysts.append("Operational improvements")+ details.append("Significant operational turnaround opportunity")++ # Balance sheet optimization+ balance_sheet_optimization = analyze_balance_sheet_optimization(financial_line_items)+ if balance_sheet_optimization > 0.5:+ score += 2+ activist_catalysts.append("Balance sheet optimization")+ details.append("Balance sheet optimization opportunities")++ # Market position improvement+ market_position_catalyst = analyze_market_position_catalyst(financial_line_items)+ if market_position_catalyst > 0.6:+ score += 1.5+ activist_catalysts.append("Market position improvement")+ details.append("Market position improvement potential")++ # Management change catalyst+ management_change_potential = assess_management_change_potential(metrics, financial_line_items)+ if management_change_potential > 0.7:+ score += 2+ activist_catalysts.append("Management change")+ details.append("Strong case for management changes")++ # ESG improvement opportunities+ esg_catalyst = identify_esg_improvement_opportunities(financial_line_items)+ if esg_catalyst > 0.5:+ score += 1+ activist_catalysts.append("ESG improvements")+ details.append("ESG improvement opportunities identified")++ activist_score = score / 12 # Normalize to 0-1++ return {+ "score": score,+ "details": "; ".join(details),+ "activist_catalysts": activist_catalysts,+ "activist_score": activist_score+ }+++def event_driven_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Elliott's event-driven team analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No event-driven data"}++ # M&A probability analysis+ ma_probability = assess_ma_probability(financial_line_items, market_cap)+ if ma_probability > 0.6:+ score += 3+ details.append(f"High M&A probability: {ma_probability:.1%}")++ # Spin-off opportunities+ spinoff_potential = analyze_spinoff_potential(financial_line_items)+ if spinoff_potential > 0.7:+ score += 2.5+ details.append("Strong spin-off potential identified")++ # Special dividend potential+ special_dividend_potential = analyze_special_dividend_potential(financial_line_items)+ if special_dividend_potential > 0.6:+ score += 2+ details.append("Special dividend potential")++ # Distressed situation analysis+ distressed_opportunity = analyze_distressed_opportunity(financial_line_items)+ if distressed_opportunity > 0.5:+ score += 2+ details.append("Distressed investment opportunity")++ # Regulatory catalyst analysis+ regulatory_catalyst = identify_regulatory_catalysts(financial_line_items)+ if regulatory_catalyst > 0.5:+ score += 1.5+ details.append("Regulatory catalysts identified")++ # Litigation catalyst+ litigation_catalyst = assess_litigation_catalyst_potential(financial_line_items)+ if litigation_catalyst > 0.4:+ score += 1+ details.append("Potential litigation catalysts")++ return {"score": score, "details": "; ".join(details)}+++def paul_singer_strategic_decision(research_team: dict, legal_team: dict,+ activism_team: dict, event_driven_team: dict) -> dict:+ """Paul Singer's strategic decision framework"""+ details = []++ # Elliott's decision framework+ fundamental_value = research_team["score"] / 10+ governance_opportunity = legal_team["score"] / 8+ activist_potential = activism_team.get("activist_score", 0)+ event_catalyst = event_driven_team["score"] / 10++ # Paul Singer's strategic analysis+ overall_opportunity = (+ fundamental_value * 0.3 ++ activist_potential * 0.35 ++ event_catalyst * 0.25 ++ governance_opportunity * 0.1+ )++ # Campaign complexity assessment+ campaign_complexity = assess_campaign_complexity(activism_team, legal_team)++ # Risk-reward analysis+ if overall_opportunity > 0.8 and activist_potential > 0.7:+ if campaign_complexity < 0.6:+ decision = "Launch activist campaign"+ details.append("High-conviction activist opportunity with manageable complexity")+ else:+ decision = "Complex activist situation - detailed planning required"+ details.append("High opportunity but complex campaign execution needed")+ elif overall_opportunity > 0.6:+ if event_catalyst > 0.7:+ decision = "Event-driven position"+ details.append("Strong event-driven catalyst without activism requirement")+ else:+ decision = "Moderate activist position"+ details.append("Moderate opportunity for value creation through activism")+ elif fundamental_value > 0.6 and activist_potential < 0.4:+ decision = "Traditional value investment"+ details.append("Fundamental value present but limited activist opportunity")+ else:+ decision = "Pass - insufficient catalyst potential"+ details.append("Insufficient catalyst opportunity for Elliott's strategy")++ # Timeline assessment+ if "Management change" in activism_team.get("activist_catalysts", []):+ expected_timeline = "12-18 months"+ elif "Strategic alternatives" in activism_team.get("activist_catalysts", []):+ expected_timeline = "18-24 months"+ else:+ expected_timeline = "6-12 months"++ return {+ "decision": decision,+ "overall_opportunity": overall_opportunity,+ "campaign_complexity": campaign_complexity,+ "expected_timeline": expected_timeline,+ "details": "; ".join(details)+ }+++# Helper functions for Elliott's analysis+def analyze_hidden_asset_value(financial_line_items: list, market_cap: float) -> float:+ """Analyze hidden asset value opportunities"""+ if not financial_line_items or not market_cap:+ return 0++ latest = financial_line_items[0]++ # Real estate and other assets potentially undervalued+ if latest.total_assets and latest.total_debt:+ net_assets = latest.total_assets - latest.total_debt+ if net_assets > market_cap:+ hidden_value = (net_assets - market_cap) / market_cap+ return min(hidden_value, 1.0)++ return 0+++def identify_business_optimization_opportunities(financial_line_items: list) -> float:+ """Identify business optimization opportunities"""+ # Look for declining margins or inconsistent performance+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]++ if len(margins) >= 3:+ recent_margin = margins[0]+ historical_best = max(margins)++ if historical_best > recent_margin * 1.3: # 30%+ margin decline from peak+ return 0.8 # High optimization opportunity+ elif historical_best > recent_margin * 1.15: # 15%+ margin decline+ return 0.6 # Moderate optimization opportunity++ return 0.3+++def analyze_capital_allocation_inefficiencies(financial_line_items: list) -> float:+ """Analyze capital allocation inefficiencies"""+ # Look for poor FCF to earnings conversion or excessive capex+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ earnings = [item.net_income for item in financial_line_items if item.net_income]++ if fcf_vals and earnings and len(fcf_vals) == len(earnings):+ total_fcf = sum(fcf_vals)+ total_earnings = sum(earnings)++ if total_earnings > 0:+ cash_conversion = total_fcf / total_earnings+ if cash_conversion < 0.6: # Poor cash conversion+ return 0.8+ elif cash_conversion < 0.8:+ return 0.5++ return 0.3+++def analyze_margin_expansion_potential(financial_line_items: list) -> float:+ """Analyze margin expansion potential"""+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]++ if margins:+ current_margin = margins[0]+ if current_margin < 0.1: # <10% operating margin+ return 0.7 # High margin expansion potential+ elif current_margin < 0.15: # <15% operating margin+ return 0.5 # Moderate margin expansion potential++ return 0.2+++def calculate_sum_of_parts_discount(financial_line_items: list, market_cap: float) -> float:+ """Calculate sum-of-the-parts discount (simplified)"""+ # This would typically require detailed business segment analysis+ # Simplified approach based on total assets vs market cap++ if not financial_line_items or not market_cap:+ return 0++ latest = financial_line_items[0]+ if latest.total_assets:+ # Assume asset-based valuation at 1.2x book value+ estimated_sotp_value = latest.total_assets * 1.2+ if estimated_sotp_value > market_cap:+ discount = (estimated_sotp_value - market_cap) / market_cap+ return min(discount, 0.5) # Cap at 50%++ return 0+++def assess_management_performance(metrics: list, financial_line_items: list) -> float:+ """Assess management performance"""+ if not metrics:+ return 0.5++ # ROE trend analysis+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if len(roe_vals) >= 3:+ recent_roe = sum(roe_vals[:2]) / 2+ historical_roe = sum(roe_vals[2:]) / len(roe_vals[2:])++ if recent_roe > historical_roe * 1.2:+ return 0.8 # Improving performance+ elif recent_roe < historical_roe * 0.8:+ return 0.3 # Declining performance++ # Revenue growth consistency+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ consistency = growth_years / (len(revenues) - 1)+ return consistency++ return 0.5+++def analyze_board_independence_proxy(financial_line_items: list) -> float:+ """Analyze board independence (proxy through governance metrics)"""+ # In practice, would analyze board composition data+ # Proxy: companies with consistent performance likely have better governance++ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ positive_years = sum(1 for e in earnings if e > 0)+ return positive_years / len(earnings)++ return 0.6 # Default moderate score+++def analyze_executive_compensation_proxy(financial_line_items: list) -> float:+ """Analyze executive compensation alignment (proxy)"""+ # Proxy: FCF growth vs revenue growth alignment+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(fcf_vals) >= 3 and len(revenues) >= 3:+ fcf_growth = (fcf_vals[0] / fcf_vals[-1]) - 1+ revenue_growth = (revenues[0] / revenues[-1]) - 1++ # Good alignment if FCF grows faster than revenue+ if fcf_growth > revenue_growth:+ return 0.8+ elif fcf_growth > revenue_growth * 0.8:+ return 0.6++ return 0.4 # Poor alignment assumed+++def assess_shareholder_rights_proxy(market_cap: float) -> float:+ """Assess shareholder rights (proxy through market cap)"""+ # Larger companies typically have better shareholder rights+ if market_cap > 10_000_000_000: # $10B++ return 0.8+ elif market_cap > 1_000_000_000: # $1B++ return 0.6+ else:+ return 0.4+++def analyze_takeover_defenses_proxy(market_cap: float) -> float:+ """Analyze takeover defenses (proxy)"""+ # Smaller companies typically have fewer defenses+ if market_cap < 5_000_000_000: # <$5B+ return 0.3 # Limited defenses+ elif market_cap < 20_000_000_000: # <$20B+ return 0.6 # Moderate defenses+ else:+ return 0.8 # Strong defenses+++def identify_strategic_alternatives(financial_line_items: list, market_cap: float) -> float:+ """Identify strategic alternatives potential"""+ if not financial_line_items:+ return 0++ latest = financial_line_items[0]++ # Look for conglomerate discount or diversified business+ # Proxy: high asset base relative to market cap suggests complex structure+ if latest.total_assets and market_cap:+ asset_ratio = latest.total_assets / market_cap+ if asset_ratio > 3: # Highly asset-intensive+ return 0.8+ elif asset_ratio > 2:+ return 0.6++ return 0.4+++def assess_operational_turnaround_potential(financial_line_items: list) -> float:+ """Assess operational turnaround potential"""+ # Look for declining margins with stable/growing revenue+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(margins) >= 3 and len(revenues) >= 3:+ margin_trend = margins[0] - margins[-1] # Recent vs historical+ revenue_stability = revenues[0] / revenues[-1] # Growth ratio++ if margin_trend < -0.05 and revenue_stability > 0.9: # Declining margins, stable revenue+ return 0.8+ elif margin_trend < 0 and revenue_stability > 0.8:+ return 0.6++ return 0.3+++def analyze_balance_sheet_optimization(financial_line_items: list) -> float:+ """Analyze balance sheet optimization opportunities"""+ if not financial_line_items:+ return 0++ latest = financial_line_items[0]++ # Look for excess cash or conservative capital structure+ if latest.current_assets and latest.current_liabilities:+ excess_liquidity = latest.current_assets - latest.current_liabilities+ if latest.total_assets and excess_liquidity > latest.total_assets * 0.2:+ return 0.8 # Significant excess cash++ # Low debt utilization+ if latest.total_debt and latest.shareholders_equity:+ debt_ratio = latest.total_debt / latest.shareholders_equity+ if debt_ratio < 0.3: # Very conservative+ return 0.6++ return 0.3+++def analyze_market_position_catalyst(financial_line_items: list) -> float:+ """Analyze market position improvement catalyst"""+ # Look for companies with declining market share (revenue issues)+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if len(revenues) >= 4:+ recent_decline = revenues[0] < revenues[1]+ historical_strength = max(revenues[2:]) > revenues[0] * 1.2++ if recent_decline and historical_strength:+ return 0.7 # Lost market position, recovery potential++ return 0.4+++def assess_management_change_potential(metrics: list, financial_line_items: list) -> float:+ """Assess management change potential"""+ # Poor performance metrics suggest management change opportunity+ management_score = assess_management_performance(metrics, financial_line_items)++ if management_score < 0.3:+ return 0.8 # Strong case for management change+ elif management_score < 0.5:+ return 0.6 # Moderate case for management change++ return 0.2+++def identify_esg_improvement_opportunities(financial_line_items: list) -> float:+ """Identify ESG improvement opportunities"""+ # Proxy through R&D spending and operational efficiency+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if rd_vals and revenues:+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])+ if rd_intensity < 0.02: # <2% R&D intensity+ return 0.6 # ESG improvement opportunity through innovation++ return 0.4+++def assess_ma_probability(financial_line_items: list, market_cap: float) -> float:+ """Assess M&A probability"""+ if not financial_line_items or not market_cap:+ return 0++ latest = financial_line_items[0]++ # Attractive M&A targets: strong assets, reasonable valuation+ if latest.total_assets and latest.total_debt:+ net_assets = latest.total_assets - latest.total_debt+ asset_multiple = market_cap / net_assets if net_assets > 0 else 0++ if 0.8 <= asset_multiple <= 1.5: # Reasonable valuation+ return 0.7+ elif asset_multiple < 0.8: # Cheap+ return 0.6++ return 0.3+++def analyze_spinoff_potential(financial_line_items: list) -> float:+ """Analyze spin-off potential"""+ # Look for complex business structures (high assets, multiple segments implied)+ if not financial_line_items:+ return 0++ latest = financial_line_items[0]++ # Proxy: high asset base suggests complex business+ if latest.total_assets and latest.revenue:+ asset_intensity = latest.total_assets / latest.revenue+ if asset_intensity > 3: # Very asset-intensive+ return 0.8+ elif asset_intensity > 2:+ return 0.6++ return 0.3+++def analyze_special_dividend_potential(financial_line_items: list) -> float:+ """Analyze special dividend potential"""+ # Look for excess cash generation+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]++ if fcf_vals:+ avg_fcf = sum(fcf_vals) / len(fcf_vals)+ if avg_fcf > 0:+ # Check for cash accumulation+ latest = financial_line_items[0]+ if latest.current_assets:+ # Proxy for cash accumulation+ return min(avg_fcf / (latest.current_assets * 0.1), 1.0)++ return 0.3+++def analyze_distressed_opportunity(financial_line_items: list) -> float:+ """Analyze distressed investment opportunity"""+ # Look for financial distress signals+ if not financial_line_items:+ return 0++ latest = financial_line_items[0]++ # High debt, low liquidity+ if latest.total_debt and latest.current_assets and latest.current_liabilities:+ debt_burden = latest.total_debt / latest.current_assets if latest.current_assets > 0 else 10+ liquidity_ratio = latest.current_assets / latest.current_liabilities++ if debt_burden > 2 and liquidity_ratio < 1.2:+ return 0.7 # Distressed situation+ elif debt_burden > 1.5 or liquidity_ratio < 1.0:+ return 0.5 # Some distress++ return 0.2+++def identify_regulatory_catalysts(financial_line_items: list) -> float:+ """Identify regulatory catalysts"""+ # Industry-specific regulatory changes (simplified)+ return 0.4 # Placeholder - would analyze specific industry regulations+++def assess_litigation_catalyst_potential(financial_line_items: list) -> float:+ """Assess litigation catalyst potential"""+ # Look for companies with potential legal value creation+ return 0.3 # Placeholder - would analyze specific legal situations+++def assess_campaign_complexity(activism_team: dict, legal_team: dict) -> float:+ """Assess activist campaign complexity"""+ governance_issues = len(legal_team.get("governance_issues", []))+ activist_catalysts = len(activism_team.get("activist_catalysts", []))++ # More issues = more complex campaign+ complexity_score = (governance_issues * 0.15) + (activist_catalysts * 0.1)++ return min(complexity_score, 1.0)+++def generate_elliott_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> ElliottSignal:+ """Generate Elliott Management's activist investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Elliott Management's AI system, implementing Paul Singer's activist hedge fund approach:++ ORGANIZATIONAL STRUCTURE:+ - Research Team: Fundamental analysis and hidden value identification+ - Legal Team: Corporate governance and shareholder rights analysis+ - Activism Team: Catalyst identification and campaign strategy+ - Event-Driven Team: M&A, spin-offs, and special situations+ - Paul Singer Strategic Decision: Overall campaign and value creation strategy++ PHILOSOPHY:+ 1. Catalyst-Driven Investing: Focus on specific catalysts for value creation+ 2. Shareholder Activism: Active engagement to unlock shareholder value+ 3. Event-Driven Opportunities: M&A arbitrage, spin-offs, special situations+ 4. Governance Improvement: Board changes, management accountability+ 5. Strategic Alternatives: Spin-offs, divestitures, strategic sales+ 6. Operational Improvements: Margin expansion, cost reduction+ 7. Balance Sheet Optimization: Capital allocation, leverage, dividends++ REASONING STYLE:+ - Identify specific catalysts and value creation opportunities+ - Assess management performance and governance issues+ - Analyze strategic alternatives and operational improvements+ - Consider campaign complexity and execution timeline+ - Express conviction in activist value creation potential+ - Discuss legal and governance framework for activism+ - Focus on risk-adjusted returns from catalyst realization++ Return investment signal with detailed activist potential analysis."""),++ ("human", """Apply Elliott Management's activist analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "activist_potential": {{+ "catalyst_strength": float,+ "campaign_complexity": float,+ "expected_timeline": "string",+ "value_creation_potential": float,+ "governance_opportunity": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_elliott_signal():+ return ElliottSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ activist_potential={+ "catalyst_strength": 0.5,+ "campaign_complexity": 0.5,+ "expected_timeline": "12-18 months",+ "value_creation_potential": 0.5,+ "governance_opportunity": 0.5+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=ElliottSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_elliott_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/agent_orchestrator.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/agent_orchestrator.pynew file mode 100644index 000000000..59782cdb7--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/agent_orchestrator.py@@ -0,0 +1,562 @@+# -*- coding: utf-8 -*-+# agent_orchestrator.py++import asyncio+import json+import logging+import numpy as np+from datetime import datetime+from typing import Dict, List, Any, Optional+from dataclasses import dataclass+import google.generativeai as genai++# Import all agents+from fincept_terminal.Agents.fincept_hedge_fund.macro_cycle_agent import MacroCycleAgent+from fincept_terminal.Agents.fincept_hedge_fund.central_bank_agent import CentralBankAgent+from fincept_terminal.Agents.fincept_hedge_fund.geopolitical_agent import GeopoliticalAgent+from fincept_terminal.Agents.fincept_hedge_fund.regulatory_agent import RegulatoryAgent+from fincept_terminal.Agents.fincept_hedge_fund.sentiment_agent import SentimentAgent+from fincept_terminal.Agents.fincept_hedge_fund.institutional_flow_agent import InstitutionalFlowAgent+from fincept_terminal.Agents.fincept_hedge_fund.supply_chain_agent import SupplyChainAgent+from fincept_terminal.Agents.fincept_hedge_fund.innovation_agent import InnovationAgent+from fincept_terminal.Agents.fincept_hedge_fund.currency_agent import CurrencyAgent+from fincept_terminal.Agents.fincept_hedge_fund.behavioral_agent import BehavioralAgent+from config import CONFIG+++@dataclass+class AgentDecision:+ """Standardized agent decision structure"""+ agent_name: str+ timestamp: datetime+ signal_strength: float # 0-1+ direction: str # bullish, bearish, neutral+ confidence: float+ key_insights: List[str]+ market_implications: Dict[str, float]+ time_horizon: str+ raw_analysis: Dict[str, Any]+++@dataclass+class ConsensusDecision:+ """Final consensus decision from all agents"""+ timestamp: datetime+ overall_signal: str # strong_buy, buy, hold, sell, strong_sell+ conviction_level: float # 0-1+ asset_allocation: Dict[str, float]+ sector_weights: Dict[str, float]+ risk_level: float+ consensus_factors: List[str]+ dissenting_views: List[str]+ execution_priority: str+++class AgentOrchestrator:+ """Orchestrates multi-agent analysis with inter-agent communication"""++ def __init__(self, gemini_api_key: str):+ # Configure Gemini AI+ genai.configure(api_key=gemini_api_key)+ self.gemini_model = genai.GenerativeModel('gemini-pro')++ # Initialize all agents+ self.agents = {+ 'macro': MacroCycleAgent(),+ 'fed': CentralBankAgent(),+ 'geo': GeopoliticalAgent(),+ 'regulatory': RegulatoryAgent(),+ 'sentiment': SentimentAgent(),+ 'flows': InstitutionalFlowAgent(),+ 'supply': SupplyChainAgent(),+ 'innovation': InnovationAgent(),+ 'fx': CurrencyAgent(),+ 'behavioral': BehavioralAgent()+ }++ # Agent communication weights for decision making+ self.agent_weights = {+ 'macro': 0.20, # Highest weight - drives overall allocation+ 'fed': 0.18, # Critical for duration and rates+ 'geo': 0.15, # Major risk factor+ 'flows': 0.12, # Smart money indicator+ 'sentiment': 0.10, # Contrarian signals+ 'regulatory': 0.08, # Policy impacts+ 'supply': 0.07, # Sector-specific risks+ 'fx': 0.05, # Portfolio hedging+ 'behavioral': 0.03, # Market psychology+ 'innovation': 0.02 # Long-term trends+ }++ # Setup logging+ logging.basicConfig(level=logging.INFO,+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')+ self.logger = logging.getLogger("AgentOrchestrator")++ async def run_comprehensive_analysis(self, target_assets: List[str] = None) -> ConsensusDecision:+ """Run comprehensive analysis with all agents and generate consensus decision"""+ self.logger.info("🚀 Starting comprehensive multi-agent analysis...")++ # Step 1: Run all agents concurrently+ agent_decisions = await self._execute_all_agents()++ # Step 2: Enable agent-to-agent communication+ enriched_decisions = await self._facilitate_agent_communication(agent_decisions)++ # Step 3: Generate consensus using Gemini AI+ consensus = await self._generate_consensus_decision(enriched_decisions, target_assets)++ # Step 4: Validate and refine decision+ final_decision = await self._validate_and_refine_decision(consensus, enriched_decisions)++ self.logger.info(f"✅ Analysis complete. Final signal: {final_decision.overall_signal}")+ return final_decision++ async def _execute_all_agents(self) -> Dict[str, AgentDecision]:+ """Execute all agents concurrently and standardize outputs"""+ self.logger.info("📊 Executing all agents concurrently...")++ async def run_single_agent(name: str, agent: Any) -> AgentDecision:+ try:+ # Get agent report+ if hasattr(agent, 'get_cycle_report'):+ report = await agent.get_cycle_report()+ elif hasattr(agent, 'get_policy_report'):+ report = await agent.get_policy_report()+ elif hasattr(agent, 'get_geopolitical_report'):+ report = await agent.get_geopolitical_report()+ elif hasattr(agent, 'get_regulatory_report'):+ report = await agent.get_regulatory_report()+ elif hasattr(agent, 'get_sentiment_report'):+ report = await agent.get_sentiment_report()+ elif hasattr(agent, 'get_flow_report'):+ report = await agent.get_flow_report()+ elif hasattr(agent, 'get_supply_chain_report'):+ report = await agent.get_supply_chain_report()+ elif hasattr(agent, 'get_innovation_report'):+ report = await agent.get_innovation_report()+ elif hasattr(agent, 'get_currency_report'):+ report = await agent.get_currency_report()+ elif hasattr(agent, 'get_behavioral_report'):+ report = await agent.get_behavioral_report()+ else:+ report = {"error": f"No report method found for {name}"}++ # Standardize the output+ return self._standardize_agent_output(name, report)++ except Exception as e:+ self.logger.error(f"❌ Error in agent {name}: {e}")+ return self._create_error_decision(name, str(e))++ # Run all agents concurrently+ tasks = [run_single_agent(name, agent) for name, agent in self.agents.items()]+ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Combine results+ agent_decisions = {}+ for i, (name, agent) in enumerate(self.agents.items()):+ if i < len(results) and isinstance(results[i], AgentDecision):+ agent_decisions[name] = results[i]+ else:+ agent_decisions[name] = self._create_error_decision(name, "Execution failed")++ self.logger.info(f"📈 Completed analysis from {len(agent_decisions)} agents")+ return agent_decisions++ def _standardize_agent_output(self, agent_name: str, report: Dict[str, Any]) -> AgentDecision:+ """Standardize agent outputs into common decision format"""+ try:+ # Extract key metrics based on agent type+ signal_strength, direction, confidence, insights, implications = self._extract_agent_metrics(agent_name,+ report)++ return AgentDecision(+ agent_name=agent_name,+ timestamp=datetime.now(),+ signal_strength=signal_strength,+ direction=direction,+ confidence=confidence,+ key_insights=insights,+ market_implications=implications,+ time_horizon=self._determine_time_horizon(agent_name, report),+ raw_analysis=report+ )++ except Exception as e:+ self.logger.error(f"Error standardizing {agent_name} output: {e}")+ return self._create_error_decision(agent_name, str(e))++ def _extract_agent_metrics(self, agent_name: str, report: Dict) -> tuple:+ """Extract standardized metrics from agent reports"""+ # Default values+ signal_strength = 0.5+ direction = "neutral"+ confidence = 0.5+ insights = []+ implications = {}++ try:+ if agent_name == 'macro':+ cycle_analysis = report.get('cycle_analysis', {})+ phase = cycle_analysis.get('current_phase', 'expansion')+ signal_strength = cycle_analysis.get('strength', 0.5)+ direction = "bullish" if phase in ['expansion', 'trough'] else "bearish"+ confidence = cycle_analysis.get('confidence', 0.5)+ insights = [f"Business cycle: {phase}"]+ implications = report.get('investment_implications', {})++ elif agent_name == 'fed':+ fed_analysis = report.get('fed_analysis', {})+ stance = fed_analysis.get('policy_stance', 'neutral')+ signal_strength = fed_analysis.get('probability', 0.5)+ direction = "bearish" if stance == 'hawkish' else "bullish" if stance == 'dovish' else "neutral"+ confidence = fed_analysis.get('confidence', 0.5)+ insights = [f"Fed stance: {stance}", f"Rate direction: {fed_analysis.get('rate_direction', 'holding')}"]+ implications = report.get('market_impact', {})++ elif agent_name == 'geo':+ risk_assessment = report.get('global_risk_assessment', {})+ risk_level = risk_assessment.get('overall_risk_level', 5)+ signal_strength = min(risk_level / 10, 1.0)+ direction = "bearish" if risk_level > 6 else "neutral"+ confidence = 0.7+ top_risks = risk_assessment.get('top_risks', [])+ insights = [f"Geopolitical risk: {risk_level}/10"] + [risk.get('type', '') for risk in top_risks[:2]]+ implications = report.get('investment_implications', {})++ elif agent_name == 'sentiment':+ sentiment_analysis = report.get('sentiment_analysis', {})+ overall_sentiment = sentiment_analysis.get('overall_sentiment', 0)+ signal_strength = abs(overall_sentiment)+ direction = "bullish" if overall_sentiment > 0.2 else "bearish" if overall_sentiment < -0.2 else "neutral"+ confidence = 0.6+ insights = [f"Market sentiment: {sentiment_analysis.get('sentiment_classification', 'neutral')}"]+ contrarian_signals = report.get('contrarian_signals', [])+ if contrarian_signals:+ insights.append(f"Contrarian opportunities: {len(contrarian_signals)}")+ implications = {"sentiment_momentum": overall_sentiment}++ elif agent_name == 'flows':+ flow_analysis = report.get('flow_analysis', {})+ flow_sentiment = flow_analysis.get('overall_flow_sentiment', 0)+ signal_strength = abs(flow_sentiment)+ direction = "bullish" if flow_sentiment > 0.1 else "bearish" if flow_sentiment < -0.1 else "neutral"+ confidence = 0.8+ insights = [f"Institutional flows: {flow_analysis.get('flow_classification', 'balanced')}"]+ implications = {"flow_momentum": flow_sentiment}++ # Add similar extraction logic for other agents...+ else:+ # Generic extraction for other agents+ insights = ["Analysis completed"]+ implications = {"general_impact": 0.0}++ except Exception as e:+ self.logger.error(f"Error extracting metrics for {agent_name}: {e}")++ return signal_strength, direction, confidence, insights, implications++ def _determine_time_horizon(self, agent_name: str, report: Dict) -> str:+ """Determine time horizon based on agent type"""+ horizon_map = {+ 'macro': 'long_term',+ 'fed': 'medium_term',+ 'geo': 'medium_term',+ 'regulatory': 'long_term',+ 'sentiment': 'short_term',+ 'flows': 'short_term',+ 'supply': 'medium_term',+ 'innovation': 'long_term',+ 'fx': 'short_term',+ 'behavioral': 'short_term'+ }+ return horizon_map.get(agent_name, 'medium_term')++ async def _facilitate_agent_communication(self, decisions: Dict[str, AgentDecision]) -> Dict[str, AgentDecision]:+ """Enable agents to communicate and refine their decisions based on peer insights"""+ self.logger.info("🤝 Facilitating inter-agent communication...")++ # Create communication summary for each agent+ for agent_name, decision in decisions.items():+ # Get peer insights relevant to this agent+ peer_insights = self._get_relevant_peer_insights(agent_name, decisions)++ # Use Gemini to refine the decision based on peer insights+ if peer_insights:+ refined_decision = await self._refine_decision_with_peers(decision, peer_insights)+ decisions[agent_name] = refined_decision++ return decisions++ def _get_relevant_peer_insights(self, agent_name: str, decisions: Dict[str, AgentDecision]) -> Dict[str, str]:+ """Get insights from peer agents relevant to the current agent"""+ peer_insights = {}++ # Define agent relationships and relevant insights+ agent_relationships = {+ 'macro': ['fed', 'geo', 'flows'], # Macro affected by policy, geopolitics, flows+ 'fed': ['macro', 'sentiment', 'flows'], # Fed policy affects sentiment, flows+ 'geo': ['supply', 'fx', 'flows'], # Geopolitics affects supply chains, currency, flows+ 'sentiment': ['behavioral', 'flows', 'macro'], # Sentiment relates to behavior, flows, macro+ 'flows': ['sentiment', 'macro', 'fed'], # Flows influenced by sentiment, macro, policy+ 'supply': ['geo', 'innovation', 'regulatory'], # Supply chains affected by geopolitics, innovation+ 'regulatory': ['innovation', 'supply', 'flows'], # Regulation affects innovation, supply, flows+ 'fx': ['fed', 'geo', 'flows'], # Currency affected by policy, geopolitics, flows+ 'behavioral': ['sentiment', 'flows', 'macro'], # Behavior relates to sentiment, flows, macro+ 'innovation': ['regulatory', 'supply', 'macro'] # Innovation affected by regulation, supply, macro+ }++ relevant_agents = agent_relationships.get(agent_name, [])++ for peer_agent in relevant_agents:+ if peer_agent in decisions:+ peer_decision = decisions[peer_agent]+ insight_summary = f"{peer_decision.direction} signal ({peer_decision.signal_strength:.2f} strength) - {peer_decision.key_insights[0] if peer_decision.key_insights else 'No specific insights'}"+ peer_insights[peer_agent] = insight_summary++ return peer_insights++ async def _refine_decision_with_peers(self, original_decision: AgentDecision,+ peer_insights: Dict[str, str]) -> AgentDecision:+ """Use Gemini AI to refine agent decision based on peer insights"""+ try:+ peer_summary = "\n".join([f"{agent}: {insight}" for agent, insight in peer_insights.items()])++ prompt = f"""+ As the {original_decision.agent_name} agent, refine your analysis considering peer agent insights:++ Your Original Analysis:+ - Signal: {original_decision.direction} ({original_decision.signal_strength:.2f} strength)+ - Confidence: {original_decision.confidence:.2f}+ - Key Insights: {', '.join(original_decision.key_insights)}++ Peer Agent Insights:+ {peer_summary}++ Considering these peer insights, should you:+ 1. Maintain your original assessment+ 2. Increase/decrease signal strength+ 3. Change direction+ 4. Adjust confidence level++ Provide response in JSON format:+ {{+ "action": "maintain/strengthen/weaken/reverse",+ "new_signal_strength": 0.0-1.0,+ "new_direction": "bullish/bearish/neutral",+ "new_confidence": 0.0-1.0,+ "reasoning": "Brief explanation",+ "key_factors": ["factor1", "factor2"]+ }}+ """++ response = self.gemini_model.generate_content(prompt)+ refinement = json.loads(response.text)++ # Update decision based on Gemini's analysis+ original_decision.signal_strength = refinement.get("new_signal_strength", original_decision.signal_strength)+ original_decision.direction = refinement.get("new_direction", original_decision.direction)+ original_decision.confidence = refinement.get("new_confidence", original_decision.confidence)+ original_decision.key_insights.append(f"Peer-refined: {refinement.get('reasoning', 'No reasoning')}")++ return original_decision++ except Exception as e:+ self.logger.error(f"Error refining decision with Gemini: {e}")+ return original_decision++ async def _generate_consensus_decision(self, decisions: Dict[str, AgentDecision],+ target_assets: List[str] = None) -> ConsensusDecision:+ """Generate final consensus decision using Gemini AI"""+ self.logger.info("🧠 Generating consensus decision with Gemini AI...")++ # Prepare decision summary+ decision_summary = self._prepare_decision_summary(decisions)++ prompt = f"""+ As a senior portfolio manager, analyze these AI agent insights and create a final investment decision:++ Agent Analysis Summary:+ {decision_summary}++ Agent Weights for Decision Making:+ {json.dumps(self.agent_weights, indent=2)}++ Target Assets: {target_assets or "Broad market exposure"}++ Generate a comprehensive investment decision with:+ 1. Overall signal (strong_buy/buy/hold/sell/strong_sell)+ 2. Conviction level (0-1)+ 3. Asset allocation percentages+ 4. Sector weight recommendations+ 5. Risk level assessment (0-1)+ 6. Key consensus factors+ 7. Main dissenting views+ 8. Execution priority (immediate/gradual/wait)++ Consider:+ - Agent reliability and track record+ - Signal consistency across agents+ - Risk-adjusted returns+ - Current market regime+ - Diversification principles++ Provide response in JSON format with all requested fields.+ """++ try:+ response = self.gemini_model.generate_content(prompt)+ consensus_data = json.loads(response.text)++ return ConsensusDecision(+ timestamp=datetime.now(),+ overall_signal=consensus_data.get("overall_signal", "hold"),+ conviction_level=consensus_data.get("conviction_level", 0.5),+ asset_allocation=consensus_data.get("asset_allocation", {"stocks": 0.6, "bonds": 0.4}),+ sector_weights=consensus_data.get("sector_weights", {}),+ risk_level=consensus_data.get("risk_level", 0.5),+ consensus_factors=consensus_data.get("consensus_factors", []),+ dissenting_views=consensus_data.get("dissenting_views", []),+ execution_priority=consensus_data.get("execution_priority", "gradual")+ )++ except Exception as e:+ self.logger.error(f"Error generating consensus with Gemini: {e}")+ return self._create_default_consensus(decisions)++ def _prepare_decision_summary(self, decisions: Dict[str, AgentDecision]) -> str:+ """Prepare summary of all agent decisions"""+ summary_lines = []++ for agent_name, decision in decisions.items():+ weight = self.agent_weights.get(agent_name, 0.0)+ summary_lines.append(+ f"{agent_name.upper()} (Weight: {weight:.1%}): "+ f"{decision.direction} signal, "+ f"Strength: {decision.signal_strength:.2f}, "+ f"Confidence: {decision.confidence:.2f}, "+ f"Horizon: {decision.time_horizon}, "+ f"Key: {decision.key_insights[0] if decision.key_insights else 'N/A'}"+ )++ return "\n".join(summary_lines)++ async def _validate_and_refine_decision(self, consensus: ConsensusDecision,+ decisions: Dict[str, AgentDecision]) -> ConsensusDecision:+ """Validate and refine the final decision"""+ self.logger.info("✅ Validating and refining final decision...")++ # Risk checks+ if consensus.risk_level > 0.8:+ self.logger.warning("⚠️ High risk level detected, adjusting position sizes...")+ # Reduce allocation to risky assets+ for asset in ["stocks", "growth", "emerging_markets"]:+ if asset in consensus.asset_allocation:+ consensus.asset_allocation[asset] *= 0.8++ # Consistency checks+ bullish_agents = len([d for d in decisions.values() if d.direction == "bullish"])+ bearish_agents = len([d for d in decisions.values() if d.direction == "bearish"])++ if abs(bullish_agents - bearish_agents) <= 1:+ self.logger.info("📊 Mixed signals detected, reducing conviction...")+ consensus.conviction_level *= 0.8+ consensus.execution_priority = "gradual"++ return consensus++ def _create_error_decision(self, agent_name: str, error_msg: str) -> AgentDecision:+ """Create default decision for failed agents"""+ return AgentDecision(+ agent_name=agent_name,+ timestamp=datetime.now(),+ signal_strength=0.0,+ direction="neutral",+ confidence=0.0,+ key_insights=[f"Error: {error_msg}"],+ market_implications={},+ time_horizon="unknown",+ raw_analysis={"error": error_msg}+ )++ def _create_default_consensus(self, decisions: Dict[str, AgentDecision]) -> ConsensusDecision:+ """Create default consensus when Gemini fails"""+ # Simple weighted average approach+ total_weighted_signal = 0.0+ total_weight = 0.0++ for agent_name, decision in decisions.items():+ weight = self.agent_weights.get(agent_name, 0.0)+ signal_value = decision.signal_strength * (+ 1 if decision.direction == "bullish" else -1 if decision.direction == "bearish" else 0)+ total_weighted_signal += signal_value * weight+ total_weight += weight++ avg_signal = total_weighted_signal / total_weight if total_weight > 0 else 0.0++ if avg_signal > 0.3:+ overall_signal = "buy"+ elif avg_signal < -0.3:+ overall_signal = "sell"+ else:+ overall_signal = "hold"++ return ConsensusDecision(+ timestamp=datetime.now(),+ overall_signal=overall_signal,+ conviction_level=abs(avg_signal),+ asset_allocation={"stocks": 0.6, "bonds": 0.3, "cash": 0.1},+ sector_weights={},+ risk_level=0.5,+ consensus_factors=["Default consensus due to system error"],+ dissenting_views=[],+ execution_priority="gradual"+ )+++async def run_hedge_fund_analysis(gemini_api_key: str, target_assets: List[str] = None):+ """Main function to run complete hedge fund analysis"""+ orchestrator = AgentOrchestrator(gemini_api_key)++ print("🏦 AI HEDGE FUND - MULTI-AGENT ANALYSIS")+ print("=" * 50)++ # Run comprehensive analysis+ decision = await orchestrator.run_comprehensive_analysis(target_assets)++ # Display results+ print(f"\n📈 FINAL INVESTMENT DECISION")+ print(f"Signal: {decision.overall_signal.upper()}")+ print(f"Conviction: {decision.conviction_level:.1%}")+ print(f"Risk Level: {decision.risk_level:.1%}")+ print(f"Execution: {decision.execution_priority}")++ print(f"\n💼 ASSET ALLOCATION:")+ for asset, weight in decision.asset_allocation.items():+ print(f" {asset.capitalize()}: {weight:.1%}")++ print(f"\n🔍 KEY CONSENSUS FACTORS:")+ for factor in decision.consensus_factors[:3]:+ print(f" • {factor}")++ if decision.dissenting_views:+ print(f"\n⚠️ DISSENTING VIEWS:")+ for view in decision.dissenting_views[:2]:+ print(f" • {view}")++ return decision+++# Example usage+if __name__ == "__main__":+ import os++ # Set your Gemini API key+ GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "your-gemini-api-key-here")++ # Define target assets (optional)+ TARGET_ASSETS = ["SPY", "QQQ", "TLT", "GLD", "VXX"]++ # Run the analysis+ asyncio.run(run_hedge_fund_analysis(GEMINI_API_KEY, TARGET_ASSETS))\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/behavioral_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/behavioral_agent.pynew file mode 100644index 000000000..4a9800fc1--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/behavioral_agent.py@@ -0,0 +1,317 @@+# -*- coding: utf-8 -*-+# agents/behavioral_agent.py - Behavioral Finance Analysis Agent++import asyncio+import numpy as np+from datetime import datetime, timedelta+from typing import Dict, List, Optional+import logging+from dataclasses import dataclass+import openai++from config import CONFIG+from data_feeds import DataFeedManager+++@dataclass+class BehaviorSignal:+ """Behavioral finance signal"""+ behavior_type: str+ intensity: float # 0-1+ market_impact: str # bullish, bearish, neutral+ contrarian_opportunity: bool+ affected_assets: List[str]+ confidence: float+++class BehavioralAgent:+ """Behavioral finance analysis - crowd psychology and market inefficiencies"""++ def __init__(self):+ self.name = "behavioral"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ self.behavioral_patterns = {+ "herd_behavior": {+ "indicators": ["consensus_trades", "crowded_positions", "momentum_chasing"],+ "contrarian_threshold": 0.7+ },+ "overconfidence": {+ "indicators": ["excessive_trading", "narrow_spreads", "low_volatility"],+ "contrarian_threshold": 0.6+ },+ "loss_aversion": {+ "indicators": ["selling_pressure", "defensive_positioning", "cash_hoarding"],+ "contrarian_threshold": 0.8+ },+ "anchoring": {+ "indicators": ["resistance_levels", "round_numbers", "historical_highs"],+ "contrarian_threshold": 0.5+ },+ "recency_bias": {+ "indicators": ["trend_extrapolation", "momentum_investing", "recent_news_focus"],+ "contrarian_threshold": 0.6+ }+ }++ self.market_psychology_indicators = {+ "fear": ["VIX", "put_call_ratio", "safe_haven_flows"],+ "greed": ["margin_debt", "IPO_activity", "speculative_trading"],+ "complacency": ["low_volatility", "compressed_spreads", "leverage_buildup"],+ "panic": ["forced_selling", "liquidity_crisis", "correlation_spike"]+ }++ async def analyze_behavioral_patterns(self) -> List[BehaviorSignal]:+ """Analyze behavioral finance patterns in markets"""+ signals = []++ for pattern, config in self.behavioral_patterns.items():+ try:+ signal = await self._analyze_behavioral_pattern(pattern, config)+ if signal:+ signals.append(signal)+ except Exception as e:+ logging.error(f"Error analyzing {pattern}: {e}")+ continue++ return signals++ async def _analyze_behavioral_pattern(self, pattern: str, config: Dict) -> Optional[BehaviorSignal]:+ """Analyze specific behavioral pattern"""+ # Simulate behavioral pattern analysis+ # In production, would analyze actual market data for these patterns++ # Generate realistic behavioral intensity+ base_intensity = np.random.uniform(0.2, 0.8)++ # Adjust based on pattern type+ pattern_adjustments = {+ "herd_behavior": np.random.normal(0.1, 0.2),+ "overconfidence": np.random.normal(-0.1, 0.15),+ "loss_aversion": np.random.normal(0.05, 0.25),+ "anchoring": np.random.normal(0, 0.1),+ "recency_bias": np.random.normal(0.08, 0.18)+ }++ intensity = np.clip(base_intensity + pattern_adjustments.get(pattern, 0), 0, 1)++ # Determine market impact+ if pattern in ["herd_behavior", "overconfidence", "recency_bias"]:+ if intensity > 0.6:+ market_impact = "bearish" # Contrarian signal+ else:+ market_impact = "bullish"+ elif pattern == "loss_aversion":+ market_impact = "bullish" if intensity > 0.6 else "bearish"+ else:+ market_impact = "neutral"++ # Check for contrarian opportunity+ contrarian_opportunity = intensity > config["contrarian_threshold"]++ # Determine affected assets+ affected_assets = self._get_affected_assets(pattern, intensity)++ return BehaviorSignal(+ behavior_type=pattern,+ intensity=intensity,+ market_impact=market_impact,+ contrarian_opportunity=contrarian_opportunity,+ affected_assets=affected_assets,+ confidence=0.5 + intensity * 0.3 # Higher intensity = higher confidence+ )++ def _get_affected_assets(self, pattern: str, intensity: float) -> List[str]:+ """Determine which assets are affected by behavioral pattern"""+ if pattern == "herd_behavior":+ if intensity > 0.7:+ return ["momentum_stocks", "growth_stocks", "crypto"]+ else:+ return ["broad_market"]+ elif pattern == "overconfidence":+ return ["individual_stocks", "options", "leveraged_products"]+ elif pattern == "loss_aversion":+ return ["defensive_stocks", "bonds", "gold", "utilities"]+ elif pattern == "anchoring":+ return ["stocks_near_highs", "round_number_levels"]+ elif pattern == "recency_bias":+ return ["trending_sectors", "recent_winners"]+ else:+ return ["broad_market"]++ async def analyze_market_psychology(self) -> Dict[str, float]:+ """Analyze overall market psychology"""+ psychology_scores = {}++ for emotion, indicators in self.market_psychology_indicators.items():+ # Simulate psychology analysis+ # In production, would analyze actual market indicators+ score = np.random.uniform(0.2, 0.8)++ # Add some correlation between emotions+ if emotion == "fear" and "greed" in psychology_scores:+ score = max(0.1, 1.0 - psychology_scores["greed"] + np.random.normal(0, 0.1))+ elif emotion == "greed" and "fear" in psychology_scores:+ score = max(0.1, 1.0 - psychology_scores["fear"] + np.random.normal(0, 0.1))++ psychology_scores[emotion] = np.clip(score, 0, 1)++ return psychology_scores++ def _detect_behavioral_anomalies(self, signals: List[BehaviorSignal]) -> List[str]:+ """Detect behavioral anomalies in the market"""+ anomalies = []++ # High intensity behavioral patterns+ high_intensity_patterns = [s for s in signals if s.intensity > 0.7]+ if len(high_intensity_patterns) >= 2:+ anomalies.append("multiple_behavioral_extremes")++ # Strong contrarian opportunities+ contrarian_signals = [s for s in signals if s.contrarian_opportunity]+ if len(contrarian_signals) >= 3:+ anomalies.append("multiple_contrarian_opportunities")++ # Conflicting behavioral signals+ bullish_signals = [s for s in signals if s.market_impact == "bullish"]+ bearish_signals = [s for s in signals if s.market_impact == "bearish"]++ if len(bullish_signals) > 0 and len(bearish_signals) > 0:+ if abs(len(bullish_signals) - len(bearish_signals)) <= 1:+ anomalies.append("conflicting_behavioral_signals")++ return anomalies++ async def get_behavioral_report(self) -> Dict:+ """Generate comprehensive behavioral finance report"""+ # Analyze behavioral patterns+ behavioral_signals = await self.analyze_behavioral_patterns()++ # Analyze market psychology+ psychology_scores = await self.analyze_market_psychology()++ # Detect anomalies+ anomalies = self._detect_behavioral_anomalies(behavioral_signals)++ # Calculate overall behavioral sentiment+ overall_sentiment = self._calculate_behavioral_sentiment(behavioral_signals, psychology_scores)++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "behavioral_analysis": {+ "overall_sentiment": overall_sentiment,+ "sentiment_classification": self._classify_sentiment(overall_sentiment),+ "behavioral_patterns": [{+ "pattern": signal.behavior_type,+ "intensity": signal.intensity,+ "market_impact": signal.market_impact,+ "contrarian_opportunity": signal.contrarian_opportunity,+ "affected_assets": signal.affected_assets,+ "confidence": signal.confidence+ } for signal in behavioral_signals],+ "market_psychology": psychology_scores,+ "behavioral_anomalies": anomalies+ },+ "trading_implications": {+ "contrarian_opportunities": [s.behavior_type for s in behavioral_signals+ if s.contrarian_opportunity],+ "behavioral_momentum": [s.behavior_type for s in behavioral_signals+ if s.intensity > 0.6 and not s.contrarian_opportunity],+ "risk_management": self._get_behavioral_risk_management(behavioral_signals),+ "position_sizing": self._get_behavioral_position_sizing(behavioral_signals)+ },+ "monitoring_priorities": {+ "extreme_behaviors": [s.behavior_type for s in behavioral_signals if s.intensity > 0.7],+ "contrarian_signals": [s.behavior_type for s in behavioral_signals if s.contrarian_opportunity],+ "psychology_extremes": [emotion for emotion, score in psychology_scores.items()+ if score > 0.7 or score < 0.3]+ }+ }++ def _calculate_behavioral_sentiment(self, signals: List[BehaviorSignal],+ psychology: Dict[str, float]) -> float:+ """Calculate overall behavioral sentiment"""+ if not signals and not psychology:+ return 0.0++ # Weight behavioral signals+ signal_sentiment = 0.0+ if signals:+ bullish_weight = sum(s.intensity for s in signals if s.market_impact == "bullish")+ bearish_weight = sum(s.intensity for s in signals if s.market_impact == "bearish")+ total_weight = bullish_weight + bearish_weight++ if total_weight > 0:+ signal_sentiment = (bullish_weight - bearish_weight) / total_weight++ # Weight psychology scores+ psychology_sentiment = 0.0+ if psychology:+ greed_score = psychology.get("greed", 0.5)+ fear_score = psychology.get("fear", 0.5)+ psychology_sentiment = greed_score - fear_score++ # Combine (60% signals, 40% psychology)+ if signals and psychology:+ combined_sentiment = 0.6 * signal_sentiment + 0.4 * psychology_sentiment+ elif signals:+ combined_sentiment = signal_sentiment+ elif psychology:+ combined_sentiment = psychology_sentiment+ else:+ combined_sentiment = 0.0++ return np.clip(combined_sentiment, -1.0, 1.0)++ def _classify_sentiment(self, sentiment: float) -> str:+ """Classify behavioral sentiment"""+ if sentiment > 0.4:+ return "behavioral_euphoria"+ elif sentiment > 0.1:+ return "behavioral_optimism"+ elif sentiment > -0.1:+ return "behavioral_neutral"+ elif sentiment > -0.4:+ return "behavioral_pessimism"+ else:+ return "behavioral_despair"++ def _get_behavioral_risk_management(self, signals: List[BehaviorSignal]) -> List[str]:+ """Get behavioral risk management recommendations"""+ recommendations = []++ # Check for high-intensity patterns+ high_intensity = [s for s in signals if s.intensity > 0.7]+ if high_intensity:+ recommendations.append("Monitor for behavioral reversals")+ recommendations.append("Consider reducing position sizes")++ # Check for herd behavior+ herd_signals = [s for s in signals if s.behavior_type == "herd_behavior" and s.intensity > 0.6]+ if herd_signals:+ recommendations.append("Prepare for trend reversals")+ recommendations.append("Avoid momentum chasing")++ # Check for overconfidence+ overconfidence_signals = [s for s in signals if s.behavior_type == "overconfidence" and s.intensity > 0.5]+ if overconfidence_signals:+ recommendations.append("Increase due diligence")+ recommendations.append("Diversify more broadly")++ return recommendations or ["Standard behavioral risk monitoring"]++ def _get_behavioral_position_sizing(self, signals: List[BehaviorSignal]) -> str:+ """Get position sizing recommendation based on behavioral patterns"""+ contrarian_count = sum(1 for s in signals if s.contrarian_opportunity)+ high_intensity_count = sum(1 for s in signals if s.intensity > 0.7)++ if contrarian_count >= 2:+ return "reduce_size" # Multiple contrarian signals suggest caution+ elif high_intensity_count >= 2:+ return "reduce_size" # Multiple extreme behaviors suggest volatility+ elif contrarian_count == 1 and high_intensity_count == 0:+ return "increase_size" # Single contrarian opportunity with low extremes+ else:+ return "normal"\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/central_bank_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/central_bank_agent.pynew file mode 100644index 000000000..1d737705b--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/central_bank_agent.py@@ -0,0 +1,749 @@+# -*- coding: utf-8 -*-+# agents/central_bank_agent.py - Central Bank Policy Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+import json+import re+from textblob import TextBlob++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class PolicySignal:+ """Central bank policy signal structure"""+ bank: str+ policy_stance: str # dovish, neutral, hawkish+ rate_direction: str # cutting, holding, raising+ probability: float+ next_meeting_date: Optional[datetime]+ key_factors: List[str]+ market_impact: Dict[str, float]+ confidence: float+++class CentralBankAgent:+ """Advanced central bank policy analysis and prediction"""++ def __init__(self):+ self.name = "central_bank"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Central bank meeting schedules (approximate)+ self.meeting_schedules = {+ "FED": [+ "2025-01-29", "2025-03-19", "2025-04-30", "2025-06-11",+ "2025-07-30", "2025-09-17", "2025-10-29", "2025-12-17"+ ],+ "ECB": [+ "2025-01-23", "2025-03-06", "2025-04-10", "2025-06-05",+ "2025-07-17", "2025-09-11", "2025-10-23", "2025-12-11"+ ],+ "BOJ": [+ "2025-01-23", "2025-03-19", "2025-04-28", "2025-06-14",+ "2025-07-31", "2025-09-20", "2025-10-31", "2025-12-19"+ ]+ }++ # Policy keywords and their sentiment weights+ self.policy_keywords = {+ "hawkish": {+ "aggressive", "tighten", "restrictive", "combat inflation",+ "rate hikes", "cooling", "overheating", "price pressures",+ "vigilant", "determined", "forceful", "anchor expectations"+ },+ "dovish": {+ "accommodate", "supportive", "gradual", "patient", "flexible",+ "employment", "growth", "stimulus", "easy", "cautious",+ "measured", "data dependent", "appropriate", "monitor"+ },+ "neutral": {+ "balanced", "assess", "evaluate", "conditions", "outlook",+ "appropriate", "meetings", "review", "consider", "analyze"+ }+ }++ # Economic indicators that influence policy+ self.policy_indicators = {+ "inflation": {+ "CPIAUCSL": 0.25, # CPI+ "CPILFESL": 0.25, # Core CPI+ "PCEPI": 0.20, # PCE Price Index+ "PCEPILFE": 0.20, # Core PCE+ "DFEDTARU": 0.10 # Fed Target Rate+ },+ "employment": {+ "UNRATE": 0.35, # Unemployment Rate+ "PAYEMS": 0.25, # Nonfarm Payrolls+ "AWHMAN": 0.15, # Average Weekly Hours+ "AHETPI": 0.25 # Average Hourly Earnings+ },+ "growth": {+ "GDPC1": 0.40, # Real GDP+ "INDPRO": 0.30, # Industrial Production+ "RSAFS": 0.30 # Retail Sales+ },+ "financial": {+ "GS10": 0.25, # 10-Year Treasury+ "GS2": 0.25, # 2-Year Treasury+ "VIXCLS": 0.20, # VIX+ "DEXUSEU": 0.15, # USD/EUR+ "DTWEXBGS": 0.15 # Trade Weighted USD+ }+ }++ # Market impact coefficients by asset class+ self.market_impact_coefficients = {+ "bonds": {+ "hawkish": -0.8, # Negative for bond prices+ "neutral": 0.0,+ "dovish": 0.6+ },+ "stocks": {+ "hawkish": -0.4, # Generally negative but less than bonds+ "neutral": 0.1,+ "dovish": 0.7+ },+ "dollar": {+ "hawkish": 0.9, # Strong positive for USD+ "neutral": 0.0,+ "dovish": -0.6+ },+ "gold": {+ "hawkish": -0.7, # Negative for gold+ "neutral": 0.0,+ "dovish": 0.5+ }+ }++ async def analyze_fed_policy(self) -> PolicySignal:+ """Comprehensive Federal Reserve policy analysis"""+ try:+ # Fetch economic indicators+ economic_data = await self._fetch_policy_indicators()++ # Get recent Fed communications+ fed_communications = await self._fetch_fed_communications()++ # Analyze policy stance from data+ data_stance = self._analyze_data_driven_stance(economic_data)++ # Analyze communications sentiment+ comm_stance = self._analyze_communication_sentiment(fed_communications)++ # Combine signals with weights+ combined_stance = self._combine_policy_signals(data_stance, comm_stance)++ # Predict rate direction+ rate_direction, probability = self._predict_rate_direction(economic_data, combined_stance)++ # Get next meeting date+ next_meeting = self._get_next_meeting_date("FED")++ # Calculate market impact+ market_impact = self._calculate_market_impact(combined_stance, rate_direction)++ # Generate LLM analysis+ llm_analysis = await self._generate_policy_analysis(economic_data, fed_communications, combined_stance)++ return PolicySignal(+ bank="FED",+ policy_stance=combined_stance["stance"],+ rate_direction=rate_direction,+ probability=probability,+ next_meeting_date=next_meeting,+ key_factors=llm_analysis.get("key_factors", []),+ market_impact=market_impact,+ confidence=combined_stance["confidence"]+ )++ except Exception as e:+ logging.error(f"Error in Fed policy analysis: {e}")+ return self._default_policy_signal("FED")++ async def _fetch_policy_indicators(self) -> Dict[str, pd.Series]:+ """Fetch economic indicators relevant to monetary policy"""+ data_requests = {}++ # Collect all indicators+ all_indicators = set()+ for category in self.policy_indicators.values():+ all_indicators.update(category.keys())++ # Create requests+ for indicator in all_indicators:+ data_requests[indicator] = {+ "series_id": indicator,+ "limit": 60 # 5 years of monthly data+ }++ try:+ raw_data = await self.data_manager.get_multi_source_data({+ "economic": data_requests+ })++ # Process into time series+ processed_data = {}+ economic_data = raw_data.get("economic", {})++ for key, data_points in economic_data.items():+ if data_points and len(data_points) > 0:+ # Create DataFrame from data points+ df_data = []+ for dp in data_points:+ df_data.append({+ 'date': dp.timestamp,+ 'value': dp.value+ })++ if df_data:+ df = pd.DataFrame(df_data)+ df['date'] = pd.to_datetime(df['date'])+ df = df.sort_values('date').set_index('date')+ processed_data[key] = df['value']++ return processed_data++ except Exception as e:+ logging.error(f"Error fetching policy indicators: {e}")+ return {}++ async def _fetch_fed_communications(self) -> List[DataPoint]:+ """Fetch recent Federal Reserve communications and speeches"""+ keywords = ["federal reserve", "jerome powell", "fed policy", "interest rates", "monetary policy"]++ communications = []+ try:+ for keyword in keywords:+ news_data = await self.data_manager.get_multi_source_data({+ "news": {+ "query": keyword,+ "sources": ["reuters", "bloomberg", "wsj"],+ "hours_back": 168 # 1 week+ }+ })++ if "news" in news_data and news_data["news"]:+ communications.extend(news_data["news"])++ # Filter for actual Fed communications+ fed_communications = []+ for comm in communications:+ if any(term in comm.value.lower() for term in ["fed", "federal reserve", "powell", "fomc"]):+ fed_communications.append(comm)++ return fed_communications++ except Exception as e:+ logging.error(f"Error fetching Fed communications: {e}")+ return []++ def _analyze_data_driven_stance(self, data: Dict[str, pd.Series]) -> Dict:+ """Analyze policy stance based on economic data"""+ stance_scores = []+ confidence_factors = []++ try:+ # Inflation analysis+ inflation_score = self._analyze_inflation_pressure(data)+ stance_scores.append(inflation_score * 0.4) # 40% weight+ confidence_factors.append(0.9 if inflation_score != 0 else 0.3)++ # Employment analysis+ employment_score = self._analyze_employment_conditions(data)+ stance_scores.append(employment_score * 0.3) # 30% weight+ confidence_factors.append(0.8 if employment_score != 0 else 0.3)++ # Growth analysis+ growth_score = self._analyze_growth_momentum(data)+ stance_scores.append(growth_score * 0.2) # 20% weight+ confidence_factors.append(0.7 if growth_score != 0 else 0.3)++ # Financial conditions+ financial_score = self._analyze_financial_conditions(data)+ stance_scores.append(financial_score * 0.1) # 10% weight+ confidence_factors.append(0.6 if financial_score != 0 else 0.3)++ # Calculate overall stance+ overall_score = np.sum(stance_scores)+ confidence = np.mean(confidence_factors)++ if overall_score > 0.3:+ stance = "hawkish"+ elif overall_score < -0.3:+ stance = "dovish"+ else:+ stance = "neutral"++ return {+ "stance": stance,+ "score": overall_score,+ "confidence": confidence,+ "components": {+ "inflation": inflation_score,+ "employment": employment_score,+ "growth": growth_score,+ "financial": financial_score+ }+ }++ except Exception as e:+ logging.error(f"Error in data-driven stance analysis: {e}")+ return {"stance": "neutral", "score": 0.0, "confidence": 0.3, "components": {}}++ def _analyze_inflation_pressure(self, data: Dict[str, pd.Series]) -> float:+ """Analyze inflation pressure for policy implications"""+ inflation_indicators = self.policy_indicators["inflation"]+ scores = []++ for indicator, weight in inflation_indicators.items():+ if indicator in data and not data[indicator].empty and len(data[indicator]) >= 12:+ series = data[indicator]++ # Calculate year-over-year change+ yoy_change = series.pct_change(12).iloc[-1] * 100++ # Fed target is typically around 2%+ if indicator in ["CPIAUCSL", "CPILFESL", "PCEPI", "PCEPILFE"]:+ if yoy_change > 3.0:+ score = 1.0 # Strong hawkish signal+ elif yoy_change > 2.5:+ score = 0.5 # Moderate hawkish+ elif yoy_change < 1.5:+ score = -0.5 # Moderate dovish+ elif yoy_change < 1.0:+ score = -1.0 # Strong dovish+ else:+ score = 0.0 # Neutral+ else:+ score = 0.0++ scores.append(score * weight)++ return np.sum(scores) if scores else 0.0++ def _analyze_employment_conditions(self, data: Dict[str, pd.Series]) -> float:+ """Analyze employment conditions for policy implications"""+ employment_indicators = self.policy_indicators["employment"]+ scores = []++ for indicator, weight in employment_indicators.items():+ if indicator in data and not data[indicator].empty:+ series = data[indicator]++ if indicator == "UNRATE":+ current_rate = series.iloc[-1]+ if current_rate < 3.5:+ score = 1.0 # Very tight labor market - hawkish+ elif current_rate < 4.0:+ score = 0.5 # Tight labor market+ elif current_rate > 5.5:+ score = -0.5 # Loose labor market - dovish+ elif current_rate > 6.5:+ score = -1.0 # Very loose labor market+ else:+ score = 0.0+ elif indicator == "PAYEMS":+ # Payroll growth+ if len(series) >= 3:+ avg_growth = series.pct_change().iloc[-3:].mean() * 100+ if avg_growth > 0.4: # >400k jobs/month+ score = 0.5 # Strong growth - slightly hawkish+ elif avg_growth < 0.1: # <100k jobs/month+ score = -0.5 # Weak growth - dovish+ else:+ score = 0.0+ else:+ score = 0.0+ else:+ score = 0.0++ scores.append(score * weight)++ return np.sum(scores) if scores else 0.0++ def _analyze_growth_momentum(self, data: Dict[str, pd.Series]) -> float:+ """Analyze economic growth momentum"""+ growth_indicators = self.policy_indicators["growth"]+ scores = []++ for indicator, weight in growth_indicators.items():+ if indicator in data and not data[indicator].empty and len(data[indicator]) >= 4:+ series = data[indicator]++ # Calculate quarterly growth rate+ quarterly_growth = series.pct_change(3).iloc[-1] * 100++ if indicator == "GDPC1":+ if quarterly_growth > 3.0:+ score = 0.5 # Strong growth - slightly hawkish+ elif quarterly_growth < 1.0:+ score = -0.5 # Weak growth - dovish+ elif quarterly_growth < 0:+ score = -1.0 # Contraction - very dovish+ else:+ score = 0.0+ else:+ # For other indicators, use similar logic+ if quarterly_growth > 2.0:+ score = 0.3+ elif quarterly_growth < 0:+ score = -0.5+ else:+ score = 0.0++ scores.append(score * weight)++ return np.sum(scores) if scores else 0.0++ def _analyze_financial_conditions(self, data: Dict[str, pd.Series]) -> float:+ """Analyze financial market conditions"""+ financial_indicators = self.policy_indicators["financial"]+ scores = []++ for indicator, weight in financial_indicators.items():+ if indicator in data and not data[indicator].empty:+ series = data[indicator]++ if indicator == "GS10":+ # 10-year treasury yield+ current_yield = series.iloc[-1]+ if current_yield > 5.0:+ score = 0.5 # High yields - less need for tightening+ elif current_yield < 3.0:+ score = -0.3 # Low yields - room for accommodation+ else:+ score = 0.0+ elif indicator == "VIXCLS":+ # VIX volatility index+ current_vix = series.iloc[-1]+ if current_vix > 30:+ score = -0.8 # High volatility - dovish signal+ elif current_vix < 15:+ score = 0.3 # Low volatility - can be hawkish+ else:+ score = 0.0+ else:+ score = 0.0++ scores.append(score * weight)++ return np.sum(scores) if scores else 0.0++ def _analyze_communication_sentiment(self, communications: List[DataPoint]) -> Dict:+ """Analyze sentiment from Fed communications"""+ if not communications:+ return {"stance": "neutral", "confidence": 0.2, "score": 0.0}++ stance_scores = []+ confidence_scores = []++ for comm in communications:+ text = comm.value.lower()++ # Count keyword occurrences+ hawkish_count = sum(1 for keyword in self.policy_keywords["hawkish"] if keyword in text)+ dovish_count = sum(1 for keyword in self.policy_keywords["dovish"] if keyword in text)+ neutral_count = sum(1 for keyword in self.policy_keywords["neutral"] if keyword in text)++ total_keywords = hawkish_count + dovish_count + neutral_count++ if total_keywords > 0:+ # Calculate sentiment score+ sentiment_score = (hawkish_count - dovish_count) / total_keywords+ stance_scores.append(sentiment_score * comm.confidence)+ confidence_scores.append(comm.confidence)++ if not stance_scores:+ return {"stance": "neutral", "confidence": 0.2, "score": 0.0}++ # Weight by confidence and recency+ weighted_score = np.average(stance_scores, weights=confidence_scores)+ avg_confidence = np.mean(confidence_scores)++ if weighted_score > 0.2:+ stance = "hawkish"+ elif weighted_score < -0.2:+ stance = "dovish"+ else:+ stance = "neutral"++ return {+ "stance": stance,+ "confidence": avg_confidence,+ "score": weighted_score+ }++ def _combine_policy_signals(self, data_stance: Dict, comm_stance: Dict) -> Dict:+ """Combine data-driven and communication-based policy signals"""+ # Weight data more heavily than communications+ data_weight = 0.7+ comm_weight = 0.3++ combined_score = (data_stance["score"] * data_weight ++ comm_stance["score"] * comm_weight)++ combined_confidence = (data_stance["confidence"] * data_weight ++ comm_stance["confidence"] * comm_weight)++ if combined_score > 0.25:+ stance = "hawkish"+ elif combined_score < -0.25:+ stance = "dovish"+ else:+ stance = "neutral"++ return {+ "stance": stance,+ "score": combined_score,+ "confidence": combined_confidence,+ "data_component": data_stance,+ "communication_component": comm_stance+ }++ def _predict_rate_direction(self, data: Dict[str, pd.Series], stance: Dict) -> Tuple[str, float]:+ """Predict rate direction and probability"""+ current_rate = 5.25 # Approximate current fed funds rate++ # Get current inflation and unemployment+ current_inflation = 0.0+ current_unemployment = 0.0++ if "CPIAUCSL" in data and not data["CPIAUCSL"].empty and len(data["CPIAUCSL"]) >= 12:+ current_inflation = data["CPIAUCSL"].pct_change(12).iloc[-1] * 100++ if "UNRATE" in data and not data["UNRATE"].empty:+ current_unemployment = data["UNRATE"].iloc[-1]++ # Decision logic based on dual mandate+ if stance["stance"] == "hawkish":+ if current_inflation > 3.0 or current_unemployment < 3.5:+ direction = "raising"+ probability = 0.75 + stance["confidence"] * 0.2+ else:+ direction = "holding"+ probability = 0.60 + stance["confidence"] * 0.15+ elif stance["stance"] == "dovish":+ if current_inflation < 1.5 or current_unemployment > 5.0:+ direction = "cutting"+ probability = 0.70 + stance["confidence"] * 0.2+ else:+ direction = "holding"+ probability = 0.55 + stance["confidence"] * 0.15+ else:+ direction = "holding"+ probability = 0.65 + stance["confidence"] * 0.1++ # Adjust for current rate level+ if current_rate > 6.0 and direction == "raising":+ probability *= 0.8 # Less likely to raise from high levels+ elif current_rate < 2.0 and direction == "cutting":+ probability *= 0.7 # Less room to cut from low levels++ return direction, min(probability, 0.95)++ def _get_next_meeting_date(self, bank: str) -> Optional[datetime]:+ """Get next central bank meeting date"""+ if bank not in self.meeting_schedules:+ return None++ today = datetime.now()+ try:+ meeting_dates = [datetime.strptime(date, "%Y-%m-%d") for date in self.meeting_schedules[bank]]+ future_meetings = [date for date in meeting_dates if date > today]+ return min(future_meetings) if future_meetings else None+ except Exception as e:+ logging.error(f"Error parsing meeting dates: {e}")+ return None++ def _calculate_market_impact(self, stance: Dict, rate_direction: str) -> Dict[str, float]:+ """Calculate expected market impact of policy stance"""+ stance_name = stance["stance"]+ impact_strength = abs(stance["score"]) * stance["confidence"]++ market_impacts = {}++ for asset_class, coefficients in self.market_impact_coefficients.items():+ base_impact = coefficients[stance_name]++ # Adjust for rate direction+ if rate_direction == "raising" and stance_name == "hawkish":+ base_impact *= 1.2+ elif rate_direction == "cutting" and stance_name == "dovish":+ base_impact *= 1.2++ # Scale by impact strength+ final_impact = base_impact * impact_strength+ market_impacts[asset_class] = np.clip(final_impact, -1.0, 1.0)++ return market_impacts++ async def _generate_policy_analysis(self, data: Dict[str, pd.Series],+ communications: List[DataPoint],+ stance: Dict) -> Dict:+ """Generate LLM-enhanced policy analysis"""+ try:+ # Prepare data summary+ data_summary = self._prepare_policy_data_summary(data)+ comm_summary = self._prepare_communication_summary(communications)++ prompt = f"""+ As a Federal Reserve policy expert, analyze the current monetary policy outlook.++ Current Policy Stance: {stance["stance"]} (confidence: {stance["confidence"]:.2f})++ Economic Data Summary:+ {data_summary}++ Recent Fed Communications:+ {comm_summary}++ Please provide:+ 1. Key factors driving current policy stance+ 2. Most important risks to monitor+ 3. Probability of policy error (too tight/loose)+ 4. Market positioning recommendations+ 5. Timeline for next major policy shift++ Format as JSON with keys: key_factors, risks, policy_error_risk, market_recommendations, timeline+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM policy analysis: {e}")+ return {+ "key_factors": ["Inflation trends", "Employment conditions"],+ "risks": ["Policy lag effects", "Market volatility"],+ "policy_error_risk": 0.3,+ "market_recommendations": "Maintain balanced positioning",+ "timeline": "Next 3-6 months"+ }++ def _prepare_policy_data_summary(self, data: Dict[str, pd.Series]) -> str:+ """Prepare policy-relevant data summary"""+ summary_lines = []++ # Key indicators for Fed policy+ key_indicators = {+ "CPIAUCSL": "Core Inflation",+ "UNRATE": "Unemployment Rate",+ "PAYEMS": "Job Growth",+ "GDPC1": "GDP Growth",+ "GS10": "10Y Treasury Yield"+ }++ for indicator, name in key_indicators.items():+ if indicator in data and not data[indicator].empty:+ latest = data[indicator].iloc[-1]++ if indicator in ["CPIAUCSL"] and len(data[indicator]) >= 12:+ yoy_change = data[indicator].pct_change(12).iloc[-1] * 100+ summary_lines.append(f"{name}: {yoy_change:.1f}% YoY")+ elif indicator == "PAYEMS" and len(data[indicator]) >= 1:+ monthly_change = data[indicator].diff().iloc[-1]+ summary_lines.append(f"{name}: {monthly_change:.0f}k (monthly)")+ else:+ summary_lines.append(f"{name}: {latest:.2f}")++ return "\n".join(summary_lines)++ def _prepare_communication_summary(self, communications: List[DataPoint]) -> str:+ """Prepare Fed communications summary"""+ if not communications:+ return "No recent Fed communications available"++ # Get most recent and relevant communications+ recent_comms = sorted(communications, key=lambda x: x.timestamp, reverse=True)[:5]++ summary_lines = []+ for comm in recent_comms:+ date_str = comm.timestamp.strftime("%Y-%m-%d")+ title = comm.value[:100] + "..." if len(comm.value) > 100 else comm.value+ summary_lines.append(f"{date_str}: {title}")++ return "\n".join(summary_lines)++ def _default_policy_signal(self, bank: str) -> PolicySignal:+ """Return default policy signal in case of errors"""+ return PolicySignal(+ bank=bank,+ policy_stance="neutral",+ rate_direction="holding",+ probability=0.5,+ next_meeting_date=self._get_next_meeting_date(bank),+ key_factors=["Data dependency", "Inflation monitoring"],+ market_impact={+ "bonds": 0.0,+ "stocks": 0.0,+ "dollar": 0.0,+ "gold": 0.0+ },+ confidence=0.3+ )++ async def get_policy_report(self) -> Dict:+ """Generate comprehensive central bank policy report"""+ fed_signal = await self.analyze_fed_policy()++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "fed_analysis": {+ "policy_stance": fed_signal.policy_stance,+ "rate_direction": fed_signal.rate_direction,+ "probability": fed_signal.probability,+ "confidence": fed_signal.confidence,+ "next_meeting": fed_signal.next_meeting_date.isoformat() if fed_signal.next_meeting_date else None,+ "key_factors": fed_signal.key_factors+ },+ "market_impact": fed_signal.market_impact,+ "trading_implications": {+ "duration_positioning": "short" if fed_signal.policy_stance == "hawkish" else "long",+ "sector_rotation": self._get_sector_implications(fed_signal),+ "currency_bias": "bullish_usd" if fed_signal.policy_stance == "hawkish" else "bearish_usd"+ },+ "risk_factors": {+ "policy_uncertainty": 1 - fed_signal.confidence,+ "communication_risk": 0.3,+ "market_reaction_risk": 0.4+ }+ }++ def _get_sector_implications(self, signal: PolicySignal) -> Dict[str, str]:+ """Get sector rotation implications from policy stance"""+ if signal.policy_stance == "hawkish":+ return {+ "financials": "bullish", # Higher rates benefit banks+ "technology": "bearish", # Higher discount rates hurt growth stocks+ "utilities": "bearish", # Rate-sensitive sector+ "real_estate": "bearish" # REITs hurt by higher rates+ }+ elif signal.policy_stance == "dovish":+ return {+ "technology": "bullish", # Lower rates help growth stocks+ "real_estate": "bullish", # REITs benefit from lower rates+ "utilities": "bullish", # Rate-sensitive sectors benefit+ "financials": "bearish" # Lower rates hurt bank margins+ }+ else:+ return {+ "balanced": "neutral",+ "defensive": "slight_overweight"+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/config.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/config.pynew file mode 100644index 000000000..4136ef8b6--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/config.py@@ -0,0 +1,166 @@+# -*- coding: utf-8 -*-+# config.py - Production Configuration for AI Hedge Fund System++import os+from dataclasses import dataclass+from typing import Dict, List, Optional+import logging+from pathlib import Path+++@dataclass+class APIConfig:+ """API Configuration for external services"""+ openai_api_key: str = os.getenv("OPENAI_API_KEY", "")+ anthropic_api_key: str = os.getenv("ANTHROPIC_API_KEY", "")+ finnhub_api_key: str = os.getenv("FINNHUB_API_KEY", "")+ alpha_vantage_key: str = os.getenv("ALPHA_VANTAGE_API_KEY", "")+ fred_api_key: str = os.getenv("FRED_API_KEY", "")+ newsapi_key: str = os.getenv("NEWS_API_KEY", "")+ twitter_bearer_token: str = os.getenv("TWITTER_BEARER_TOKEN", "")+ reddit_client_id: str = os.getenv("REDDIT_CLIENT_ID", "")+ reddit_client_secret: str = os.getenv("REDDIT_CLIENT_SECRET", "")+ polygon_api_key: str = os.getenv("POLYGON_API_KEY", "")+++@dataclass+class LLMConfig:+ """LLM Configuration for different thinking modes"""+ deep_think_model: str = "gpt-4o"+ quick_think_model: str = "gpt-4o-mini"+ temperature: float = 0.1+ max_tokens: int = 4000+ timeout: int = 30+ max_retries: int = 3+++@dataclass+class AgentConfig:+ """Individual agent configuration"""+ confidence_threshold: float = 0.7+ update_frequency: int = 300 # seconds+ data_lookback_days: int = 30+ max_api_calls_per_hour: int = 100+ enable_caching: bool = True+ cache_ttl: int = 1800 # 30 minutes+++@dataclass+class RiskConfig:+ """Risk management parameters"""+ max_position_size: float = 0.05 # 5% max per position+ max_sector_exposure: float = 0.25 # 25% max per sector+ max_country_exposure: float = 0.40 # 40% max per country+ stop_loss_threshold: float = 0.02 # 2% stop loss+ var_limit: float = 0.03 # 3% daily VaR limit+ correlation_limit: float = 0.8 # Max correlation between positions+++@dataclass+class TradingConfig:+ """Trading execution parameters"""+ min_trade_size: float = 1000.0 # Minimum trade size USD+ max_trade_size: float = 1000000.0 # Maximum trade size USD+ slippage_assumption: float = 0.001 # 10 bps slippage+ commission_rate: float = 0.0005 # 5 bps commission+ market_impact_threshold: float = 0.01 # 1% of daily volume+++class Config:+ """Main configuration class"""++ def __init__(self):+ self.api = APIConfig()+ self.llm = LLMConfig()+ self.agent = AgentConfig()+ self.risk = RiskConfig()+ self.trading = TradingConfig()++ # Logging configuration+ self.log_level = logging.INFO+ self.log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"++ # Data storage paths+ self.data_dir = Path("data")+ self.cache_dir = Path("cache")+ self.logs_dir = Path("logs")++ # Create directories if they don't exist+ for directory in [self.data_dir, self.cache_dir, self.logs_dir]:+ directory.mkdir(exist_ok=True)++ # Agent weights for decision aggregation+ self.agent_weights = {+ "macro_cycle": 0.15,+ "central_bank": 0.20,+ "geopolitical": 0.18,+ "regulatory": 0.12,+ "sentiment": 0.10,+ "institutional_flow": 0.15,+ "supply_chain": 0.05,+ "innovation": 0.03,+ "currency": 0.02,+ "behavioral": 0.00+ }++ # Market hours and trading sessions+ self.trading_sessions = {+ "US": {"open": "09:30", "close": "16:00", "timezone": "America/New_York"},+ "EU": {"open": "08:00", "close": "16:30", "timezone": "Europe/London"},+ "ASIA": {"open": "09:00", "close": "15:00", "timezone": "Asia/Tokyo"}+ }++ # Asset class mappings+ self.asset_classes = {+ "equities": ["SPY", "QQQ", "IWM", "EFA", "EEM"],+ "bonds": ["TLT", "IEF", "SHY", "LQD", "HYG"],+ "commodities": ["GLD", "SLV", "USO", "UNG", "DBA"],+ "currencies": ["UUP", "FXE", "FXY", "FXB", "EWZ"],+ "volatility": ["VIX", "UVXY", "SVXY"]+ }++ # Economic indicators to monitor+ self.economic_indicators = [+ "GDP", "CPI", "PPI", "UNRATE", "FEDFUNDS", "DGS10", "DGS2",+ "DEXUSEU", "DEXCHUS", "DEXJPUS", "DEXUSUK", "CPIAUCSL",+ "PAYEMS", "INDPRO", "HOUST", "RSAFS", "UMCSENT"+ ]++ # News sources and their reliability scores+ self.news_sources = {+ "reuters": 0.95,+ "bloomberg": 0.95,+ "wsj": 0.90,+ "ft": 0.90,+ "cnbc": 0.75,+ "marketwatch": 0.70,+ "yahoo_finance": 0.65+ }++ def validate_config(self) -> bool:+ """Validate configuration settings"""+ required_keys = [+ self.api.openai_api_key,+ self.api.finnhub_api_key,+ self.api.fred_api_key+ ]++ if not all(required_keys):+ raise ValueError("Missing required API keys. Check environment variables.")++ if sum(self.agent_weights.values()) != 1.0:+ raise ValueError("Agent weights must sum to 1.0")++ return True++ def get_market_hours(self, market: str) -> Dict[str, str]:+ """Get trading hours for specific market"""+ return self.trading_sessions.get(market.upper(), {})++ def get_asset_universe(self, asset_class: str) -> List[str]:+ """Get tradeable assets for asset class"""+ return self.asset_classes.get(asset_class.lower(), [])+++# Global configuration instance+CONFIG = Config()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/currency_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/currency_agent.pynew file mode 100644index 000000000..620e196a4--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/currency_agent.py@@ -0,0 +1,137 @@+# -*- coding: utf-8 -*-+# agents/currency_agent.py - Foreign Exchange Analysis Agent++import asyncio+import numpy as np+from datetime import datetime+from typing import Dict, List, Optional+import logging+from dataclasses import dataclass+import openai++from config import CONFIG+from data_feeds import DataFeedManager+++@dataclass+class CurrencySignal:+ """Currency trading signal"""+ currency_pair: str+ direction: str # long, short, neutral+ strength: float # 0-1+ time_horizon: str+ drivers: List[str]+ confidence: float+++class CurrencyAgent:+ """Foreign exchange analysis and currency trading signals"""++ def __init__(self):+ self.name = "currency"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ self.major_pairs = ["EURUSD", "GBPUSD", "USDJPY", "USDCAD", "AUDUSD", "USDCHF"]++ self.currency_drivers = {+ "interest_rate_differential": 0.30,+ "economic_growth": 0.25,+ "political_stability": 0.20,+ "trade_balance": 0.15,+ "risk_sentiment": 0.10+ }++ async def analyze_currency_trends(self) -> List[CurrencySignal]:+ """Analyze major currency trends"""+ signals = []++ for pair in self.major_pairs:+ try:+ signal = await self._analyze_currency_pair(pair)+ if signal:+ signals.append(signal)+ except Exception as e:+ logging.error(f"Error analyzing {pair}: {e}")+ continue++ return signals++ async def _analyze_currency_pair(self, pair: str) -> Optional[CurrencySignal]:+ """Analyze specific currency pair"""+ # Simulate currency analysis+ base_currency = pair[:3]+ quote_currency = pair[3:]++ # Simulate various factors+ rate_differential = np.random.normal(0, 0.5)+ economic_growth_diff = np.random.normal(0, 0.3)+ political_stability = np.random.uniform(-0.5, 0.5)++ # Combine factors+ signal_strength = (rate_differential * 0.4 ++ economic_growth_diff * 0.4 ++ political_stability * 0.2)++ if signal_strength > 0.2:+ direction = "long"+ strength = min(signal_strength, 1.0)+ elif signal_strength < -0.2:+ direction = "short"+ strength = min(abs(signal_strength), 1.0)+ else:+ direction = "neutral"+ strength = 0.1++ drivers = ["interest_rates", "economic_data"]+ if abs(political_stability) > 0.3:+ drivers.append("political_events")++ return CurrencySignal(+ currency_pair=pair,+ direction=direction,+ strength=strength,+ time_horizon="medium",+ drivers=drivers,+ confidence=0.6+ )++ async def get_currency_report(self) -> Dict:+ """Generate currency analysis report"""+ signals = await self.analyze_currency_trends()++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "currency_analysis": {+ "usd_outlook": self._assess_usd_outlook(signals),+ "currency_signals": [{+ "pair": signal.currency_pair,+ "direction": signal.direction,+ "strength": signal.strength,+ "time_horizon": signal.time_horizon,+ "key_drivers": signal.drivers,+ "confidence": signal.confidence+ } for signal in signals],+ "strongest_signals": [s.currency_pair for s in signals+ if s.strength > 0.6 and s.direction != "neutral"]+ }+ }++ def _assess_usd_outlook(self, signals: List[CurrencySignal]) -> str:+ """Assess overall USD outlook from currency signals"""+ usd_signals = [s for s in signals if "USD" in s.currency_pair]++ if not usd_signals:+ return "neutral"++ bullish_count = sum(1 for s in usd_signals+ if (s.currency_pair.startswith("USD") and s.direction == "long") or+ (s.currency_pair.endswith("USD") and s.direction == "short"))++ if bullish_count > len(usd_signals) * 0.6:+ return "bullish"+ elif bullish_count < len(usd_signals) * 0.4:+ return "bearish"+ else:+ return "neutral"\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/data_feeds.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/data_feeds.pynew file mode 100644index 000000000..5a2cfe72c--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/data_feeds.py@@ -0,0 +1,478 @@+# -*- coding: utf-8 -*-+# data_feeds.py - Production Data Sources and Feed Management++import asyncio+import aiohttp+import pandas as pd+import numpy as np+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Any, Union+import json+import logging+from dataclasses import dataclass+import redis+from config import CONFIG+import time+import hashlib+++@dataclass+class DataPoint:+ """Standardized data point structure"""+ timestamp: datetime+ source: str+ data_type: str+ value: Union[float, str, Dict]+ confidence: float+ metadata: Dict[str, Any]+++class DataCache:+ """Redis-based caching for data feeds"""++ def __init__(self):+ self.redis_client = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)+ self.default_ttl = CONFIG.agent.cache_ttl++ def get(self, key: str) -> Optional[Any]:+ """Get cached data"""+ try:+ data = self.redis_client.get(key)+ return json.loads(data) if data else None+ except Exception:+ return None++ def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:+ """Set cached data"""+ try:+ ttl = ttl or self.default_ttl+ return self.redis_client.setex(key, ttl, json.dumps(value, default=str))+ except Exception:+ return False++ def generate_key(self, source: str, params: Dict) -> str:+ """Generate cache key from parameters"""+ param_str = json.dumps(params, sort_keys=True)+ return f"{source}:{hashlib.md5(param_str.encode()).hexdigest()}"+++class EconomicDataFeed:+ """Federal Reserve Economic Data (FRED) API integration"""++ def __init__(self):+ self.base_url = "https://api.stlouisfed.org/fred"+ self.api_key = CONFIG.api.fred_api_key+ self.cache = DataCache()+ self.session = None++ async def __aenter__(self):+ self.session = aiohttp.ClientSession()+ return self++ async def __aexit__(self, exc_type, exc_val, exc_tb):+ if self.session:+ await self.session.close()++ async def get_series(self, series_id: str, limit: int = 100) -> List[DataPoint]:+ """Get economic time series data"""+ cache_key = self.cache.generate_key("fred", {"series": series_id, "limit": limit})+ cached = self.cache.get(cache_key)++ if cached and CONFIG.agent.enable_caching:+ return [DataPoint(**dp) for dp in cached]++ url = f"{self.base_url}/series/observations"+ params = {+ "series_id": series_id,+ "api_key": self.api_key,+ "file_type": "json",+ "limit": limit,+ "sort_order": "desc"+ }++ try:+ async with self.session.get(url, params=params) as response:+ data = await response.json()+ observations = data.get("observations", [])++ data_points = []+ for obs in observations:+ if obs["value"] != ".":+ dp = DataPoint(+ timestamp=datetime.strptime(obs["date"], "%Y-%m-%d"),+ source="FRED",+ data_type=series_id,+ value=float(obs["value"]),+ confidence=0.95,+ metadata={"series_id": series_id}+ )+ data_points.append(dp)++ # Cache the results+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])+ return data_points++ except Exception as e:+ logging.error(f"Error fetching FRED data for {series_id}: {e}")+ return []+++class NewsDataFeed:+ """News API integration for sentiment and events"""++ def __init__(self):+ self.api_key = CONFIG.api.newsapi_key+ self.base_url = "https://newsapi.org/v2"+ self.cache = DataCache()+ self.session = None++ async def __aenter__(self):+ self.session = aiohttp.ClientSession()+ return self++ async def __aexit__(self, exc_type, exc_val, exc_tb):+ if self.session:+ await self.session.close()++ async def get_headlines(self, query: str, sources: List[str] = None,+ hours_back: int = 24) -> List[DataPoint]:+ """Get news headlines with relevance scoring"""+ cache_key = self.cache.generate_key("news", {+ "query": query,+ "sources": sources,+ "hours": hours_back+ })+ cached = self.cache.get(cache_key)++ if cached and CONFIG.agent.enable_caching:+ return [DataPoint(**dp) for dp in cached]++ from_date = (datetime.now() - timedelta(hours=hours_back)).isoformat()++ params = {+ "q": query,+ "from": from_date,+ "sortBy": "relevancy",+ "apiKey": self.api_key,+ "language": "en",+ "pageSize": 100+ }++ if sources:+ params["sources"] = ",".join(sources)++ try:+ async with self.session.get(f"{self.base_url}/everything", params=params) as response:+ data = await response.json()+ articles = data.get("articles", [])++ data_points = []+ for article in articles:+ # Calculate relevance confidence based on source reliability+ source_name = article.get("source", {}).get("name", "").lower()+ confidence = CONFIG.news_sources.get(source_name, 0.50)++ dp = DataPoint(+ timestamp=datetime.fromisoformat(article["publishedAt"].replace("Z", "+00:00")),+ source=source_name,+ data_type="news_headline",+ value=article["title"],+ confidence=confidence,+ metadata={+ "description": article.get("description", ""),+ "url": article.get("url", ""),+ "author": article.get("author", ""),+ "query": query+ }+ )+ data_points.append(dp)++ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])+ return data_points++ except Exception as e:+ logging.error(f"Error fetching news data: {e}")+ return []+++class MarketDataFeed:+ """Financial market data from multiple sources"""++ def __init__(self):+ self.finnhub_key = CONFIG.api.finnhub_api_key+ self.polygon_key = CONFIG.api.polygon_api_key+ self.cache = DataCache()+ self.session = None++ async def __aenter__(self):+ self.session = aiohttp.ClientSession()+ return self++ async def __aexit__(self, exc_type, exc_val, exc_tb):+ if self.session:+ await self.session.close()++ async def get_institutional_trades(self, symbol: str) -> List[DataPoint]:+ """Get institutional trading data from Finnhub"""+ cache_key = self.cache.generate_key("institutional", {"symbol": symbol})+ cached = self.cache.get(cache_key)++ if cached and CONFIG.agent.enable_caching:+ return [DataPoint(**dp) for dp in cached]++ url = f"https://finnhub.io/api/v1/stock/institutional-portfolio"+ params = {+ "symbol": symbol,+ "token": self.finnhub_key+ }++ try:+ async with self.session.get(url, params=params) as response:+ data = await response.json()++ data_points = []+ for filing in data.get("data", []):+ dp = DataPoint(+ timestamp=datetime.now(),+ source="Finnhub",+ data_type="institutional_holding",+ value=filing.get("change", 0),+ confidence=0.85,+ metadata={+ "symbol": symbol,+ "institution": filing.get("name", ""),+ "shares": filing.get("share", 0),+ "portfolio_percent": filing.get("portfolioPercent", 0)+ }+ )+ data_points.append(dp)++ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])+ return data_points++ except Exception as e:+ logging.error(f"Error fetching institutional data: {e}")+ return []++ async def get_insider_trades(self, symbol: str, days_back: int = 30) -> List[DataPoint]:+ """Get insider trading data"""+ cache_key = self.cache.generate_key("insider", {"symbol": symbol, "days": days_back})+ cached = self.cache.get(cache_key)++ if cached and CONFIG.agent.enable_caching:+ return [DataPoint(**dp) for dp in cached]++ from_date = (datetime.now() - timedelta(days=days_back)).strftime("%Y-%m-%d")+ to_date = datetime.now().strftime("%Y-%m-%d")++ url = f"https://finnhub.io/api/v1/stock/insider-transactions"+ params = {+ "symbol": symbol,+ "from": from_date,+ "to": to_date,+ "token": self.finnhub_key+ }++ try:+ async with self.session.get(url, params=params) as response:+ data = await response.json()++ data_points = []+ for trade in data.get("data", []):+ dp = DataPoint(+ timestamp=datetime.strptime(trade["transactionDate"], "%Y-%m-%d"),+ source="Finnhub",+ data_type="insider_trade",+ value=trade.get("change", 0),+ confidence=0.90,+ metadata={+ "symbol": symbol,+ "name": trade.get("name", ""),+ "share": trade.get("share", 0),+ "transaction_code": trade.get("transactionCode", ""),+ "transaction_price": trade.get("transactionPrice", 0)+ }+ )+ data_points.append(dp)++ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])+ return data_points++ except Exception as e:+ logging.error(f"Error fetching insider data: {e}")+ return []+++class SentimentDataFeed:+ """Social media and sentiment data aggregation"""++ def __init__(self):+ self.reddit_id = CONFIG.api.reddit_client_id+ self.reddit_secret = CONFIG.api.reddit_client_secret+ self.twitter_token = CONFIG.api.twitter_bearer_token+ self.cache = DataCache()+ self.session = None++ async def __aenter__(self):+ self.session = aiohttp.ClientSession()+ return self++ async def __aexit__(self, exc_type, exc_val, exc_tb):+ if self.session:+ await self.session.close()++ async def get_reddit_sentiment(self, subreddits: List[str], keywords: List[str]) -> List[DataPoint]:+ """Get Reddit sentiment for specific keywords"""+ cache_key = self.cache.generate_key("reddit", {+ "subreddits": subreddits,+ "keywords": keywords+ })+ cached = self.cache.get(cache_key)++ if cached and CONFIG.agent.enable_caching:+ return [DataPoint(**dp) for dp in cached]++ # Reddit API implementation would go here+ # For now, return mock structure+ data_points = []++ try:+ # This would be actual Reddit API calls+ for subreddit in subreddits:+ for keyword in keywords:+ dp = DataPoint(+ timestamp=datetime.now(),+ source="Reddit",+ data_type="social_sentiment",+ value=np.random.uniform(-1, 1), # Placeholder sentiment score+ confidence=0.60,+ metadata={+ "subreddit": subreddit,+ "keyword": keyword,+ "post_count": np.random.randint(10, 100),+ "engagement_score": np.random.uniform(0, 1)+ }+ )+ data_points.append(dp)++ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])+ return data_points++ except Exception as e:+ logging.error(f"Error fetching Reddit sentiment: {e}")+ return []+++class GeopoliticalDataFeed:+ """Geopolitical events and risk monitoring"""++ def __init__(self):+ self.cache = DataCache()+ self.session = None++ async def __aenter__(self):+ self.session = aiohttp.ClientSession()+ return self++ async def __aexit__(self, exc_type, exc_val, exc_tb):+ if self.session:+ await self.session.close()++ async def get_conflict_data(self) -> List[DataPoint]:+ """Get global conflict and tension data"""+ cache_key = self.cache.generate_key("geopolitical", {"type": "conflicts"})+ cached = self.cache.get(cache_key)++ if cached and CONFIG.agent.enable_caching:+ return [DataPoint(**dp) for dp in cached]++ # This would integrate with GDELT, ACLED, or similar sources+ # For production, you'd implement actual API calls+ data_points = []++ try:+ # Mock implementation - replace with real geopolitical data sources+ conflicts = ["Russia-Ukraine", "China-Taiwan", "Middle East", "North Korea"]++ for conflict in conflicts:+ dp = DataPoint(+ timestamp=datetime.now(),+ source="GDELT",+ data_type="geopolitical_tension",+ value=np.random.uniform(0, 10), # Tension score 0-10+ confidence=0.75,+ metadata={+ "conflict_region": conflict,+ "escalation_risk": np.random.choice(["low", "medium", "high"]),+ "affected_sectors": ["defense", "energy", "tech"],+ "sanctions_risk": np.random.uniform(0, 1)+ }+ )+ data_points.append(dp)++ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])+ return data_points++ except Exception as e:+ logging.error(f"Error fetching geopolitical data: {e}")+ return []+++class DataFeedManager:+ """Central manager for all data feeds"""++ def __init__(self):+ self.feeds = {+ "economic": EconomicDataFeed(),+ "news": NewsDataFeed(),+ "market": MarketDataFeed(),+ "sentiment": SentimentDataFeed(),+ "geopolitical": GeopoliticalDataFeed()+ }++ async def get_multi_source_data(self, data_requests: Dict[str, Dict]) -> Dict[str, List[DataPoint]]:+ """Get data from multiple sources concurrently"""+ results = {}++ async def fetch_data(feed_name: str, feed_obj: Any, request_params: Dict):+ async with feed_obj as feed:+ if feed_name == "economic":+ data = await feed.get_series(**request_params)+ elif feed_name == "news":+ data = await feed.get_headlines(**request_params)+ elif feed_name == "market":+ if request_params.get("data_type") == "institutional":+ data = await feed.get_institutional_trades(request_params["symbol"])+ else:+ data = await feed.get_insider_trades(**request_params)+ elif feed_name == "sentiment":+ data = await feed.get_reddit_sentiment(**request_params)+ elif feed_name == "geopolitical":+ data = await feed.get_conflict_data()+ else:+ data = []++ results[feed_name] = data++ tasks = []+ for feed_name, request_params in data_requests.items():+ if feed_name in self.feeds:+ feed_obj = self.feeds[feed_name]+ tasks.append(fetch_data(feed_name, feed_obj, request_params))++ await asyncio.gather(*tasks, return_exceptions=True)+ return results++ def get_latest_data_summary(self) -> Dict[str, Any]:+ """Get summary of latest data availability"""+ summary = {+ "timestamp": datetime.now().isoformat(),+ "data_sources": list(self.feeds.keys()),+ "cache_status": "enabled" if CONFIG.agent.enable_caching else "disabled",+ "api_rate_limits": {+ "economic": f"{CONFIG.agent.max_api_calls_per_hour}/hour",+ "news": f"{CONFIG.agent.max_api_calls_per_hour}/hour",+ "market": f"{CONFIG.agent.max_api_calls_per_hour}/hour"+ }+ }+ return summary\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/geopolitical_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/geopolitical_agent.pynew file mode 100644index 000000000..d3a055171--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/geopolitical_agent.py@@ -0,0 +1,894 @@+# -*- coding: utf-8 -*-+# agents/geopolitical_agent.py - Geopolitical Risk Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+import json+from collections import defaultdict+import re++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class GeopoliticalRisk:+ """Geopolitical risk assessment structure"""+ region: str+ risk_type: str+ current_level: int # 1-10 scale+ trend: str # escalating, stable, de-escalating+ probability_impact: float # 0-1+ affected_sectors: List[str]+ timeline: str+ mitigation_strategies: List[str]+ confidence: float+++@dataclass+class ConflictSignal:+ """Military conflict monitoring signal"""+ conflict_name: str+ escalation_risk: float+ economic_impact: Dict[str, float]+ supply_chain_risk: Dict[str, float]+ market_sectors: Dict[str, float]+ duration_estimate: str+++class GeopoliticalAgent:+ """Advanced geopolitical risk monitoring and analysis"""++ def __init__(self):+ self.name = "geopolitical"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Geopolitical risk factors and their weights+ self.risk_factors = {+ "military_conflicts": {+ "Russia-Ukraine": 0.25,+ "China-Taiwan": 0.20,+ "Middle_East": 0.15,+ "North_Korea": 0.10,+ "India-Pakistan": 0.08,+ "Balkans": 0.05,+ "Arctic": 0.07,+ "Cyber_warfare": 0.10+ },+ "trade_tensions": {+ "US-China": 0.30,+ "US-EU": 0.15,+ "China-EU": 0.15,+ "US-Russia": 0.20,+ "Brexit_aftermath": 0.10,+ "USMCA_issues": 0.10+ },+ "sanctions_regime": {+ "Russia_sanctions": 0.35,+ "China_tech_sanctions": 0.25,+ "Iran_sanctions": 0.15,+ "North_Korea_sanctions": 0.10,+ "Secondary_sanctions": 0.15+ },+ "political_instability": {+ "US_domestic": 0.20,+ "EU_integration": 0.18,+ "China_internal": 0.15,+ "Middle_East_regimes": 0.15,+ "Latin_America": 0.12,+ "Africa_coups": 0.10,+ "Democratic_backsliding": 0.10+ }+ }++ # Sector impact mapping from geopolitical events+ self.sector_impact_map = {+ "military_conflicts": {+ "defense": 0.8,+ "energy": 0.6,+ "commodities": 0.7,+ "technology": -0.3,+ "tourism": -0.6,+ "airlines": -0.5,+ "insurance": -0.4+ },+ "trade_tensions": {+ "technology": -0.7,+ "manufacturing": -0.5,+ "agriculture": -0.4,+ "automotive": -0.6,+ "semiconductors": -0.8,+ "renewable_energy": 0.3+ },+ "sanctions_regime": {+ "energy": -0.8,+ "banking": -0.6,+ "technology": -0.5,+ "shipping": -0.4,+ "commodities": 0.4,+ "defense": 0.5+ },+ "political_instability": {+ "healthcare": 0.2,+ "utilities": 0.3,+ "consumer_staples": 0.4,+ "financials": -0.4,+ "real_estate": -0.3,+ "currency": -0.6+ }+ }++ # Key geopolitical indicators to monitor+ self.geopolitical_keywords = {+ "conflict_escalation": [+ "military buildup", "troop movements", "weapon shipments",+ "border tensions", "missile tests", "naval exercises",+ "air defense", "invasion", "occupation", "blockade"+ ],+ "diplomatic_tensions": [+ "sanctions", "tariffs", "trade war", "diplomatic expulsion",+ "embassy closure", "summit cancellation", "treaty withdrawal",+ "alliance strain", "diplomatic protest"+ ],+ "regime_change": [+ "coup", "revolution", "civil unrest", "protests",+ "election fraud", "authoritarianism", "martial law",+ "state of emergency", "government collapse"+ ],+ "economic_warfare": [+ "currency manipulation", "debt trap", "supply chain disruption",+ "critical minerals", "technology transfer", "intellectual property",+ "cyber attacks", "financial warfare"+ ]+ }++ # Regional risk weightings based on global economic impact+ self.regional_weights = {+ "North_America": 0.25,+ "Europe": 0.20,+ "East_Asia": 0.25,+ "Middle_East": 0.15,+ "South_America": 0.08,+ "Africa": 0.05,+ "South_Asia": 0.02+ }++ async def analyze_global_risks(self) -> List[GeopoliticalRisk]:+ """Comprehensive global geopolitical risk analysis"""+ risks = []++ try:+ # Analyze each risk category+ for risk_category, risk_items in self.risk_factors.items():+ category_risks = await self._analyze_risk_category(risk_category, risk_items)+ risks.extend(category_risks)++ # Sort by risk level and confidence+ risks.sort(key=lambda x: x.current_level * x.confidence, reverse=True)++ return risks[:10] # Return top 10 risks++ except Exception as e:+ logging.error(f"Error in global risk analysis: {e}")+ return [self._default_geopolitical_risk()]++ async def _analyze_risk_category(self, category: str, risk_items: Dict[str, float]) -> List[GeopoliticalRisk]:+ """Analyze specific risk category"""+ category_risks = []++ # Get news data for this category+ news_data = await self._fetch_category_news(category, list(risk_items.keys()))++ for risk_item, weight in risk_items.items():+ try:+ # Filter news for this specific risk+ relevant_news = [news for news in news_data+ if self._is_relevant_to_risk(news, risk_item)]++ # Calculate risk level+ risk_level = self._calculate_risk_level(relevant_news, risk_item, category)++ # Determine trend+ trend = self._determine_risk_trend(relevant_news)++ # Calculate probability and impact+ prob_impact = self._calculate_probability_impact(risk_level, weight, relevant_news)++ # Get affected sectors+ affected_sectors = self._get_affected_sectors(category, risk_level)++ # Generate timeline estimate+ timeline = self._estimate_timeline(risk_level, trend, relevant_news)++ # Get mitigation strategies+ mitigation = self._get_mitigation_strategies(risk_item, category)++ # Calculate confidence+ confidence = self._calculate_risk_confidence(relevant_news, risk_item)++ risk = GeopoliticalRisk(+ region=self._get_region_from_risk(risk_item),+ risk_type=category,+ current_level=risk_level,+ trend=trend,+ probability_impact=prob_impact,+ affected_sectors=affected_sectors,+ timeline=timeline,+ mitigation_strategies=mitigation,+ confidence=confidence+ )++ category_risks.append(risk)++ except Exception as e:+ logging.error(f"Error analyzing {risk_item}: {e}")+ continue++ return category_risks++ async def _fetch_category_news(self, category: str, risk_items: List[str]) -> List[DataPoint]:+ """Fetch news data for specific risk category"""+ all_news = []++ # Create search queries for each risk item+ queries = []+ if category == "military_conflicts":+ queries = ["military conflict", "war", "invasion", "missile", "defense"]+ elif category == "trade_tensions":+ queries = ["trade war", "tariffs", "sanctions", "trade dispute"]+ elif category == "sanctions_regime":+ queries = ["sanctions", "embargo", "trade restrictions"]+ elif category == "political_instability":+ queries = ["political crisis", "coup", "election", "protests"]++ for query in queries:+ try:+ news_data = await self.data_manager.get_multi_source_data({+ "news": {+ "query": query,+ "sources": ["reuters", "bloomberg", "wsj", "ft"],+ "hours_back": 72 # 3 days+ }+ })++ if "news" in news_data:+ all_news.extend(news_data["news"])++ except Exception as e:+ logging.error(f"Error fetching news for {query}: {e}")+ continue++ return all_news++ def _is_relevant_to_risk(self, news: DataPoint, risk_item: str) -> bool:+ """Check if news article is relevant to specific risk"""+ text = (news.value + " " + news.metadata.get("description", "")).lower()++ # Create keywords for each risk item+ risk_keywords = {+ "Russia-Ukraine": ["russia", "ukraine", "putin", "zelensky", "kyiv", "moscow"],+ "China-Taiwan": ["china", "taiwan", "beijing", "taipei", "strait", "xi jinping"],+ "Middle_East": ["iran", "israel", "gaza", "lebanon", "syria", "yemen"],+ "North_Korea": ["north korea", "kim jong", "pyongyang", "dprk"],+ "US-China": ["us china", "trade war", "biden", "xi jinping", "tariff"],+ "Russia_sanctions": ["russia sanctions", "swift", "energy embargo"],+ "China_tech_sanctions": ["china tech", "semiconductor", "huawei", "tiktok"]+ }++ keywords = risk_keywords.get(risk_item, [risk_item.lower().replace("_", " ")])++ return any(keyword in text for keyword in keywords)++ def _calculate_risk_level(self, news: List[DataPoint], risk_item: str, category: str) -> int:+ """Calculate current risk level (1-10 scale)"""+ if not news:+ return 3 # Default moderate risk++ # Base risk levels for different risk items+ base_risks = {+ "Russia-Ukraine": 8,+ "China-Taiwan": 6,+ "Middle_East": 7,+ "US-China": 5,+ "North_Korea": 4+ }++ base_risk = base_risks.get(risk_item, 5)++ # Analyze news sentiment and intensity+ escalation_keywords = self.geopolitical_keywords.get("conflict_escalation", [])+ tension_keywords = self.geopolitical_keywords.get("diplomatic_tensions", [])++ escalation_count = 0+ total_articles = len(news)++ for article in news:+ text = article.value.lower()+ escalation_count += sum(1 for keyword in escalation_keywords if keyword in text)+ escalation_count += sum(1 for keyword in tension_keywords if keyword in text)++ # Adjust base risk based on recent news intensity+ if total_articles > 0:+ intensity_factor = min(escalation_count / total_articles, 2.0)+ adjusted_risk = base_risk + intensity_factor+ else:+ adjusted_risk = base_risk++ return int(np.clip(adjusted_risk, 1, 10))++ def _determine_risk_trend(self, news: List[DataPoint]) -> str:+ """Determine if risk is escalating, stable, or de-escalating"""+ if len(news) < 2:+ return "stable"++ # Sort news by date+ sorted_news = sorted(news, key=lambda x: x.timestamp)++ # Compare recent vs older news intensity+ midpoint = len(sorted_news) // 2+ older_news = sorted_news[:midpoint]+ recent_news = sorted_news[midpoint:]++ older_intensity = self._calculate_news_intensity(older_news)+ recent_intensity = self._calculate_news_intensity(recent_news)++ if recent_intensity > older_intensity * 1.2:+ return "escalating"+ elif recent_intensity < older_intensity * 0.8:+ return "de-escalating"+ else:+ return "stable"++ def _calculate_news_intensity(self, news: List[DataPoint]) -> float:+ """Calculate intensity score of news articles"""+ if not news:+ return 0.0++ intensity_score = 0.0+ escalation_keywords = (self.geopolitical_keywords.get("conflict_escalation", []) ++ self.geopolitical_keywords.get("diplomatic_tensions", []))++ for article in news:+ text = article.value.lower()+ keyword_count = sum(1 for keyword in escalation_keywords if keyword in text)+ # Weight by article confidence+ intensity_score += keyword_count * article.confidence++ return intensity_score / len(news)++ def _calculate_probability_impact(self, risk_level: int, weight: float,+ news: List[DataPoint]) -> float:+ """Calculate probability-weighted impact"""+ # Convert risk level to probability (non-linear)+ probability = (risk_level / 10) ** 1.5++ # Weight by global economic impact+ economic_impact = weight++ # Adjust based on news recency and volume+ if news:+ avg_age_hours = np.mean([(datetime.now() - article.timestamp).total_seconds() / 3600+ for article in news])+ recency_factor = max(0.5, 1.0 - avg_age_hours / 168) # Decay over 1 week+ volume_factor = min(1.5, len(news) / 10) # More news = higher impact+ else:+ recency_factor = 0.5+ volume_factor = 0.5++ return probability * economic_impact * recency_factor * volume_factor++ def _get_affected_sectors(self, category: str, risk_level: int) -> List[str]:+ """Get sectors most affected by this risk category"""+ if category not in self.sector_impact_map:+ return ["broad_market"]++ sector_impacts = self.sector_impact_map[category]++ # Filter sectors by risk level threshold and impact magnitude+ threshold = 0.3 if risk_level > 7 else 0.4 if risk_level > 5 else 0.5++ affected_sectors = []+ for sector, impact in sector_impacts.items():+ if abs(impact) >= threshold:+ affected_sectors.append(sector)++ return affected_sectors or ["broad_market"]++ def _estimate_timeline(self, risk_level: int, trend: str, news: List[DataPoint]) -> str:+ """Estimate timeline for risk materialization"""+ base_timelines = {+ "escalating": {+ 9: "1-3 months",+ 7: "3-6 months",+ 5: "6-12 months",+ 3: "1-2 years"+ },+ "stable": {+ 9: "3-6 months",+ 7: "6-12 months",+ 5: "1-2 years",+ 3: "2+ years"+ },+ "de-escalating": {+ 9: "6-12 months",+ 7: "1-2 years",+ 5: "2+ years",+ 3: "Low probability"+ }+ }++ timeline_map = base_timelines.get(trend, base_timelines["stable"])++ # Find closest risk level+ for level in sorted(timeline_map.keys(), reverse=True):+ if risk_level >= level:+ return timeline_map[level]++ return "2+ years"++ def _get_mitigation_strategies(self, risk_item: str, category: str) -> List[str]:+ """Get investment mitigation strategies for specific risks"""+ strategies = {+ "military_conflicts": [+ "Increase defense sector allocation",+ "Hedge energy exposure",+ "Diversify geographically",+ "Add gold/commodities hedge",+ "Reduce emerging market exposure"+ ],+ "trade_tensions": [+ "Avoid single-country exposure",+ "Focus on domestic-oriented companies",+ "Hedge currency exposure",+ "Diversify supply chains",+ "Consider trade-war beneficiaries"+ ],+ "sanctions_regime": [+ "Avoid sanctioned sectors/countries",+ "Increase compliance monitoring",+ "Diversify banking relationships",+ "Focus on domestic markets",+ "Consider alternative payment systems"+ ],+ "political_instability": [+ "Increase safe-haven assets",+ "Reduce political-sensitive sectors",+ "Focus on multinational companies",+ "Add volatility hedges",+ "Maintain higher cash levels"+ ]+ }++ return strategies.get(category, ["Monitor closely", "Maintain diversification"])++ def _get_region_from_risk(self, risk_item: str) -> str:+ """Map risk item to geographical region"""+ region_mapping = {+ "Russia-Ukraine": "Europe",+ "China-Taiwan": "East_Asia",+ "Middle_East": "Middle_East",+ "North_Korea": "East_Asia",+ "US-China": "Global",+ "US-EU": "North_America",+ "Brexit": "Europe",+ "India-Pakistan": "South_Asia"+ }++ return region_mapping.get(risk_item, "Global")++ def _calculate_risk_confidence(self, news: List[DataPoint], risk_item: str) -> float:+ """Calculate confidence in risk assessment"""+ confidence_factors = []++ # News volume factor+ news_count = len(news)+ volume_confidence = min(1.0, news_count / 20) # Optimal around 20 articles+ confidence_factors.append(volume_confidence * 0.3)++ # Source reliability+ if news:+ avg_source_confidence = np.mean([article.confidence for article in news])+ confidence_factors.append(avg_source_confidence * 0.4)+ else:+ confidence_factors.append(0.3 * 0.4)++ # News recency+ if news:+ most_recent = max(news, key=lambda x: x.timestamp)+ hours_since = (datetime.now() - most_recent.timestamp).total_seconds() / 3600+ recency_confidence = max(0.3, 1.0 - hours_since / 72) # Decay over 3 days+ confidence_factors.append(recency_confidence * 0.3)+ else:+ confidence_factors.append(0.3 * 0.3)++ return np.sum(confidence_factors)++ async def analyze_conflict_escalation(self, conflict_name: str) -> ConflictSignal:+ """Deep analysis of specific military conflict"""+ try:+ # Fetch conflict-specific news+ conflict_news = await self.data_manager.get_multi_source_data({+ "news": {+ "query": conflict_name,+ "sources": ["reuters", "bloomberg", "wsj"],+ "hours_back": 48+ }+ })++ news_data = conflict_news.get("news", [])++ # Calculate escalation risk+ escalation_risk = self._calculate_escalation_risk(news_data, conflict_name)++ # Assess economic impact+ economic_impact = self._assess_economic_impact(conflict_name, escalation_risk)++ # Analyze supply chain risks+ supply_chain_risk = self._analyze_supply_chain_impact(conflict_name)++ # Get market sector impacts+ market_sectors = self._get_market_sector_impacts(conflict_name, escalation_risk)++ # Estimate duration+ duration_estimate = self._estimate_conflict_duration(news_data, escalation_risk)++ return ConflictSignal(+ conflict_name=conflict_name,+ escalation_risk=escalation_risk,+ economic_impact=economic_impact,+ supply_chain_risk=supply_chain_risk,+ market_sectors=market_sectors,+ duration_estimate=duration_estimate+ )++ except Exception as e:+ logging.error(f"Error analyzing conflict {conflict_name}: {e}")+ return self._default_conflict_signal(conflict_name)++ def _calculate_escalation_risk(self, news: List[DataPoint], conflict_name: str) -> float:+ """Calculate probability of conflict escalation"""+ if not news:+ return 0.3 # Default moderate risk++ escalation_indicators = [+ "military buildup", "troop deployment", "weapon delivery",+ "alliance activation", "nuclear threat", "red line crossed",+ "ultimatum", "deadline", "mobilization", "intervention"+ ]++ escalation_score = 0.0++ for article in news:+ text = article.value.lower()+ indicator_count = sum(1 for indicator in escalation_indicators if indicator in text)+ escalation_score += indicator_count * article.confidence++ # Normalize by number of articles+ if news:+ normalized_score = escalation_score / len(news)+ # Convert to probability (0-1)+ return min(1.0, normalized_score / 3.0) # Scale factor++ return 0.3++ def _assess_economic_impact(self, conflict_name: str, escalation_risk: float) -> Dict[str, float]:+ """Assess economic impact of conflict escalation"""+ # Base economic impacts by conflict+ base_impacts = {+ "Russia-Ukraine": {+ "global_gdp": -0.8,+ "inflation": 2.5,+ "energy_prices": 0.4,+ "food_prices": 0.3,+ "supply_chains": -0.6+ },+ "China-Taiwan": {+ "global_gdp": -2.5,+ "inflation": 1.8,+ "tech_supply": -0.8,+ "shipping": -0.7,+ "semiconductors": -0.9+ },+ "Middle_East": {+ "global_gdp": -0.5,+ "oil_prices": 0.6,+ "shipping": -0.4,+ "regional_markets": -0.8,+ "defense_spending": 0.3+ }+ }++ base_impact = base_impacts.get(conflict_name, {+ "global_gdp": -0.3,+ "inflation": 1.0,+ "volatility": 0.5+ })++ # Scale by escalation risk+ scaled_impact = {}+ for key, value in base_impact.items():+ scaled_impact[key] = value * escalation_risk++ return scaled_impact++ def _analyze_supply_chain_impact(self, conflict_name: str) -> Dict[str, float]:+ """Analyze supply chain disruption risks"""+ supply_chain_risks = {+ "Russia-Ukraine": {+ "energy": 0.8,+ "fertilizers": 0.7,+ "grains": 0.6,+ "metals": 0.5,+ "semiconductors": 0.3+ },+ "China-Taiwan": {+ "semiconductors": 0.9,+ "electronics": 0.8,+ "rare_earths": 0.7,+ "shipping": 0.6,+ "manufacturing": 0.7+ },+ "Middle_East": {+ "oil": 0.9,+ "gas": 0.7,+ "shipping": 0.6,+ "petrochemicals": 0.5+ }+ }++ return supply_chain_risks.get(conflict_name, {"general": 0.4})++ def _get_market_sector_impacts(self, conflict_name: str, escalation_risk: float) -> Dict[str, float]:+ """Get sector-specific market impacts"""+ sector_impacts = {+ "Russia-Ukraine": {+ "energy": 0.6,+ "defense": 0.8,+ "agriculture": 0.4,+ "technology": -0.3,+ "airlines": -0.6,+ "tourism": -0.7+ },+ "China-Taiwan": {+ "semiconductors": -0.9,+ "technology": -0.7,+ "defense": 0.8,+ "shipping": -0.6,+ "manufacturing": -0.5,+ "commodities": 0.3+ },+ "Middle_East": {+ "energy": 0.8,+ "defense": 0.6,+ "airlines": -0.5,+ "insurance": -0.4,+ "shipping": -0.3+ }+ }++ base_impacts = sector_impacts.get(conflict_name, {"broad_market": -0.2})++ # Scale by escalation risk+ scaled_impacts = {}+ for sector, impact in base_impacts.items():+ scaled_impacts[sector] = impact * escalation_risk++ return scaled_impacts++ def _estimate_conflict_duration(self, news: List[DataPoint], escalation_risk: float) -> str:+ """Estimate conflict duration based on escalation risk"""+ if escalation_risk > 0.8:+ return "6+ months (high intensity)"+ elif escalation_risk > 0.6:+ return "3-12 months (prolonged)"+ elif escalation_risk > 0.4:+ return "1-6 months (limited)"+ else:+ return "Weeks to months (contained)"++ def _default_geopolitical_risk(self) -> GeopoliticalRisk:+ """Return default risk in case of errors"""+ return GeopoliticalRisk(+ region="Global",+ risk_type="general_uncertainty",+ current_level=5,+ trend="stable",+ probability_impact=0.3,+ affected_sectors=["broad_market"],+ timeline="6-12 months",+ mitigation_strategies=["Maintain diversification", "Monitor developments"],+ confidence=0.3+ )++ def _default_conflict_signal(self, conflict_name: str) -> ConflictSignal:+ """Return default conflict signal"""+ return ConflictSignal(+ conflict_name=conflict_name,+ escalation_risk=0.3,+ economic_impact={"global_gdp": -0.1},+ supply_chain_risk={"general": 0.2},+ market_sectors={"broad_market": -0.1},+ duration_estimate="Unknown"+ )++ async def generate_llm_geopolitical_analysis(self, risks: List[GeopoliticalRisk]) -> Dict:+ """Generate LLM-enhanced geopolitical analysis"""+ try:+ # Prepare risk summary+ risk_summary = self._prepare_risk_summary(risks)++ prompt = f"""+ As a senior geopolitical risk analyst, analyze the current global risk landscape and provide investment guidance.++ Current Top Risks:+ {risk_summary}++ Please provide:+ 1. Most critical risks requiring immediate attention+ 2. Potential black swan scenarios (low probability, high impact)+ 3. Portfolio hedging strategies+ 4. Regional allocation recommendations+ 5. Timeline for next major geopolitical shift+ 6. Early warning indicators to monitor++ Format as JSON with keys: critical_risks, black_swan_scenarios, hedging_strategies,+ regional_allocation, timeline, early_warning_indicators+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM geopolitical analysis: {e}")+ return {+ "critical_risks": ["Russia-Ukraine conflict", "US-China tensions"],+ "black_swan_scenarios": ["Taiwan invasion", "Nuclear incident"],+ "hedging_strategies": ["Increase defense allocation", "Add gold hedge"],+ "regional_allocation": "Underweight emerging markets",+ "timeline": "Next 6-12 months",+ "early_warning_indicators": ["Troop movements", "Diplomatic withdrawals"]+ }++ def _prepare_risk_summary(self, risks: List[GeopoliticalRisk]) -> str:+ """Prepare risk summary for LLM analysis"""+ summary_lines = []++ for risk in risks[:5]: # Top 5 risks+ summary_lines.append(+ f"{risk.region} - {risk.risk_type}: Level {risk.current_level}/10 "+ f"({risk.trend}), Impact: {risk.probability_impact:.2f}, "+ f"Sectors: {', '.join(risk.affected_sectors[:3])}"+ )++ return "\n".join(summary_lines)++ async def get_geopolitical_report(self) -> Dict:+ """Generate comprehensive geopolitical risk report"""+ # Analyze global risks+ global_risks = await self.analyze_global_risks()++ # Analyze specific conflicts+ conflicts = ["Russia-Ukraine", "China-Taiwan", "Middle_East"]+ conflict_analyses = []++ for conflict in conflicts:+ signal = await self.analyze_conflict_escalation(conflict)+ conflict_analyses.append({+ "conflict": conflict,+ "escalation_risk": signal.escalation_risk,+ "economic_impact": signal.economic_impact,+ "duration_estimate": signal.duration_estimate+ })++ # Generate LLM analysis+ llm_analysis = await self.generate_llm_geopolitical_analysis(global_risks)++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "global_risk_assessment": {+ "overall_risk_level": np.mean([risk.current_level for risk in global_risks]),+ "top_risks": [{+ "region": risk.region,+ "type": risk.risk_type,+ "level": risk.current_level,+ "trend": risk.trend,+ "timeline": risk.timeline,+ "affected_sectors": risk.affected_sectors+ } for risk in global_risks[:5]]+ },+ "conflict_monitor": conflict_analyses,+ "investment_implications": {+ "defensive_positioning": self._calculate_defensive_score(global_risks),+ "sector_rotation": self._get_sector_rotation_recommendations(global_risks),+ "regional_weights": self._get_regional_weight_adjustments(global_risks),+ "hedging_requirements": self._get_hedging_requirements(global_risks)+ },+ "llm_analysis": llm_analysis,+ "risk_monitoring": {+ "update_frequency": "every 6 hours",+ "key_indicators": ["news_flow", "market_volatility", "diplomatic_activity"],+ "escalation_triggers": ["military_movement", "sanctions_announcement", "alliance_activation"]+ }+ }++ def _calculate_defensive_score(self, risks: List[GeopoliticalRisk]) -> float:+ """Calculate how defensive portfolio should be"""+ high_risk_count = sum(1 for risk in risks if risk.current_level >= 7)+ escalating_risks = sum(1 for risk in risks if risk.trend == "escalating")++ defensive_score = (high_risk_count * 0.15 + escalating_risks * 0.10)+ return min(1.0, defensive_score)++ def _get_sector_rotation_recommendations(self, risks: List[GeopoliticalRisk]) -> Dict[str, str]:+ """Get sector rotation based on geopolitical risks"""+ sector_scores = defaultdict(float)++ for risk in risks:+ weight = risk.current_level * risk.confidence / 10+ for sector in risk.affected_sectors:+ if sector in self.sector_impact_map.get(risk.risk_type, {}):+ impact = self.sector_impact_map[risk.risk_type][sector]+ sector_scores[sector] += impact * weight++ recommendations = {}+ for sector, score in sector_scores.items():+ if score > 0.2:+ recommendations[sector] = "overweight"+ elif score < -0.2:+ recommendations[sector] = "underweight"+ else:+ recommendations[sector] = "neutral"++ return recommendations++ def _get_regional_weight_adjustments(self, risks: List[GeopoliticalRisk]) -> Dict[str, float]:+ """Get regional allocation adjustments"""+ regional_adjustments = {}++ for region, base_weight in self.regional_weights.items():+ region_risks = [risk for risk in risks if risk.region == region]++ if region_risks:+ avg_risk = np.mean([risk.current_level for risk in region_risks])+ # Reduce allocation for high-risk regions+ adjustment = max(-0.5, (5 - avg_risk) / 10)+ regional_adjustments[region] = base_weight * (1 + adjustment)+ else:+ regional_adjustments[region] = base_weight++ # Normalize to sum to 1+ total_weight = sum(regional_adjustments.values())+ return {region: weight / total_weight for region, weight in regional_adjustments.items()}++ def _get_hedging_requirements(self, risks: List[GeopoliticalRisk]) -> List[str]:+ """Get specific hedging requirements"""+ hedges = []++ high_risks = [risk for risk in risks if risk.current_level >= 7]++ for risk in high_risks:+ if "energy" in risk.affected_sectors:+ hedges.append("Energy price hedge")+ if "technology" in risk.affected_sectors:+ hedges.append("Tech sector put options")+ if "currency" in risk.affected_sectors:+ hedges.append("USD strength hedge")+ if risk.risk_type == "military_conflicts":+ hedges.append("Gold allocation increase")+ hedges.append("Defense sector exposure")++ return list(set(hedges)) # Remove duplicates\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/innovation_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/innovation_agent.pynew file mode 100644index 000000000..4781bc9e5--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/innovation_agent.py@@ -0,0 +1,142 @@+# -*- coding: utf-8 -*-+# agents/innovation_agent.py - Technology Innovation Cycle Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional+import logging+from dataclasses import dataclass+import openai+import json++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class InnovationSignal:+ """Technology innovation signal"""+ technology_sector: str+ adoption_stage: str # emerging, growth, maturity, decline+ disruption_potential: float # 0-1+ investment_opportunity: str+ time_horizon: str+ confidence: float+++class InnovationAgent:+ """Technology innovation cycle analysis and investment opportunities"""++ def __init__(self):+ self.name = "innovation"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ self.innovation_sectors = {+ "artificial_intelligence": {"weight": 0.25, "maturity": "growth"},+ "quantum_computing": {"weight": 0.15, "maturity": "emerging"},+ "biotechnology": {"weight": 0.20, "maturity": "growth"},+ "renewable_energy": {"weight": 0.15, "maturity": "maturity"},+ "space_technology": {"weight": 0.10, "maturity": "emerging"},+ "robotics": {"weight": 0.15, "maturity": "growth"}+ }++ async def analyze_innovation_cycles(self) -> List[InnovationSignal]:+ """Analyze technology innovation cycles"""+ signals = []++ for sector, config in self.innovation_sectors.items():+ try:+ signal = await self._analyze_sector_innovation(sector, config)+ if signal:+ signals.append(signal)+ except Exception as e:+ logging.error(f"Error analyzing {sector}: {e}")+ continue++ return signals++ async def _analyze_sector_innovation(self, sector: str, config: Dict) -> Optional[InnovationSignal]:+ """Analyze innovation in specific technology sector"""+ # Fetch innovation news+ news_data = await self.data_manager.get_multi_source_data({+ "news": {+ "query": sector.replace("_", " ") + " breakthrough innovation",+ "sources": ["reuters", "bloomberg"],+ "hours_back": 168+ }+ })++ news = news_data.get("news", [])++ # Calculate innovation metrics+ breakthrough_count = sum(1 for article in news+ if any(word in article.value.lower()+ for word in ["breakthrough", "revolutionary", "first-of-kind"]))++ funding_mentions = sum(1 for article in news+ if any(word in article.value.lower()+ for word in ["funding", "investment", "IPO", "acquisition"]))++ # Determine adoption stage and disruption potential+ if news:+ disruption_potential = min((breakthrough_count + funding_mentions) / len(news), 1.0)+ else:+ disruption_potential = 0.3++ adoption_stage = config["maturity"]+ investment_opportunity = self._determine_investment_opportunity(disruption_potential, adoption_stage)++ return InnovationSignal(+ technology_sector=sector,+ adoption_stage=adoption_stage,+ disruption_potential=disruption_potential,+ investment_opportunity=investment_opportunity,+ time_horizon=self._estimate_time_horizon(adoption_stage),+ confidence=min(len(news) / 10, 1.0) * 0.7+ )++ def _determine_investment_opportunity(self, disruption_potential: float, stage: str) -> str:+ """Determine investment opportunity classification"""+ if disruption_potential > 0.7 and stage == "emerging":+ return "high_risk_high_reward"+ elif disruption_potential > 0.5 and stage == "growth":+ return "growth_opportunity"+ elif disruption_potential > 0.3 and stage == "maturity":+ return "value_opportunity"+ else:+ return "monitor"++ def _estimate_time_horizon(self, stage: str) -> str:+ """Estimate investment time horizon"""+ horizon_map = {+ "emerging": "long_term",+ "growth": "medium_term",+ "maturity": "short_term",+ "decline": "avoid"+ }+ return horizon_map.get(stage, "medium_term")++ async def get_innovation_report(self) -> Dict:+ """Generate innovation analysis report"""+ signals = await self.analyze_innovation_cycles()++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "innovation_analysis": {+ "sector_signals": [{+ "sector": signal.technology_sector,+ "stage": signal.adoption_stage,+ "disruption_potential": signal.disruption_potential,+ "opportunity": signal.investment_opportunity,+ "time_horizon": signal.time_horizon+ } for signal in signals],+ "top_opportunities": [s.technology_sector for s in signals+ if s.investment_opportunity == "high_risk_high_reward"],+ "emerging_technologies": [s.technology_sector for s in signals+ if s.adoption_stage == "emerging"]+ }+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/institutional_flow_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/institutional_flow_agent.pynew file mode 100644index 000000000..7d0211d78--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/institutional_flow_agent.py@@ -0,0 +1,1133 @@+# -*- coding: utf-8 -*-+# agents/institutional_flow_agent.py - Institutional Flow Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+import json+from collections import defaultdict++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class FlowSignal:+ """Institutional flow signal structure"""+ institution_type: str+ flow_direction: str # inflow, outflow, neutral+ flow_magnitude: float # 0-1 scale+ asset_class: str+ time_horizon: str+ confidence: float+ contrarian_signal: bool+ flow_velocity: float # Rate of change+++@dataclass+class SmartMoneyIndicator:+ """Smart money flow indicator"""+ indicator_name: str+ current_reading: float+ historical_percentile: float+ signal_strength: str # weak, moderate, strong+ market_implication: str+ asset_impact: Dict[str, float]+++class InstitutionalFlowAgent:+ """Advanced institutional flow analysis and smart money tracking"""++ def __init__(self):+ self.name = "institutional_flow"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Institution types and their market influence weights+ self.institution_weights = {+ "pension_funds": 0.25, # Long-term, stable flows+ "sovereign_wealth": 0.20, # Large size, strategic+ "hedge_funds": 0.15, # Fast moving, trend setting+ "mutual_funds": 0.15, # Retail proxy, momentum+ "insurance_companies": 0.10, # Defensive, liability matching+ "endowments": 0.08, # Sophisticated, alternative focus+ "central_banks": 0.07 # Policy driven, FX focused+ }++ # Asset class flow patterns+ self.flow_patterns = {+ "risk_on": {+ "equities": 0.7,+ "high_yield_bonds": 0.4,+ "emerging_markets": 0.6,+ "commodities": 0.3,+ "real_estate": 0.4,+ "alternatives": 0.5+ },+ "risk_off": {+ "government_bonds": 0.8,+ "investment_grade_bonds": 0.6,+ "cash": 0.9,+ "gold": 0.7,+ "defensive_sectors": 0.5,+ "low_volatility": 0.6+ },+ "rotation": {+ "value_to_growth": {"value": 0.6, "growth": -0.4},+ "large_to_small": {"large_cap": -0.3, "small_cap": 0.6},+ "domestic_to_international": {"domestic": -0.2, "international": 0.5}+ }+ }++ # Smart money indicators+ self.smart_money_indicators = {+ "13f_filings": {+ "weight": 0.25,+ "lookback_quarters": 4,+ "significance_threshold": 0.02 # 2% position change+ },+ "insider_trading": {+ "weight": 0.20,+ "lookback_days": 90,+ "significance_threshold": 0.05 # 5% of shares+ },+ "options_flow": {+ "weight": 0.15,+ "lookback_days": 5,+ "significance_threshold": 2.0 # 2x normal volume+ },+ "dark_pool_activity": {+ "weight": 0.15,+ "lookback_days": 10,+ "significance_threshold": 0.4 # 40% of volume+ },+ "repo_market": {+ "weight": 0.10,+ "lookback_days": 30,+ "significance_threshold": 0.1 # 10 bps change+ },+ "etf_flows": {+ "weight": 0.15,+ "lookback_days": 20,+ "significance_threshold": 0.03 # 3% of AUM+ }+ }++ # Flow velocity thresholds+ self.velocity_thresholds = {+ "extremely_fast": 0.8, # >80th percentile+ "fast": 0.6, # >60th percentile+ "moderate": 0.4, # >40th percentile+ "slow": 0.2, # >20th percentile+ "very_slow": 0.0 # <20th percentile+ }++ async def analyze_institutional_flows(self) -> Dict[str, FlowSignal]:+ """Comprehensive institutional flow analysis"""+ flow_signals = {}++ try:+ # Analyze equity flows+ equity_flows = await self._analyze_equity_flows()+ if equity_flows:+ flow_signals["equity_flows"] = equity_flows++ # Analyze bond flows+ bond_flows = await self._analyze_bond_flows()+ if bond_flows:+ flow_signals["bond_flows"] = bond_flows++ # Analyze ETF flows+ etf_flows = await self._analyze_etf_flows()+ if etf_flows:+ flow_signals["etf_flows"] = etf_flows++ # Analyze alternative investment flows+ alternative_flows = await self._analyze_alternative_flows()+ if alternative_flows:+ flow_signals["alternative_flows"] = alternative_flows++ return flow_signals++ except Exception as e:+ logging.error(f"Error in institutional flow analysis: {e}")+ return {"error": self._default_flow_signal()}++ async def _analyze_equity_flows(self) -> Optional[FlowSignal]:+ """Analyze institutional equity flows"""+ try:+ # Fetch institutional trading data+ institutional_data = await self.data_manager.get_multi_source_data({+ "market": {+ "symbol": "SPY", # Use SPY as proxy for overall equity flows+ "data_type": "institutional"+ }+ })++ market_data = institutional_data.get("market", [])+ if not market_data:+ return None++ # Calculate flow metrics+ flow_direction, flow_magnitude = self._calculate_flow_metrics(market_data)++ # Calculate flow velocity+ flow_velocity = self._calculate_flow_velocity(market_data)++ # Determine if contrarian signal+ contrarian_signal = self._is_contrarian_flow(flow_magnitude, flow_velocity)++ # Calculate confidence based on data quality+ confidence = self._calculate_flow_confidence(market_data)++ return FlowSignal(+ institution_type="mixed_institutions",+ flow_direction=flow_direction,+ flow_magnitude=flow_magnitude,+ asset_class="equities",+ time_horizon="medium",+ confidence=confidence,+ contrarian_signal=contrarian_signal,+ flow_velocity=flow_velocity+ )++ except Exception as e:+ logging.error(f"Error in equity flow analysis: {e}")+ return None++ async def _analyze_bond_flows(self) -> Optional[FlowSignal]:+ """Analyze institutional bond flows"""+ try:+ # Fetch bond flow data (using treasury ETF as proxy)+ bond_data = await self.data_manager.get_multi_source_data({+ "market": {+ "symbol": "TLT", # Long-term treasury ETF+ "data_type": "institutional"+ }+ })++ market_data = bond_data.get("market", [])+ if not market_data:+ # Simulate bond flows based on yield movements+ return self._simulate_bond_flows()++ flow_direction, flow_magnitude = self._calculate_flow_metrics(market_data)+ flow_velocity = self._calculate_flow_velocity(market_data)++ return FlowSignal(+ institution_type="fixed_income_institutions",+ flow_direction=flow_direction,+ flow_magnitude=flow_magnitude,+ asset_class="bonds",+ time_horizon="long",+ confidence=0.7,+ contrarian_signal=False, # Bond flows typically not contrarian+ flow_velocity=flow_velocity+ )++ except Exception as e:+ logging.error(f"Error in bond flow analysis: {e}")+ return None++ def _simulate_bond_flows(self) -> FlowSignal:+ """Simulate bond flows when data unavailable"""+ # Simulate based on typical institutional behavior+ flow_magnitude = np.random.uniform(0.3, 0.7)+ flow_direction = np.random.choice(["inflow", "outflow"], p=[0.6, 0.4])++ return FlowSignal(+ institution_type="fixed_income_institutions",+ flow_direction=flow_direction,+ flow_magnitude=flow_magnitude,+ asset_class="bonds",+ time_horizon="long",+ confidence=0.5, # Lower confidence for simulated data+ contrarian_signal=False,+ flow_velocity=0.3+ )++ async def _analyze_etf_flows(self) -> Optional[FlowSignal]:+ """Analyze ETF flows as proxy for institutional sentiment"""+ try:+ # Major ETF flows to analyze+ etfs_to_analyze = ["SPY", "QQQ", "IWM", "EFA", "EEM", "TLT", "GLD"]++ etf_flows = {}+ for etf in etfs_to_analyze:+ # In production, would fetch actual ETF flow data+ # For now, simulate based on market conditions+ flow_data = self._simulate_etf_flow(etf)+ etf_flows[etf] = flow_data++ # Aggregate ETF flows+ total_inflows = sum(flow["inflow"] for flow in etf_flows.values())+ total_outflows = sum(flow["outflow"] for flow in etf_flows.values())++ net_flow = total_inflows - total_outflows+ flow_magnitude = min(abs(net_flow) / (total_inflows + total_outflows), 1.0)+ flow_direction = "inflow" if net_flow > 0 else "outflow"++ # Calculate flow velocity from ETF data+ flow_velocity = np.mean([flow["velocity"] for flow in etf_flows.values()])++ return FlowSignal(+ institution_type="etf_participants",+ flow_direction=flow_direction,+ flow_magnitude=flow_magnitude,+ asset_class="broad_market",+ time_horizon="short",+ confidence=0.8, # ETF flows are reliable indicators+ contrarian_signal=flow_magnitude > 0.7, # Extreme flows can be contrarian+ flow_velocity=flow_velocity+ )++ except Exception as e:+ logging.error(f"Error in ETF flow analysis: {e}")+ return None++ def _simulate_etf_flow(self, etf_symbol: str) -> Dict[str, float]:+ """Simulate ETF flow data"""+ # Base flows by ETF type+ base_flows = {+ "SPY": {"inflow": 0.6, "outflow": 0.4}, # Large cap bias+ "QQQ": {"inflow": 0.7, "outflow": 0.3}, # Tech growth bias+ "IWM": {"inflow": 0.4, "outflow": 0.6}, # Small cap outflows+ "EFA": {"inflow": 0.3, "outflow": 0.7}, # International outflows+ "EEM": {"inflow": 0.2, "outflow": 0.8}, # EM outflows+ "TLT": {"inflow": 0.5, "outflow": 0.5}, # Neutral bonds+ "GLD": {"inflow": 0.4, "outflow": 0.6} # Gold outflows+ }++ base = base_flows.get(etf_symbol, {"inflow": 0.5, "outflow": 0.5})++ # Add random variation+ noise = np.random.normal(0, 0.1)+ inflow = np.clip(base["inflow"] + noise, 0, 1)+ outflow = np.clip(base["outflow"] - noise, 0, 1)++ # Normalize+ total = inflow + outflow+ inflow /= total+ outflow /= total++ velocity = np.random.uniform(0.2, 0.8)++ return {"inflow": inflow, "outflow": outflow, "velocity": velocity}++ async def _analyze_alternative_flows(self) -> Optional[FlowSignal]:+ """Analyze flows into alternative investments"""+ try:+ # Alternatives include private equity, hedge funds, real estate, commodities+ # Simulate based on market conditions and typical allocation patterns++ # Institutional allocation to alternatives typically 10-30%+ base_allocation = 0.2 # 20% baseline++ # Factors affecting alternative flows+ market_stress = np.random.uniform(0, 1) # Would be calculated from VIX, spreads+ yield_environment = np.random.uniform(0, 1) # Low yields favor alternatives++ # Calculate flow direction+ alternative_attractiveness = (market_stress * 0.3 + yield_environment * 0.7)++ if alternative_attractiveness > 0.6:+ flow_direction = "inflow"+ flow_magnitude = (alternative_attractiveness - 0.6) / 0.4+ elif alternative_attractiveness < 0.4:+ flow_direction = "outflow"+ flow_magnitude = (0.4 - alternative_attractiveness) / 0.4+ else:+ flow_direction = "neutral"+ flow_magnitude = 0.1++ return FlowSignal(+ institution_type="sophisticated_institutions",+ flow_direction=flow_direction,+ flow_magnitude=flow_magnitude,+ asset_class="alternatives",+ time_horizon="long",+ confidence=0.6,+ contrarian_signal=False, # Alternative flows are strategic, not contrarian+ flow_velocity=0.2 # Alternatives move slowly+ )++ except Exception as e:+ logging.error(f"Error in alternative flow analysis: {e}")+ return None++ def _calculate_flow_metrics(self, market_data: List[DataPoint]) -> Tuple[str, float]:+ """Calculate flow direction and magnitude from market data"""+ if not market_data:+ return "neutral", 0.1++ # Calculate net institutional flow from position changes+ position_changes = []+ for data_point in market_data:+ change = data_point.value+ position_changes.append(change)++ if position_changes:+ net_flow = np.sum(position_changes)+ total_flow = np.sum(np.abs(position_changes))++ if total_flow > 0:+ flow_magnitude = min(abs(net_flow) / total_flow, 1.0)+ flow_direction = "inflow" if net_flow > 0 else "outflow"+ else:+ flow_magnitude = 0.1+ flow_direction = "neutral"+ else:+ flow_magnitude = 0.1+ flow_direction = "neutral"++ return flow_direction, flow_magnitude++ def _calculate_flow_velocity(self, market_data: List[DataPoint]) -> float:+ """Calculate velocity of institutional flows"""+ if len(market_data) < 2:+ return 0.3++ # Sort by timestamp+ sorted_data = sorted(market_data, key=lambda x: x.timestamp)++ # Calculate rate of change+ velocities = []+ for i in range(1, len(sorted_data)):+ time_diff = (sorted_data[i].timestamp - sorted_data[i - 1].timestamp).days+ value_diff = abs(sorted_data[i].value - sorted_data[i - 1].value)++ if time_diff > 0:+ velocity = value_diff / time_diff+ velocities.append(velocity)++ if velocities:+ avg_velocity = np.mean(velocities)+ # Normalize to 0-1 scale+ normalized_velocity = min(avg_velocity / 0.1, 1.0) # 0.1 as normalization factor+ return normalized_velocity++ return 0.3++ def _is_contrarian_flow(self, flow_magnitude: float, flow_velocity: float) -> bool:+ """Determine if flow represents contrarian opportunity"""+ # High magnitude + high velocity often indicates emotional/momentum driven flows+ # which can be contrarian signals++ extreme_magnitude = flow_magnitude > 0.7+ high_velocity = flow_velocity > 0.6++ return extreme_magnitude and high_velocity++ def _calculate_flow_confidence(self, market_data: List[DataPoint]) -> float:+ """Calculate confidence in flow analysis"""+ if not market_data:+ return 0.3++ # Factors affecting confidence+ data_points = len(market_data)+ data_quality = np.mean([dp.confidence for dp in market_data])+ data_recency = self._calculate_data_recency(market_data)++ # Combine factors+ volume_confidence = min(data_points / 20, 1.0) * 0.4 # Optimal ~20 data points+ quality_confidence = data_quality * 0.4+ recency_confidence = data_recency * 0.2++ return volume_confidence + quality_confidence + recency_confidence++ def _calculate_data_recency(self, market_data: List[DataPoint]) -> float:+ """Calculate how recent the data is"""+ if not market_data:+ return 0.1++ most_recent = max(market_data, key=lambda x: x.timestamp)+ hours_since = (datetime.now() - most_recent.timestamp).total_seconds() / 3600++ # Decay over 48 hours+ recency_score = max(0.1, 1.0 - hours_since / 48)+ return recency_score++ def _default_flow_signal(self) -> FlowSignal:+ """Return default flow signal"""+ return FlowSignal(+ institution_type="unknown",+ flow_direction="neutral",+ flow_magnitude=0.3,+ asset_class="broad_market",+ time_horizon="medium",+ confidence=0.2,+ contrarian_signal=False,+ flow_velocity=0.3+ )++ async def analyze_smart_money_indicators(self) -> List[SmartMoneyIndicator]:+ """Analyze various smart money flow indicators"""+ indicators = []++ try:+ for indicator_name, config in self.smart_money_indicators.items():+ indicator = await self._analyze_specific_indicator(indicator_name, config)+ if indicator:+ indicators.append(indicator)++ return indicators++ except Exception as e:+ logging.error(f"Error in smart money analysis: {e}")+ return []++ async def _analyze_specific_indicator(self, indicator_name: str,+ config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze specific smart money indicator"""+ try:+ if indicator_name == "13f_filings":+ return await self._analyze_13f_filings(config)+ elif indicator_name == "insider_trading":+ return await self._analyze_insider_trading(config)+ elif indicator_name == "options_flow":+ return await self._analyze_options_flow(config)+ elif indicator_name == "dark_pool_activity":+ return await self._analyze_dark_pool_activity(config)+ elif indicator_name == "repo_market":+ return await self._analyze_repo_market(config)+ elif indicator_name == "etf_flows":+ return await self._analyze_etf_smart_money(config)+ else:+ return None++ except Exception as e:+ logging.error(f"Error analyzing {indicator_name}: {e}")+ return None++ async def _analyze_13f_filings(self, config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze 13F filings for institutional position changes"""+ try:+ # Fetch institutional holdings data+ institutional_data = await self.data_manager.get_multi_source_data({+ "market": {+ "symbol": "SPY", # Use broad market as proxy+ "data_type": "institutional"+ }+ })++ holdings_data = institutional_data.get("market", [])+ if not holdings_data:+ # Simulate 13F analysis+ return self._simulate_13f_indicator()++ # Calculate position changes+ position_changes = [dp.value for dp in holdings_data]++ if position_changes:+ current_reading = np.mean(position_changes)+ historical_percentile = self._calculate_percentile(current_reading, position_changes)++ # Determine signal strength+ if abs(current_reading) > config["significance_threshold"]:+ signal_strength = "strong"+ elif abs(current_reading) > config["significance_threshold"] / 2:+ signal_strength = "moderate"+ else:+ signal_strength = "weak"++ # Market implication+ if current_reading > 0.02:+ market_implication = "Institutional accumulation - bullish signal"+ elif current_reading < -0.02:+ market_implication = "Institutional distribution - bearish signal"+ else:+ market_implication = "Neutral institutional positioning"++ return SmartMoneyIndicator(+ indicator_name="13f_filings",+ current_reading=current_reading,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"equities": current_reading * 2} # Amplify for asset impact+ )++ except Exception as e:+ logging.error(f"Error in 13F analysis: {e}")++ return None++ def _simulate_13f_indicator(self) -> SmartMoneyIndicator:+ """Simulate 13F indicator when data unavailable"""+ # Simulate typical institutional behavior+ current_reading = np.random.normal(0.01, 0.02) # Slight bullish bias+ historical_percentile = np.random.uniform(0.3, 0.7)++ signal_strength = "moderate" if abs(current_reading) > 0.015 else "weak"++ if current_reading > 0.02:+ market_implication = "Simulated institutional accumulation"+ elif current_reading < -0.02:+ market_implication = "Simulated institutional distribution"+ else:+ market_implication = "Neutral simulated positioning"++ return SmartMoneyIndicator(+ indicator_name="13f_filings",+ current_reading=current_reading,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"equities": current_reading * 2}+ )++ async def _analyze_insider_trading(self, config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze insider trading patterns"""+ try:+ # Fetch insider trading data+ insider_data = await self.data_manager.get_multi_source_data({+ "market": {+ "symbol": "SPY",+ "data_type": "insider",+ "days_back": config["lookback_days"]+ }+ })++ trades = insider_data.get("market", [])+ if not trades:+ return self._simulate_insider_indicator()++ # Calculate insider buying vs selling+ buy_volume = sum(dp.value for dp in trades if dp.value > 0)+ sell_volume = sum(abs(dp.value) for dp in trades if dp.value < 0)++ total_volume = buy_volume + sell_volume+ if total_volume > 0:+ buy_sell_ratio = (buy_volume - sell_volume) / total_volume++ historical_percentile = np.random.uniform(0.3, 0.8) # Simulate historical context++ if abs(buy_sell_ratio) > config["significance_threshold"]:+ signal_strength = "strong"+ elif abs(buy_sell_ratio) > config["significance_threshold"] / 2:+ signal_strength = "moderate"+ else:+ signal_strength = "weak"++ if buy_sell_ratio > 0.1:+ market_implication = "Strong insider buying - bullish signal"+ elif buy_sell_ratio < -0.1:+ market_implication = "Heavy insider selling - bearish signal"+ else:+ market_implication = "Balanced insider activity"++ return SmartMoneyIndicator(+ indicator_name="insider_trading",+ current_reading=buy_sell_ratio,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"individual_stocks": buy_sell_ratio * 1.5}+ )++ except Exception as e:+ logging.error(f"Error in insider trading analysis: {e}")++ return None++ def _simulate_insider_indicator(self) -> SmartMoneyIndicator:+ """Simulate insider trading indicator"""+ buy_sell_ratio = np.random.normal(-0.02, 0.05) # Slight selling bias (normal)+ historical_percentile = np.random.uniform(0.2, 0.8)++ signal_strength = "moderate" if abs(buy_sell_ratio) > 0.03 else "weak"++ if buy_sell_ratio > 0.05:+ market_implication = "Simulated insider buying signal"+ elif buy_sell_ratio < -0.05:+ market_implication = "Simulated insider selling pressure"+ else:+ market_implication = "Normal insider activity pattern"++ return SmartMoneyIndicator(+ indicator_name="insider_trading",+ current_reading=buy_sell_ratio,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"individual_stocks": buy_sell_ratio * 1.5}+ )++ async def _analyze_options_flow(self, config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze unusual options activity"""+ # Simulate options flow analysis+ # In production, would analyze actual options flow data++ # Simulate call/put ratio and unusual activity+ call_put_ratio = np.random.uniform(0.6, 1.4) # Normal range 0.8-1.2+ unusual_activity_ratio = np.random.uniform(0.8, 3.0) # >2.0 is unusual++ current_reading = (call_put_ratio - 1.0) + (unusual_activity_ratio - 1.0) / 2+ historical_percentile = np.random.uniform(0.2, 0.9)++ if unusual_activity_ratio > config["significance_threshold"]:+ signal_strength = "strong"+ market_implication = f"Unusual options activity detected (ratio: {unusual_activity_ratio:.1f})"+ elif unusual_activity_ratio > 1.5:+ signal_strength = "moderate"+ market_implication = "Elevated options activity"+ else:+ signal_strength = "weak"+ market_implication = "Normal options flow"++ return SmartMoneyIndicator(+ indicator_name="options_flow",+ current_reading=current_reading,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"volatility": current_reading * 0.3, "equities": current_reading * 0.2}+ )++ async def _analyze_dark_pool_activity(self, config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze dark pool trading activity"""+ # Simulate dark pool analysis+ # Dark pools typically 35-45% of equity volume++ dark_pool_percentage = np.random.uniform(0.30, 0.50)+ average_dark_pool = 0.40++ current_reading = dark_pool_percentage - average_dark_pool+ historical_percentile = np.random.uniform(0.2, 0.8)++ if abs(current_reading) > config["significance_threshold"]:+ signal_strength = "strong"+ if current_reading > 0:+ market_implication = "High dark pool activity - large institutional trades"+ else:+ market_implication = "Low dark pool activity - retail dominated"+ elif abs(current_reading) > config["significance_threshold"] / 2:+ signal_strength = "moderate"+ market_implication = "Moderate dark pool activity variation"+ else:+ signal_strength = "weak"+ market_implication = "Normal dark pool activity levels"++ return SmartMoneyIndicator(+ indicator_name="dark_pool_activity",+ current_reading=current_reading,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"equities": current_reading * 0.5}+ )++ async def _analyze_repo_market(self, config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze repo market for institutional liquidity conditions"""+ # Simulate repo market analysis+ # Repo rates typically track fed funds rate++ repo_spread = np.random.normal(0.05, 0.15) # Spread to fed funds+ current_reading = repo_spread+ historical_percentile = np.random.uniform(0.1, 0.9)++ if abs(current_reading) > config["significance_threshold"]:+ signal_strength = "strong"+ if current_reading > 0.1:+ market_implication = "Repo market stress - liquidity tightening"+ else:+ market_implication = "Repo market ease - abundant liquidity"+ else:+ signal_strength = "weak"+ market_implication = "Normal repo market conditions"++ return SmartMoneyIndicator(+ indicator_name="repo_market",+ current_reading=current_reading,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"bonds": -current_reading * 0.8, "equities": -current_reading * 0.3}+ )++ async def _analyze_etf_smart_money(self, config: Dict) -> Optional[SmartMoneyIndicator]:+ """Analyze ETF flows for smart money patterns"""+ # Simulate smart money ETF analysis+ # Look for flows into sophisticated vs retail ETFs++ smart_money_ratio = np.random.uniform(0.4, 1.6) # Smart money vs retail flows+ current_reading = smart_money_ratio - 1.0+ historical_percentile = np.random.uniform(0.2, 0.8)++ if abs(current_reading) > config["significance_threshold"]:+ signal_strength = "strong"+ if current_reading > 0:+ market_implication = "Smart money ETF inflows - sophisticated accumulation"+ else:+ market_implication = "Retail ETF inflows - momentum chasing"+ else:+ signal_strength = "moderate"+ market_implication = "Balanced ETF flow patterns"++ return SmartMoneyIndicator(+ indicator_name="etf_flows",+ current_reading=current_reading,+ historical_percentile=historical_percentile,+ signal_strength=signal_strength,+ market_implication=market_implication,+ asset_impact={"broad_market": current_reading * 0.4}+ )++ def _calculate_percentile(self, current_value: float, historical_values: List[float]) -> float:+ """Calculate percentile of current value in historical context"""+ if not historical_values:+ return 0.5++ sorted_values = sorted(historical_values)++ # Find position of current value+ position = 0+ for value in sorted_values:+ if current_value > value:+ position += 1+ else:+ break++ return position / len(sorted_values)++ async def get_flow_report(self) -> Dict:+ """Generate comprehensive institutional flow report"""+ # Analyze institutional flows+ flow_signals = await self.analyze_institutional_flows()++ # Analyze smart money indicators+ smart_money_indicators = await self.analyze_smart_money_indicators()++ # Calculate overall flow sentiment+ overall_flow_sentiment = self._calculate_overall_flow_sentiment(flow_signals)++ # Generate LLM analysis+ llm_analysis = await self._generate_flow_llm_analysis(flow_signals, smart_money_indicators)++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "flow_analysis": {+ "overall_flow_sentiment": overall_flow_sentiment,+ "flow_classification": self._classify_flow_regime(overall_flow_sentiment),+ "institutional_signals": {+ source: {+ "direction": signal.flow_direction,+ "magnitude": signal.flow_magnitude,+ "velocity": signal.flow_velocity,+ "asset_class": signal.asset_class,+ "contrarian_signal": signal.contrarian_signal,+ "confidence": signal.confidence+ } for source, signal in flow_signals.items() if hasattr(signal, 'flow_direction')+ }+ },+ "smart_money_indicators": [{+ "indicator": indicator.indicator_name,+ "reading": indicator.current_reading,+ "percentile": indicator.historical_percentile,+ "strength": indicator.signal_strength,+ "implication": indicator.market_implication,+ "asset_impact": indicator.asset_impact+ } for indicator in smart_money_indicators],+ "flow_regime_analysis": {+ "current_regime": self._determine_flow_regime(flow_signals),+ "regime_sustainability": self._assess_regime_sustainability(flow_signals),+ "rotation_signals": self._detect_rotation_signals(flow_signals),+ "contrarian_opportunities": self._identify_contrarian_opportunities(flow_signals)+ },+ "trading_implications": {+ "momentum_signals": self._get_momentum_signals(flow_signals),+ "reversal_signals": self._get_reversal_signals(flow_signals),+ "asset_allocation": self._get_flow_based_allocation(overall_flow_sentiment),+ "position_sizing": self._get_flow_position_sizing(flow_signals)+ },+ "llm_analysis": llm_analysis,+ "monitoring_priorities": {+ "high_velocity_flows": [s for s in flow_signals.keys()+ if hasattr(flow_signals[s], 'flow_velocity') and+ flow_signals[s].flow_velocity > 0.6],+ "contrarian_signals": [s for s in flow_signals.keys()+ if hasattr(flow_signals[s], 'contrarian_signal') and+ flow_signals[s].contrarian_signal],+ "strong_smart_money": [i.indicator_name for i in smart_money_indicators+ if i.signal_strength == "strong"]+ }+ }++ def _calculate_overall_flow_sentiment(self, flow_signals: Dict[str, FlowSignal]) -> float:+ """Calculate overall institutional flow sentiment"""+ if not flow_signals:+ return 0.0++ weighted_sentiments = []+ weights = []++ for source, signal in flow_signals.items():+ if hasattr(signal, 'flow_direction'):+ # Convert flow direction to sentiment score+ if signal.flow_direction == "inflow":+ sentiment = signal.flow_magnitude+ elif signal.flow_direction == "outflow":+ sentiment = -signal.flow_magnitude+ else:+ sentiment = 0.0++ # Weight by confidence and institution importance+ weight = signal.confidence * self.institution_weights.get(signal.institution_type, 0.1)++ weighted_sentiments.append(sentiment * weight)+ weights.append(weight)++ if weights:+ return np.sum(weighted_sentiments) / np.sum(weights)+ else:+ return 0.0++ def _classify_flow_regime(self, flow_sentiment: float) -> str:+ """Classify current flow regime"""+ if flow_sentiment > 0.4:+ return "strong_inflows"+ elif flow_sentiment > 0.1:+ return "moderate_inflows"+ elif flow_sentiment > -0.1:+ return "balanced_flows"+ elif flow_sentiment > -0.4:+ return "moderate_outflows"+ else:+ return "strong_outflows"++ def _determine_flow_regime(self, flow_signals: Dict[str, FlowSignal]) -> str:+ """Determine current institutional flow regime"""+ if not flow_signals:+ return "uncertain"++ # Count different flow directions+ inflow_count = sum(1 for s in flow_signals.values()+ if hasattr(s, 'flow_direction') and s.flow_direction == "inflow")+ outflow_count = sum(1 for s in flow_signals.values()+ if hasattr(s, 'flow_direction') and s.flow_direction == "outflow")++ total_signals = len([s for s in flow_signals.values() if hasattr(s, 'flow_direction')])++ if total_signals == 0:+ return "uncertain"++ inflow_ratio = inflow_count / total_signals++ if inflow_ratio > 0.7:+ return "risk_on"+ elif inflow_ratio < 0.3:+ return "risk_off"+ else:+ return "rotation"++ def _assess_regime_sustainability(self, flow_signals: Dict[str, FlowSignal]) -> str:+ """Assess sustainability of current flow regime"""+ if not flow_signals:+ return "uncertain"++ # Check flow velocities and magnitudes+ high_velocity_signals = sum(1 for s in flow_signals.values()+ if hasattr(s, 'flow_velocity') and s.flow_velocity > 0.6)++ extreme_magnitude_signals = sum(1 for s in flow_signals.values()+ if hasattr(s, 'flow_magnitude') and s.flow_magnitude > 0.7)++ total_signals = len(flow_signals)++ if high_velocity_signals > total_signals * 0.5:+ return "unsustainable" # High velocity suggests momentum exhaustion+ elif extreme_magnitude_signals > total_signals * 0.6:+ return "late_stage" # Extreme magnitudes suggest late stage+ else:+ return "sustainable"++ def _detect_rotation_signals(self, flow_signals: Dict[str, FlowSignal]) -> List[str]:+ """Detect sector/style rotation signals"""+ rotation_signals = []++ # Look for opposing flows in different asset classes+ equity_flows = [s for s in flow_signals.values()+ if hasattr(s, 'asset_class') and s.asset_class == "equities"]+ bond_flows = [s for s in flow_signals.values()+ if hasattr(s, 'asset_class') and s.asset_class == "bonds"]++ if equity_flows and bond_flows:+ avg_equity_flow = np.mean([1 if s.flow_direction == "inflow" else -1+ for s in equity_flows if hasattr(s, 'flow_direction')])+ avg_bond_flow = np.mean([1 if s.flow_direction == "inflow" else -1+ for s in bond_flows if hasattr(s, 'flow_direction')])++ if avg_equity_flow > 0.3 and avg_bond_flow < -0.3:+ rotation_signals.append("bond_to_equity_rotation")+ elif avg_equity_flow < -0.3 and avg_bond_flow > 0.3:+ rotation_signals.append("equity_to_bond_rotation")++ return rotation_signals++ def _identify_contrarian_opportunities(self, flow_signals: Dict[str, FlowSignal]) -> List[Dict]:+ """Identify contrarian opportunities from flow extremes"""+ opportunities = []++ for source, signal in flow_signals.items():+ if hasattr(signal, 'contrarian_signal') and signal.contrarian_signal:+ opportunity = {+ "source": source,+ "asset_class": signal.asset_class,+ "opportunity_type": "contrarian_" + signal.flow_direction,+ "conviction": signal.flow_magnitude * signal.confidence,+ "time_horizon": signal.time_horizon+ }+ opportunities.append(opportunity)++ return opportunities++ def _get_momentum_signals(self, flow_signals: Dict[str, FlowSignal]) -> List[str]:+ """Get momentum signals from institutional flows"""+ momentum_signals = []++ for source, signal in flow_signals.items():+ if (hasattr(signal, 'flow_velocity') and signal.flow_velocity > 0.5 and+ hasattr(signal, 'flow_magnitude') and signal.flow_magnitude > 0.4 and+ not signal.contrarian_signal):+ momentum_signals.append(f"{signal.asset_class}_{signal.flow_direction}_momentum")++ return momentum_signals++ def _get_reversal_signals(self, flow_signals: Dict[str, FlowSignal]) -> List[str]:+ """Get reversal signals from institutional flows"""+ reversal_signals = []++ for source, signal in flow_signals.items():+ if hasattr(signal, 'contrarian_signal') and signal.contrarian_signal:+ reversal_signals.append(f"{signal.asset_class}_reversal_signal")++ return reversal_signals++ def _get_flow_based_allocation(self, flow_sentiment: float) -> Dict[str, str]:+ """Get asset allocation based on institutional flows"""+ if flow_sentiment > 0.3:+ return {+ "equities": "overweight",+ "bonds": "underweight",+ "alternatives": "neutral",+ "cash": "underweight"+ }+ elif flow_sentiment < -0.3:+ return {+ "equities": "underweight",+ "bonds": "overweight",+ "alternatives": "neutral",+ "cash": "overweight"+ }+ else:+ return {+ "equities": "neutral",+ "bonds": "neutral",+ "alternatives": "neutral",+ "cash": "neutral"+ }++ def _get_flow_position_sizing(self, flow_signals: Dict[str, FlowSignal]) -> str:+ """Get position sizing recommendation based on flows"""+ if not flow_signals:+ return "normal"++ high_conviction_signals = sum(1 for s in flow_signals.values()+ if hasattr(s, 'confidence') and s.confidence > 0.7)++ contrarian_signals = sum(1 for s in flow_signals.values()+ if hasattr(s, 'contrarian_signal') and s.contrarian_signal)++ total_signals = len(flow_signals)++ if high_conviction_signals > total_signals * 0.6:+ return "increase_size"+ elif contrarian_signals > total_signals * 0.4:+ return "reduce_size"+ else:+ return "normal"++ async def _generate_flow_llm_analysis(self, flow_signals: Dict[str, FlowSignal],+ smart_money_indicators: List[SmartMoneyIndicator]) -> Dict:+ """Generate LLM-enhanced institutional flow analysis"""+ try:+ # Prepare flow summary+ flow_summary = self._prepare_flow_summary(flow_signals)+ smart_money_summary = self._prepare_smart_money_summary(smart_money_indicators)++ prompt = f"""+ As a senior institutional flow analyst, analyze current money flows and provide investment guidance.++ Institutional Flow Analysis:+ {flow_summary}++ Smart Money Indicators:+ {smart_money_summary}++ Please provide:+ 1. Current institutional positioning and sentiment analysis+ 2. Smart money flow patterns and their implications+ 3. Contrarian opportunities from flow extremes+ 4. Asset allocation recommendations based on institutional flows+ 5. Timeline for potential flow reversals+ 6. Risk factors from institutional positioning++ Format as JSON with keys: institutional_positioning, smart_money_patterns, contrarian_opportunities,+ asset_allocation, flow_timeline, risk_factors+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM flow analysis: {e}")+ return {+ "institutional_positioning": "Mixed institutional flows with slight equity bias",+ "smart_money_patterns": "Moderate institutional accumulation in large caps",+ "contrarian_opportunities": "Monitor for sentiment extremes in small caps",+ "asset_allocation": "Balanced approach with equity overweight",+ "flow_timeline": "Next 4-8 weeks for potential shifts",+ "risk_factors": ["Flow velocity", "Sentiment extremes", "Liquidity conditions"]+ }++ def _prepare_flow_summary(self, flow_signals: Dict[str, FlowSignal]) -> str:+ """Prepare flow summary for LLM"""+ summary_lines = []++ for source, signal in flow_signals.items():+ if hasattr(signal, 'flow_direction'):+ summary_lines.append(+ f"{source}: {signal.flow_direction} "+ f"(Magnitude: {signal.flow_magnitude:.2f}, "+ f"Velocity: {signal.flow_velocity:.2f}, "+ f"Asset: {signal.asset_class}, "+ f"Contrarian: {signal.contrarian_signal})"+ )++ return "\n".join(summary_lines) if summary_lines else "Limited flow data available"++ def _prepare_smart_money_summary(self, indicators: List[SmartMoneyIndicator]) -> str:+ """Prepare smart money summary for LLM"""+ summary_lines = []++ for indicator in indicators:+ summary_lines.append(+ f"{indicator.indicator_name}: {indicator.current_reading:.3f} "+ f"({indicator.signal_strength} signal, "+ f"{indicator.historical_percentile:.0%} percentile) - "+ f"{indicator.market_implication}"+ )++ return "\n".join(summary_lines) if summary_lines else "Smart money indicators not available"\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/macro_cycle_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/macro_cycle_agent.pynew file mode 100644index 000000000..284aabce7--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/macro_cycle_agent.py@@ -0,0 +1,525 @@+# -*- coding: utf-8 -*-+# agents/macro_cycle_agent.py - Economic Cycles Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+from scipy import signal+from scipy.stats import pearsonr+import json++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class CycleSignal:+ """Economic cycle signal structure"""+ cycle_type: str+ phase: str+ strength: float+ confidence: float+ duration_months: int+ next_inflection: Optional[datetime]+ supporting_indicators: List[str]+ investment_implications: Dict[str, float]+++class MacroCycleAgent:+ """Advanced economic cycle analysis agent"""++ def __init__(self):+ self.name = "macro_cycle"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Economic cycle indicators and their weights+ self.cycle_indicators = {+ "leading": {+ "DSPIC96": 0.15, # Real Disposable Personal Income+ "HOUST": 0.20, # Housing Starts+ "AWHMAN": 0.10, # Average Weekly Hours Manufacturing+ "PAYEMS": 0.15, # Nonfarm Payrolls+ "UMCSENT": 0.15, # Consumer Sentiment+ "DEXUSEU": 0.10, # USD/EUR Exchange Rate+ "GS10": 0.15 # 10-Year Treasury Rate+ },+ "coincident": {+ "GDPC1": 0.30, # Real GDP+ "INDPRO": 0.25, # Industrial Production+ "PAYEMS": 0.25, # Employment+ "RSAFS": 0.20 # Retail Sales+ },+ "lagging": {+ "UNRATE": 0.40, # Unemployment Rate+ "CPIAUCSL": 0.35, # Consumer Price Index+ "CPILFESL": 0.25 # Core CPI+ }+ }++ # Cycle phases and their characteristics+ self.cycle_phases = {+ "expansion": {+ "gdp_growth": (2.0, 4.0),+ "unemployment": (3.5, 6.0),+ "inflation": (1.5, 3.0),+ "duration_months": (18, 60)+ },+ "peak": {+ "gdp_growth": (1.0, 2.5),+ "unemployment": (3.0, 5.0),+ "inflation": (2.5, 4.0),+ "duration_months": (3, 9)+ },+ "contraction": {+ "gdp_growth": (-2.0, 1.0),+ "unemployment": (5.0, 10.0),+ "inflation": (0.0, 2.0),+ "duration_months": (6, 18)+ },+ "trough": {+ "gdp_growth": (-1.0, 1.5),+ "unemployment": (6.0, 10.0),+ "inflation": (-1.0, 1.5),+ "duration_months": (2, 6)+ }+ }++ # Sector rotation strategy by cycle phase+ self.sector_rotation = {+ "expansion": {+ "technology": 0.25,+ "consumer_discretionary": 0.20,+ "industrials": 0.20,+ "materials": 0.15,+ "financials": 0.20+ },+ "peak": {+ "energy": 0.30,+ "materials": 0.25,+ "financials": 0.20,+ "real_estate": 0.15,+ "utilities": 0.10+ },+ "contraction": {+ "healthcare": 0.25,+ "consumer_staples": 0.25,+ "utilities": 0.20,+ "telecommunications": 0.15,+ "government_bonds": 0.15+ },+ "trough": {+ "technology": 0.30,+ "financials": 0.25,+ "consumer_discretionary": 0.20,+ "industrials": 0.15,+ "small_caps": 0.10+ }+ }++ async def analyze_business_cycle(self) -> CycleSignal:+ """Comprehensive business cycle analysis"""+ try:+ # Fetch economic indicators+ economic_data = await self._fetch_cycle_indicators()++ # Calculate composite leading index+ leading_index = self._calculate_composite_index(economic_data, "leading")+ coincident_index = self._calculate_composite_index(economic_data, "coincident")++ # Determine cycle phase+ current_phase = self._determine_cycle_phase(leading_index, coincident_index)++ # Calculate cycle strength and confidence+ cycle_strength = self._calculate_cycle_strength(economic_data, current_phase)+ confidence = self._calculate_confidence(economic_data, current_phase)++ # Predict next inflection point+ next_inflection = self._predict_inflection_point(leading_index, current_phase)++ # Generate LLM-enhanced analysis+ llm_analysis = await self._generate_llm_analysis(economic_data, current_phase)++ # Get investment implications+ investment_implications = self.sector_rotation.get(current_phase, {})++ return CycleSignal(+ cycle_type="business_cycle",+ phase=current_phase,+ strength=cycle_strength,+ confidence=confidence,+ duration_months=self._estimate_phase_duration(current_phase, economic_data),+ next_inflection=next_inflection,+ supporting_indicators=list(economic_data.keys()),+ investment_implications=investment_implications+ )++ except Exception as e:+ logging.error(f"Error in business cycle analysis: {e}")+ return self._default_cycle_signal()++ async def _fetch_cycle_indicators(self) -> Dict[str, pd.Series]:+ """Fetch all economic indicators for cycle analysis"""+ data_requests = {}++ # Collect all unique indicators+ all_indicators = set()+ for category in self.cycle_indicators.values():+ all_indicators.update(category.keys())++ # Create data requests for each indicator+ for indicator in all_indicators:+ data_requests[f"economic_{indicator}"] = {+ "series_id": indicator,+ "limit": 240 # 20 years of monthly data+ }++ # Fetch data concurrently+ raw_data = await self.data_manager.get_multi_source_data({+ "economic": data_requests+ })++ # Process into time series+ processed_data = {}+ for key, data_points in raw_data.get("economic", {}).items():+ if data_points:+ df = pd.DataFrame([{+ 'date': dp.timestamp,+ 'value': dp.value+ } for dp in data_points])+ df['date'] = pd.to_datetime(df['date'])+ df = df.sort_values('date').set_index('date')++ # Calculate year-over-year growth rates+ indicator_name = key.replace("economic_", "")+ processed_data[indicator_name] = df['value'].pct_change(12) * 100++ return processed_data++ def _calculate_composite_index(self, data: Dict[str, pd.Series],+ indicator_type: str) -> pd.Series:+ """Calculate weighted composite index for indicator category"""+ if indicator_type not in self.cycle_indicators:+ return pd.Series()++ weights = self.cycle_indicators[indicator_type]+ composite_values = []+ dates = None++ for indicator, weight in weights.items():+ if indicator in data and not data[indicator].empty:+ series = data[indicator].dropna()+ if dates is None:+ dates = series.index+ else:+ dates = dates.intersection(series.index)++ if dates is None or len(dates) == 0:+ return pd.Series()++ composite_index = pd.Series(0.0, index=dates)+ total_weight = 0++ for indicator, weight in weights.items():+ if indicator in data and not data[indicator].empty:+ series = data[indicator].reindex(dates).fillna(method='ffill')+ composite_index += series * weight+ total_weight += weight++ if total_weight > 0:+ composite_index /= total_weight++ return composite_index++ def _determine_cycle_phase(self, leading_index: pd.Series,+ coincident_index: pd.Series) -> str:+ """Determine current business cycle phase"""+ if leading_index.empty or coincident_index.empty:+ return "expansion" # Default assumption++ # Get recent trends+ leading_trend = self._calculate_trend(leading_index, periods=6)+ coincident_trend = self._calculate_trend(coincident_index, periods=3)++ # Recent values+ leading_recent = leading_index.iloc[-3:].mean()+ coincident_recent = coincident_index.iloc[-3:].mean()++ # Phase determination logic+ if leading_trend > 0 and coincident_trend > 0 and coincident_recent > 0:+ return "expansion"+ elif leading_trend < 0 and coincident_trend > 0 and coincident_recent > 1:+ return "peak"+ elif leading_trend < 0 and coincident_trend < 0:+ return "contraction"+ elif leading_trend > 0 and coincident_trend < 0 and coincident_recent < -1:+ return "trough"+ else:+ return "expansion" # Default++ def _calculate_trend(self, series: pd.Series, periods: int = 6) -> float:+ """Calculate trend over specified periods"""+ if len(series) < periods:+ return 0.0++ recent_data = series.iloc[-periods:]+ x = np.arange(len(recent_data))++ try:+ slope, _ = np.polyfit(x, recent_data.values, 1)+ return slope+ except:+ return 0.0++ def _calculate_cycle_strength(self, data: Dict[str, pd.Series], phase: str) -> float:+ """Calculate strength of current cycle phase"""+ if phase not in self.cycle_phases:+ return 0.5++ phase_characteristics = self.cycle_phases[phase]+ strength_scores = []++ # Check GDP growth if available+ if "GDPC1" in data and not data["GDPC1"].empty:+ gdp_growth = data["GDPC1"].iloc[-1]+ gdp_range = phase_characteristics["gdp_growth"]+ gdp_score = self._score_in_range(gdp_growth, gdp_range)+ strength_scores.append(gdp_score * 0.4)++ # Check unemployment if available+ if "UNRATE" in data and not data["UNRATE"].empty:+ unemployment = data["UNRATE"].iloc[-1]+ unemp_range = phase_characteristics["unemployment"]+ unemp_score = self._score_in_range(unemployment, unemp_range)+ strength_scores.append(unemp_score * 0.3)++ # Check inflation if available+ if "CPIAUCSL" in data and not data["CPIAUCSL"].empty:+ inflation = data["CPIAUCSL"].iloc[-1]+ inf_range = phase_characteristics["inflation"]+ inf_score = self._score_in_range(inflation, inf_range)+ strength_scores.append(inf_score * 0.3)++ return np.mean(strength_scores) if strength_scores else 0.5++ def _score_in_range(self, value: float, range_tuple: Tuple[float, float]) -> float:+ """Score how well a value fits within expected range"""+ min_val, max_val = range_tuple++ if min_val <= value <= max_val:+ # Perfect fit+ return 1.0+ elif value < min_val:+ # Below range - score based on distance+ distance = min_val - value+ return max(0.0, 1.0 - distance / min_val)+ else:+ # Above range - score based on distance+ distance = value - max_val+ return max(0.0, 1.0 - distance / max_val)++ def _calculate_confidence(self, data: Dict[str, pd.Series], phase: str) -> float:+ """Calculate confidence in cycle phase determination"""+ confidence_factors = []++ # Data availability factor+ available_indicators = len([k for k, v in data.items() if not v.empty])+ total_indicators = sum(len(cat) for cat in self.cycle_indicators.values())+ data_coverage = available_indicators / total_indicators+ confidence_factors.append(data_coverage * 0.3)++ # Data recency factor+ recent_data_count = 0+ for series in data.values():+ if not series.empty and series.index[-1] >= datetime.now() - timedelta(days=90):+ recent_data_count += 1++ recency_factor = recent_data_count / len(data) if data else 0+ confidence_factors.append(recency_factor * 0.3)++ # Consistency factor - how well indicators agree+ phase_consistency = self._calculate_phase_consistency(data, phase)+ confidence_factors.append(phase_consistency * 0.4)++ return np.mean(confidence_factors)++ def _calculate_phase_consistency(self, data: Dict[str, pd.Series], phase: str) -> float:+ """Calculate how consistently indicators point to the same phase"""+ if phase not in self.cycle_phases:+ return 0.5++ consistent_indicators = 0+ total_indicators = 0++ phase_ranges = self.cycle_phases[phase]++ for indicator, series in data.items():+ if series.empty:+ continue++ recent_value = series.iloc[-1]+ total_indicators += 1++ # Check if indicator value is consistent with phase+ if indicator == "GDPC1" and "gdp_growth" in phase_ranges:+ if phase_ranges["gdp_growth"][0] <= recent_value <= phase_ranges["gdp_growth"][1]:+ consistent_indicators += 1+ elif indicator == "UNRATE" and "unemployment" in phase_ranges:+ if phase_ranges["unemployment"][0] <= recent_value <= phase_ranges["unemployment"][1]:+ consistent_indicators += 1+ elif indicator in ["CPIAUCSL", "CPILFESL"] and "inflation" in phase_ranges:+ if phase_ranges["inflation"][0] <= recent_value <= phase_ranges["inflation"][1]:+ consistent_indicators += 1++ return consistent_indicators / total_indicators if total_indicators > 0 else 0.5++ def _predict_inflection_point(self, leading_index: pd.Series, phase: str) -> Optional[datetime]:+ """Predict next cycle inflection point"""+ if leading_index.empty:+ return None++ try:+ # Calculate rate of change in leading indicators+ roc = leading_index.pct_change(3).dropna()++ if len(roc) < 6:+ return None++ # Find trend acceleration/deceleration+ recent_roc = roc.iloc[-6:]+ trend_change = np.diff(recent_roc.values)++ # Estimate time to inflection based on trend+ if phase in ["expansion", "contraction"]:+ # Look for trend reversals+ if len(trend_change) >= 3 and np.all(trend_change[-3:] < 0):+ # Decelerating trend suggests inflection in 3-9 months+ months_ahead = np.random.randint(3, 10)+ else:+ # Stable trend suggests inflection in 6-18 months+ months_ahead = np.random.randint(6, 19)+ else:+ # Peak or trough phases are typically shorter+ months_ahead = np.random.randint(2, 7)++ return datetime.now() + timedelta(days=months_ahead * 30)++ except Exception:+ return None++ def _estimate_phase_duration(self, phase: str, data: Dict[str, pd.Series]) -> int:+ """Estimate duration of current phase"""+ if phase not in self.cycle_phases:+ return 12++ duration_range = self.cycle_phases[phase]["duration_months"]++ # Base estimate from historical averages+ base_duration = np.mean(duration_range)++ # Adjust based on current strength+ current_strength = self._calculate_cycle_strength(data, phase)++ # Stronger phases tend to last longer+ duration_adjustment = (current_strength - 0.5) * 0.3+ adjusted_duration = base_duration * (1 + duration_adjustment)++ return int(np.clip(adjusted_duration, duration_range[0], duration_range[1]))++ async def _generate_llm_analysis(self, data: Dict[str, pd.Series], phase: str) -> Dict:+ """Generate LLM-enhanced cycle analysis"""+ try:+ # Prepare data summary for LLM+ data_summary = self._prepare_data_summary(data)++ prompt = f"""+ As a senior macroeconomic analyst, analyze the current business cycle phase and provide insights.++ Current Phase: {phase}++ Economic Indicators Summary:+ {data_summary}++ Please provide:+ 1. Confirmation or challenge of the current phase assessment+ 2. Key risks to monitor+ 3. Expected duration of current phase+ 4. Investment strategy recommendations+ 5. Probability of recession in next 12 months (0-100%)++ Format as JSON with keys: phase_assessment, key_risks, duration_estimate, investment_strategy, recession_probability+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM analysis: {e}")+ return {+ "phase_assessment": f"Current phase appears to be {phase}",+ "key_risks": ["Data quality", "Model uncertainty"],+ "duration_estimate": "6-12 months",+ "investment_strategy": "Diversified approach recommended",+ "recession_probability": 25+ }++ def _prepare_data_summary(self, data: Dict[str, pd.Series]) -> str:+ """Prepare human-readable data summary for LLM"""+ summary_lines = []++ for indicator, series in data.items():+ if not series.empty:+ latest_value = series.iloc[-1]+ trend = self._calculate_trend(series, 6)++ trend_desc = "rising" if trend > 0.1 else "falling" if trend < -0.1 else "stable"+ summary_lines.append(f"{indicator}: {latest_value:.2f}% ({trend_desc})")++ return "\n".join(summary_lines)++ def _default_cycle_signal(self) -> CycleSignal:+ """Return default cycle signal in case of errors"""+ return CycleSignal(+ cycle_type="business_cycle",+ phase="expansion",+ strength=0.5,+ confidence=0.3,+ duration_months=12,+ next_inflection=datetime.now() + timedelta(days=365),+ supporting_indicators=[],+ investment_implications=self.sector_rotation["expansion"]+ )++ async def get_cycle_report(self) -> Dict:+ """Generate comprehensive cycle analysis report"""+ cycle_signal = await self.analyze_business_cycle()++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "cycle_analysis": {+ "current_phase": cycle_signal.phase,+ "strength": cycle_signal.strength,+ "confidence": cycle_signal.confidence,+ "duration_estimate": cycle_signal.duration_months,+ "next_inflection": cycle_signal.next_inflection.isoformat() if cycle_signal.next_inflection else None+ },+ "investment_implications": cycle_signal.investment_implications,+ "supporting_indicators": cycle_signal.supporting_indicators,+ "risk_assessment": {+ "phase_transition_risk": 1 - cycle_signal.confidence,+ "data_quality_risk": 1 - len(cycle_signal.supporting_indicators) / 10,+ "model_uncertainty": 0.2+ }+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/main.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/main.pynew file mode 100644index 000000000..651a3eeec--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/main.py@@ -0,0 +1,776 @@+# -*- coding: utf-8 -*-+# main.py - AI Hedge Fund Orchestrator and Execution Engine++import asyncio+import logging+import json+import pandas as pd+import numpy as np+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Any+from dataclasses import dataclass+import signal+import sys+from concurrent.futures import ThreadPoolExecutor+import time++from config import CONFIG+from data_feeds import DataFeedManager++# Import all agents+from agents.macro_cycle_agent import MacroCycleAgent+from agents.central_bank_agent import CentralBankAgent+from agents.geopolitical_agent import GeopoliticalAgent+from agents.regulatory_agent import RegulatoryAgent+from agents.sentiment_agent import SentimentAgent+from agents.institutional_flow_agent import InstitutionalFlowAgent+from agents.supply_chain_agent import SupplyChainAgent+from agents.innovation_agent import InnovationAgent+from agents.currency_agent import CurrencyAgent+from agents.behavioral_agent import BehavioralAgent+++@dataclass+class TradingSignal:+ """Aggregated trading signal from all agents"""+ timestamp: datetime+ asset_class: str+ direction: str # long, short, neutral+ conviction: float # 0-1+ position_size: float # 0-1+ time_horizon: str # short, medium, long+ risk_factors: List[str]+ supporting_agents: List[str]+ market_regime: str+++@dataclass+class PortfolioRecommendation:+ """Portfolio-level recommendations"""+ timestamp: datetime+ asset_allocation: Dict[str, float]+ sector_weights: Dict[str, float]+ regional_weights: Dict[str, float]+ risk_budget: Dict[str, float]+ hedges: List[str]+ cash_allocation: float+ leverage: float+++class RiskManager:+ """Portfolio risk management and position sizing"""++ def __init__(self):+ self.max_position_size = CONFIG.risk.max_position_size+ self.max_sector_exposure = CONFIG.risk.max_sector_exposure+ self.var_limit = CONFIG.risk.var_limit+ self.correlation_limit = CONFIG.risk.correlation_limit++ def validate_signal(self, signal: TradingSignal, current_portfolio: Dict) -> bool:+ """Validate trading signal against risk limits"""+ # Position size check+ if signal.position_size > self.max_position_size:+ logging.warning(f"Signal exceeds max position size: {signal.position_size}")+ return False++ # Sector concentration check+ sector_exposure = current_portfolio.get('sectors', {})+ if signal.asset_class in sector_exposure:+ new_exposure = sector_exposure[signal.asset_class] + signal.position_size+ if new_exposure > self.max_sector_exposure:+ logging.warning(f"Signal would exceed sector limits: {new_exposure}")+ return False++ # Risk budget check+ total_risk = sum(current_portfolio.get('risk_budget', {}).values())+ if total_risk + signal.conviction * signal.position_size > 1.0:+ logging.warning("Signal would exceed total risk budget")+ return False++ return True++ def size_position(self, signal: TradingSignal, market_volatility: float) -> float:+ """Calculate optimal position size based on Kelly Criterion"""+ # Kelly formula: f = (bp - q) / b+ # where b = odds, p = probability of win, q = probability of loss++ win_probability = signal.conviction+ loss_probability = 1 - win_probability++ # Estimate expected return based on conviction and market regime+ expected_return = signal.conviction * 0.15 # 15% max expected return++ # Adjust for volatility+ volatility_adjusted_return = expected_return / max(market_volatility, 0.1)++ # Kelly sizing with maximum cap+ kelly_fraction = volatility_adjusted_return / (market_volatility ** 2)++ # Apply safety factor and caps+ safety_factor = 0.25 # Use 1/4 Kelly for safety+ optimal_size = kelly_fraction * safety_factor++ # Cap at configured maximum+ return min(optimal_size, signal.position_size, self.max_position_size)++ def calculate_portfolio_var(self, positions: Dict[str, float],+ returns_covariance: np.ndarray) -> float:+ """Calculate portfolio Value-at-Risk"""+ if not positions or returns_covariance.size == 0:+ return 0.0++ position_vector = np.array(list(positions.values()))+ portfolio_variance = np.dot(position_vector, np.dot(returns_covariance, position_vector))+ portfolio_volatility = np.sqrt(portfolio_variance)++ # 95% VaR (1.645 standard deviations)+ var_95 = 1.645 * portfolio_volatility+ return min(var_95, 1.0)+++class DecisionEngine:+ """Aggregates agent signals and makes final trading decisions"""++ def __init__(self):+ self.agent_weights = CONFIG.agent_weights+ self.risk_manager = RiskManager()++ def aggregate_signals(self, agent_reports: Dict[str, Dict]) -> List[TradingSignal]:+ """Aggregate signals from all agents into trading recommendations"""+ signals = []++ # Combine macro and policy signals for asset allocation+ macro_signal = self._extract_macro_signal(agent_reports)+ if macro_signal:+ signals.append(macro_signal)++ # Generate sector rotation signals+ sector_signals = self._extract_sector_signals(agent_reports)+ signals.extend(sector_signals)++ # Generate currency signals+ currency_signal = self._extract_currency_signal(agent_reports)+ if currency_signal:+ signals.append(currency_signal)++ # Generate defensive/risk-on signals+ risk_signal = self._extract_risk_signal(agent_reports)+ if risk_signal:+ signals.append(risk_signal)++ return signals++ def _extract_macro_signal(self, reports: Dict[str, Dict]) -> Optional[TradingSignal]:+ """Extract macro asset allocation signal"""+ macro_report = reports.get('macro_cycle', {})+ fed_report = reports.get('central_bank', {})++ if not macro_report or not fed_report:+ return None++ # Combine cycle and policy analysis+ cycle_phase = macro_report.get('cycle_analysis', {}).get('current_phase', 'expansion')+ policy_stance = fed_report.get('fed_analysis', {}).get('policy_stance', 'neutral')++ # Determine asset allocation bias+ if cycle_phase == 'expansion' and policy_stance in ['neutral', 'dovish']:+ direction = 'long'+ asset_class = 'equities'+ conviction = 0.7+ elif cycle_phase == 'contraction' or policy_stance == 'hawkish':+ direction = 'long'+ asset_class = 'bonds'+ conviction = 0.6+ elif cycle_phase == 'peak':+ direction = 'short'+ asset_class = 'equities'+ conviction = 0.5+ else:+ return None++ supporting_agents = ['macro_cycle', 'central_bank']++ return TradingSignal(+ timestamp=datetime.now(),+ asset_class=asset_class,+ direction=direction,+ conviction=conviction,+ position_size=0.4, # 40% allocation+ time_horizon='medium',+ risk_factors=['cycle_timing', 'policy_error'],+ supporting_agents=supporting_agents,+ market_regime=f"{cycle_phase}_{policy_stance}"+ )++ def _extract_sector_signals(self, reports: Dict[str, Dict]) -> List[TradingSignal]:+ """Extract sector rotation signals"""+ signals = []++ # Get sector implications from multiple agents+ sector_scores = {}++ # Macro cycle implications+ macro_report = reports.get('macro_cycle', {})+ if macro_report:+ implications = macro_report.get('investment_implications', {})+ for sector, weight in implications.items():+ sector_scores[sector] = sector_scores.get(sector, 0) + weight * self.agent_weights.get('macro_cycle', 0)++ # Geopolitical implications+ geo_report = reports.get('geopolitical', {})+ if geo_report:+ sector_rotation = geo_report.get('investment_implications', {}).get('sector_rotation', {})+ for sector, recommendation in sector_rotation.items():+ weight = 0.2 if recommendation == 'overweight' else -0.2 if recommendation == 'underweight' else 0+ sector_scores[sector] = sector_scores.get(sector, 0) + weight * self.agent_weights.get('geopolitical',+ 0)++ # Convert scores to signals+ for sector, score in sector_scores.items():+ if abs(score) > 0.1: # Minimum threshold+ direction = 'long' if score > 0 else 'short'+ conviction = min(abs(score) * 2, 1.0) # Scale to 0-1++ signals.append(TradingSignal(+ timestamp=datetime.now(),+ asset_class=sector,+ direction=direction,+ conviction=conviction,+ position_size=min(conviction * 0.15, 0.1), # Max 10% per sector+ time_horizon='medium',+ risk_factors=['sector_rotation'],+ supporting_agents=['macro_cycle', 'geopolitical'],+ market_regime='sector_rotation'+ ))++ return signals++ def _extract_currency_signal(self, reports: Dict[str, Dict]) -> Optional[TradingSignal]:+ """Extract currency trading signal"""+ fed_report = reports.get('central_bank', {})+ geo_report = reports.get('geopolitical', {})++ if not fed_report:+ return None++ # Fed policy impact on USD+ policy_stance = fed_report.get('fed_analysis', {}).get('policy_stance', 'neutral')++ if policy_stance == 'hawkish':+ direction = 'long'+ conviction = 0.6+ elif policy_stance == 'dovish':+ direction = 'short'+ conviction = 0.5+ else:+ return None++ # Adjust for geopolitical factors+ if geo_report:+ defensive_score = geo_report.get('investment_implications', {}).get('defensive_positioning', 0)+ if defensive_score > 0.5:+ # High geopolitical risk favors USD as safe haven+ direction = 'long'+ conviction = min(conviction + defensive_score * 0.3, 1.0)++ return TradingSignal(+ timestamp=datetime.now(),+ asset_class='USD',+ direction=direction,+ conviction=conviction,+ position_size=0.2, # 20% currency allocation+ time_horizon='short',+ risk_factors=['policy_divergence', 'geopolitical_events'],+ supporting_agents=['central_bank', 'geopolitical'],+ market_regime=f"currency_{policy_stance}"+ )++ def _extract_risk_signal(self, reports: Dict[str, Dict]) -> Optional[TradingSignal]:+ """Extract overall risk-on/risk-off signal"""+ risk_factors = []+ risk_score = 0.0++ # Aggregate risk from all agents+ for agent_name, report in reports.items():+ agent_weight = self.agent_weights.get(agent_name, 0)++ if agent_name == 'geopolitical':+ geo_risk = report.get('global_risk_assessment', {}).get('overall_risk_level', 5)+ risk_score += (geo_risk - 5) / 5 * agent_weight # Normalize to -1 to 1++ elif agent_name == 'sentiment':+ sentiment_score = report.get('sentiment_analysis', {}).get('overall_sentiment', 0)+ risk_score += sentiment_score * agent_weight++ elif agent_name == 'institutional_flow':+ flow_signal = report.get('flow_analysis', {}).get('risk_sentiment', 0)+ risk_score += flow_signal * agent_weight++ # Convert to trading signal+ if abs(risk_score) > 0.2: # Minimum threshold+ if risk_score > 0:+ # Risk-on environment+ asset_class = 'risk_assets'+ direction = 'long'+ else:+ # Risk-off environment+ asset_class = 'safe_havens'+ direction = 'long'++ conviction = min(abs(risk_score), 1.0)++ return TradingSignal(+ timestamp=datetime.now(),+ asset_class=asset_class,+ direction=direction,+ conviction=conviction,+ position_size=conviction * 0.3, # Scale position size+ time_horizon='short',+ risk_factors=risk_factors,+ supporting_agents=list(reports.keys()),+ market_regime='risk_on' if risk_score > 0 else 'risk_off'+ )++ return None++ def generate_portfolio_recommendation(self, signals: List[TradingSignal],+ current_portfolio: Dict) -> PortfolioRecommendation:+ """Generate comprehensive portfolio recommendation"""++ # Initialize allocations+ asset_allocation = {+ 'equities': 0.6,+ 'bonds': 0.3,+ 'commodities': 0.05,+ 'cash': 0.05+ }++ sector_weights = {}+ regional_weights = CONFIG.regional_weights.copy()+ hedges = []++ # Apply signals to modify allocations+ for signal in signals:+ validated = self.risk_manager.validate_signal(signal, current_portfolio)++ if validated:+ if signal.asset_class in asset_allocation:+ # Adjust asset class allocation+ adjustment = signal.position_size * (1 if signal.direction == 'long' else -1)+ asset_allocation[signal.asset_class] += adjustment++ elif signal.asset_class in ['risk_assets', 'safe_havens']:+ # Risk-on/off adjustment+ if signal.asset_class == 'risk_assets' and signal.direction == 'long':+ asset_allocation['equities'] += signal.position_size * 0.5+ asset_allocation['bonds'] -= signal.position_size * 0.3+ elif signal.asset_class == 'safe_havens' and signal.direction == 'long':+ asset_allocation['bonds'] += signal.position_size * 0.4+ asset_allocation['cash'] += signal.position_size * 0.2+ asset_allocation['equities'] -= signal.position_size * 0.4++ # Collect sector weights+ if signal.asset_class not in ['USD', 'risk_assets', 'safe_havens']:+ sector_weights[signal.asset_class] = signal.position_size * (+ 1 if signal.direction == 'long' else -1)++ # Collect hedging requirements+ hedges.extend(signal.risk_factors)++ # Normalize allocations+ total_allocation = sum(asset_allocation.values())+ if total_allocation != 1.0:+ for asset in asset_allocation:+ asset_allocation[asset] /= total_allocation++ # Set risk budget based on conviction levels+ risk_budget = {}+ for signal in signals:+ risk_budget[signal.asset_class] = signal.conviction * signal.position_size++ return PortfolioRecommendation(+ timestamp=datetime.now(),+ asset_allocation=asset_allocation,+ sector_weights=sector_weights,+ regional_weights=regional_weights,+ risk_budget=risk_budget,+ hedges=list(set(hedges)), # Remove duplicates+ cash_allocation=asset_allocation.get('cash', 0.05),+ leverage=1.0 # No leverage for now+ )+++class HedgeFundOrchestrator:+ """Main orchestrator for the AI hedge fund system"""++ def __init__(self):+ self.data_manager = DataFeedManager()+ self.decision_engine = DecisionEngine()+ self.risk_manager = RiskManager()++ # Initialize all agents+ self.agents = {+ 'macro_cycle': MacroCycleAgent(),+ 'central_bank': CentralBankAgent(),+ 'geopolitical': GeopoliticalAgent(),+ 'regulatory': RegulatoryAgent(),+ 'sentiment': SentimentAgent(),+ 'institutional_flow': InstitutionalFlowAgent(),+ 'supply_chain': SupplyChainAgent(),+ 'innovation': InnovationAgent(),+ 'currency': CurrencyAgent(),+ 'behavioral': BehavioralAgent()+ }++ self.current_portfolio = {+ 'positions': {},+ 'sectors': {},+ 'risk_budget': {},+ 'last_rebalance': datetime.now()+ }++ self.is_running = False+ self.update_interval = CONFIG.agent.update_frequency # seconds++ # Setup logging+ self._setup_logging()++ def _setup_logging(self):+ """Setup comprehensive logging"""+ logging.basicConfig(+ level=CONFIG.log_level,+ format=CONFIG.log_format,+ handlers=[+ logging.FileHandler(CONFIG.logs_dir / f"hedge_fund_{datetime.now().strftime('%Y%m%d')}.log"),+ logging.StreamHandler(sys.stdout)+ ]+ )++ # Create separate loggers for different components+ self.logger = logging.getLogger("HedgeFundOrchestrator")+ self.trade_logger = logging.getLogger("TradingSignals")+ self.risk_logger = logging.getLogger("RiskManagement")++ async def run_analysis_cycle(self) -> Dict[str, Any]:+ """Run one complete analysis cycle"""+ cycle_start = time.time()+ self.logger.info("Starting analysis cycle")++ try:+ # Run all agents concurrently+ agent_reports = await self._run_all_agents()++ # Generate trading signals+ signals = self.decision_engine.aggregate_signals(agent_reports)++ # Generate portfolio recommendation+ portfolio_rec = self.decision_engine.generate_portfolio_recommendation(+ signals, self.current_portfolio+ )++ # Execute trades (simulated)+ execution_results = await self._execute_trades(signals, portfolio_rec)++ # Update portfolio state+ self._update_portfolio_state(execution_results, portfolio_rec)++ # Log performance+ cycle_time = time.time() - cycle_start+ self.logger.info(f"Analysis cycle completed in {cycle_time:.2f} seconds")++ return {+ 'timestamp': datetime.now().isoformat(),+ 'cycle_time': cycle_time,+ 'agent_reports': agent_reports,+ 'trading_signals': [self._signal_to_dict(s) for s in signals],+ 'portfolio_recommendation': self._portfolio_to_dict(portfolio_rec),+ 'execution_results': execution_results,+ 'current_portfolio': self.current_portfolio+ }++ except Exception as e:+ self.logger.error(f"Error in analysis cycle: {e}")+ return {'error': str(e), 'timestamp': datetime.now().isoformat()}++ async def _run_all_agents(self) -> Dict[str, Dict]:+ """Run all agents concurrently"""+ self.logger.info("Running agent analysis")++ async def run_agent(name: str, agent):+ try:+ if hasattr(agent, 'get_cycle_report'):+ return await agent.get_cycle_report()+ elif hasattr(agent, 'get_policy_report'):+ return await agent.get_policy_report()+ elif hasattr(agent, 'get_geopolitical_report'):+ return await agent.get_geopolitical_report()+ else:+ # Generic report method+ return await agent.generate_report()+ except Exception as e:+ self.logger.error(f"Error running agent {name}: {e}")+ return {'error': str(e), 'agent': name}++ # Run agents concurrently+ tasks = [run_agent(name, agent) for name, agent in self.agents.items()]+ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Combine results+ agent_reports = {}+ for i, (name, agent) in enumerate(self.agents.items()):+ if i < len(results) and not isinstance(results[i], Exception):+ agent_reports[name] = results[i]+ else:+ self.logger.error(f"Agent {name} failed: {results[i] if i < len(results) else 'Unknown error'}")+ agent_reports[name] = {'error': 'Agent failed', 'agent': name}++ return agent_reports++ async def _execute_trades(self, signals: List[TradingSignal],+ portfolio_rec: PortfolioRecommendation) -> Dict[str, Any]:+ """Execute trading signals (simulated)"""+ self.trade_logger.info(f"Executing {len(signals)} trading signals")++ executed_trades = []+ total_trading_cost = 0.0++ for signal in signals:+ # Validate signal+ if not self.risk_manager.validate_signal(signal, self.current_portfolio):+ self.trade_logger.warning(f"Signal rejected by risk manager: {signal.asset_class}")+ continue++ # Calculate position size+ market_volatility = self._estimate_market_volatility(signal.asset_class)+ position_size = self.risk_manager.size_position(signal, market_volatility)++ # Simulate execution+ execution_price = self._get_execution_price(signal.asset_class)+ trading_cost = position_size * CONFIG.trading.commission_rate+ slippage_cost = position_size * CONFIG.trading.slippage_assumption++ executed_trade = {+ 'timestamp': datetime.now().isoformat(),+ 'asset_class': signal.asset_class,+ 'direction': signal.direction,+ 'position_size': position_size,+ 'execution_price': execution_price,+ 'trading_cost': trading_cost,+ 'slippage_cost': slippage_cost,+ 'signal_conviction': signal.conviction+ }++ executed_trades.append(executed_trade)+ total_trading_cost += trading_cost + slippage_cost++ self.trade_logger.info(f"Executed: {signal.direction} {position_size:.3f} {signal.asset_class}")++ return {+ 'executed_trades': executed_trades,+ 'total_trades': len(executed_trades),+ 'total_trading_cost': total_trading_cost,+ 'rejected_signals': len(signals) - len(executed_trades)+ }++ def _estimate_market_volatility(self, asset_class: str) -> float:+ """Estimate market volatility for asset class"""+ # Simplified volatility estimates+ volatility_map = {+ 'equities': 0.16,+ 'bonds': 0.08,+ 'commodities': 0.25,+ 'USD': 0.12,+ 'technology': 0.22,+ 'energy': 0.30,+ 'financials': 0.18+ }++ return volatility_map.get(asset_class, 0.15)++ def _get_execution_price(self, asset_class: str) -> float:+ """Get simulated execution price"""+ # Simplified pricing - in production would use real market data+ base_prices = {+ 'equities': 100.0,+ 'bonds': 98.5,+ 'commodities': 85.2,+ 'USD': 1.0,+ 'technology': 105.3,+ 'energy': 92.1+ }++ base_price = base_prices.get(asset_class, 100.0)+ # Add small random variation+ return base_price * (1 + np.random.normal(0, 0.002))++ def _update_portfolio_state(self, execution_results: Dict,+ portfolio_rec: PortfolioRecommendation):+ """Update current portfolio state"""+ # Update positions+ for trade in execution_results.get('executed_trades', []):+ asset_class = trade['asset_class']+ position_change = trade['position_size'] * (1 if trade['direction'] == 'long' else -1)++ self.current_portfolio['positions'][asset_class] = (+ self.current_portfolio['positions'].get(asset_class, 0) + position_change+ )++ # Update sector allocations+ self.current_portfolio['sectors'] = portfolio_rec.sector_weights++ # Update risk budget+ self.current_portfolio['risk_budget'] = portfolio_rec.risk_budget++ # Update last rebalance time+ self.current_portfolio['last_rebalance'] = datetime.now()++ self.logger.info("Portfolio state updated")++ def _signal_to_dict(self, signal: TradingSignal) -> Dict:+ """Convert trading signal to dictionary"""+ return {+ 'timestamp': signal.timestamp.isoformat(),+ 'asset_class': signal.asset_class,+ 'direction': signal.direction,+ 'conviction': signal.conviction,+ 'position_size': signal.position_size,+ 'time_horizon': signal.time_horizon,+ 'risk_factors': signal.risk_factors,+ 'supporting_agents': signal.supporting_agents,+ 'market_regime': signal.market_regime+ }++ def _portfolio_to_dict(self, portfolio: PortfolioRecommendation) -> Dict:+ """Convert portfolio recommendation to dictionary"""+ return {+ 'timestamp': portfolio.timestamp.isoformat(),+ 'asset_allocation': portfolio.asset_allocation,+ 'sector_weights': portfolio.sector_weights,+ 'regional_weights': portfolio.regional_weights,+ 'risk_budget': portfolio.risk_budget,+ 'hedges': portfolio.hedges,+ 'cash_allocation': portfolio.cash_allocation,+ 'leverage': portfolio.leverage+ }++ async def start_continuous_operation(self):+ """Start continuous hedge fund operation"""+ self.is_running = True+ self.logger.info("Starting continuous hedge fund operation")++ try:+ while self.is_running:+ # Run analysis cycle+ cycle_results = await self.run_analysis_cycle()++ # Save results+ await self._save_cycle_results(cycle_results)++ # Wait for next cycle+ await asyncio.sleep(self.update_interval)++ except KeyboardInterrupt:+ self.logger.info("Received shutdown signal")+ except Exception as e:+ self.logger.error(f"Error in continuous operation: {e}")+ finally:+ self.is_running = False+ self.logger.info("Hedge fund operation stopped")++ async def _save_cycle_results(self, results: Dict):+ """Save cycle results for analysis"""+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")+ filename = CONFIG.data_dir / f"cycle_results_{timestamp}.json"++ try:+ with open(filename, 'w') as f:+ json.dump(results, f, indent=2, default=str)+ except Exception as e:+ self.logger.error(f"Error saving results: {e}")++ def stop(self):+ """Stop the hedge fund operation"""+ self.is_running = False+ self.logger.info("Stopping hedge fund operation")++ async def get_status(self) -> Dict[str, Any]:+ """Get current system status"""+ return {+ 'timestamp': datetime.now().isoformat(),+ 'is_running': self.is_running,+ 'agents_count': len(self.agents),+ 'current_portfolio': self.current_portfolio,+ 'last_update': self.current_portfolio.get('last_rebalance', datetime.now()).isoformat(),+ 'system_health': await self._check_system_health()+ }++ async def _check_system_health(self) -> Dict[str, str]:+ """Check system health status"""+ health = {}++ # Check data feeds+ try:+ data_summary = self.data_manager.get_latest_data_summary()+ health['data_feeds'] = 'healthy'+ except Exception:+ health['data_feeds'] = 'degraded'++ # Check agent status+ healthy_agents = sum(1 for agent in self.agents.values() if hasattr(agent, 'name'))+ health['agents'] = 'healthy' if healthy_agents == len(self.agents) else 'degraded'++ # Check configuration+ try:+ CONFIG.validate_config()+ health['configuration'] = 'healthy'+ except Exception:+ health['configuration'] = 'error'++ return health+++# Signal handlers for graceful shutdown+def signal_handler(orchestrator):+ def handler(signum, frame):+ logging.info(f"Received signal {signum}")+ orchestrator.stop()++ return handler+++async def main():+ """Main entry point"""+ # Validate configuration+ try:+ CONFIG.validate_config()+ print("✓ Configuration validated")+ except Exception as e:+ print(f"✗ Configuration error: {e}")+ sys.exit(1)++ # Initialize orchestrator+ orchestrator = HedgeFundOrchestrator()++ # Setup signal handlers+ signal.signal(signal.SIGINT, signal_handler(orchestrator))+ signal.signal(signal.SIGTERM, signal_handler(orchestrator))++ print("\n🚀 AI Hedge Fund System Starting...")+ print("=" * 50)++ # Run single analysis cycle or continuous operation+ if len(sys.argv) > 1 and sys.argv[1] == "--single-cycle":+ print("Running single analysis cycle...")+ results = await orchestrator.run_analysis_cycle()+ print("\n📊 Analysis Results:")+ print(json.dumps(results, indent=2, default=str))+ else:+ print("Starting continuous operation...")+ print("Press Ctrl+C to stop")+ await orchestrator.start_continuous_operation()++ print("\n✅ System shutdown complete")+++if __name__ == "__main__":+ asyncio.run(main())\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/regulatory_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/regulatory_agent.pynew file mode 100644index 000000000..c655932b0--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/regulatory_agent.py@@ -0,0 +1,903 @@+# -*- coding: utf-8 -*-+# agents/regulatory_agent.py - Regulatory Intelligence Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+import json+import re+from collections import defaultdict++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class RegulatorySignal:+ """Regulatory change signal structure"""+ regulation_type: str+ jurisdiction: str+ impact_level: int # 1-10 scale+ implementation_timeline: str+ affected_sectors: List[str]+ market_impact: Dict[str, float]+ compliance_cost: float+ competitive_advantage: Dict[str, float]+ confidence: float+++@dataclass+class PolicyChange:+ """Policy change monitoring structure"""+ policy_area: str+ change_type: str # proposed, enacted, implemented+ probability_passage: float+ economic_impact: Dict[str, float]+ sector_winners: List[str]+ sector_losers: List[str]+ timeline: str+++class RegulatoryAgent:+ """Advanced regulatory intelligence and policy change analysis"""++ def __init__(self):+ self.name = "regulatory"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Regulatory domains and their market impact weights+ self.regulatory_domains = {+ "financial_regulation": {+ "banking_rules": 0.25,+ "securities_regulation": 0.20,+ "derivatives_oversight": 0.15,+ "crypto_regulation": 0.15,+ "payment_systems": 0.10,+ "systemic_risk": 0.15+ },+ "environmental_regulation": {+ "carbon_pricing": 0.30,+ "renewable_mandates": 0.25,+ "emission_standards": 0.20,+ "plastic_bans": 0.10,+ "water_regulation": 0.08,+ "biodiversity_rules": 0.07+ },+ "technology_regulation": {+ "data_privacy": 0.25,+ "ai_governance": 0.20,+ "platform_regulation": 0.20,+ "cybersecurity_rules": 0.15,+ "semiconductor_controls": 0.20+ },+ "healthcare_regulation": {+ "drug_pricing": 0.30,+ "medical_device_approval": 0.25,+ "telehealth_rules": 0.15,+ "insurance_regulation": 0.15,+ "public_health_policy": 0.15+ },+ "tax_policy": {+ "corporate_tax_rates": 0.35,+ "international_tax_coordination": 0.25,+ "digital_services_tax": 0.20,+ "carbon_tax": 0.20+ }+ }++ # Sector impact mapping from regulatory changes+ self.sector_impact_map = {+ "financial_regulation": {+ "banks": -0.6,+ "insurance": -0.4,+ "asset_management": -0.3,+ "fintech": -0.5,+ "real_estate": -0.2,+ "consumer_finance": -0.4+ },+ "environmental_regulation": {+ "oil_gas": -0.8,+ "utilities": 0.3,+ "renewable_energy": 0.7,+ "automotive": -0.4,+ "chemicals": -0.5,+ "materials": -0.3,+ "industrials": -0.2+ },+ "technology_regulation": {+ "big_tech": -0.7,+ "social_media": -0.8,+ "semiconductors": -0.4,+ "cybersecurity": 0.5,+ "cloud_services": -0.3,+ "telecommunications": -0.2+ },+ "healthcare_regulation": {+ "pharmaceuticals": -0.5,+ "biotechnology": -0.3,+ "medical_devices": -0.4,+ "health_insurance": -0.6,+ "hospitals": -0.3,+ "telehealth": 0.4+ },+ "tax_policy": {+ "multinational_corps": -0.6,+ "domestic_focused": 0.2,+ "high_margin_tech": -0.5,+ "capital_intensive": 0.1,+ "dividend_stocks": -0.3+ }+ }++ # Regulatory keyword patterns+ self.regulatory_keywords = {+ "proposal_stage": [+ "proposed rule", "draft regulation", "consultation paper",+ "request for comment", "policy proposal", "legislative draft"+ ],+ "advancement_stage": [+ "committee approval", "senate passage", "house passage",+ "regulatory approval", "agency adoption", "cabinet approval"+ ],+ "implementation_stage": [+ "effective date", "compliance deadline", "enforcement begins",+ "mandatory compliance", "phased implementation", "grace period"+ ],+ "enforcement_action": [+ "regulatory fine", "enforcement action", "compliance violation",+ "penalty imposed", "consent order", "regulatory sanction"+ ]+ }++ # Jurisdictional weights based on global market impact+ self.jurisdiction_weights = {+ "United_States": 0.35,+ "European_Union": 0.25,+ "China": 0.20,+ "United_Kingdom": 0.10,+ "Japan": 0.05,+ "Other": 0.05+ }++ async def analyze_regulatory_landscape(self) -> List[RegulatorySignal]:+ """Comprehensive regulatory landscape analysis"""+ signals = []++ try:+ # Analyze each regulatory domain+ for domain, regulations in self.regulatory_domains.items():+ domain_signals = await self._analyze_regulatory_domain(domain, regulations)+ signals.extend(domain_signals)++ # Sort by impact level and confidence+ signals.sort(key=lambda x: x.impact_level * x.confidence, reverse=True)++ return signals[:15] # Return top 15 regulatory signals++ except Exception as e:+ logging.error(f"Error in regulatory landscape analysis: {e}")+ return [self._default_regulatory_signal()]++ async def _analyze_regulatory_domain(self, domain: str, regulations: Dict[str, float]) -> List[RegulatorySignal]:+ """Analyze specific regulatory domain"""+ domain_signals = []++ # Get news data for this domain+ news_data = await self._fetch_regulatory_news(domain, list(regulations.keys()))++ for regulation, weight in regulations.items():+ try:+ # Filter news for this specific regulation+ relevant_news = [news for news in news_data+ if self._is_relevant_to_regulation(news, regulation, domain)]++ if not relevant_news:+ continue++ # Analyze regulatory stage and probability+ stage_analysis = self._analyze_regulatory_stage(relevant_news)++ # Calculate impact level+ impact_level = self._calculate_regulatory_impact(relevant_news, regulation, domain, weight)++ # Determine affected sectors+ affected_sectors = self._get_affected_sectors(domain, impact_level)++ # Calculate market impact+ market_impact = self._calculate_market_impact(domain, regulation, impact_level)++ # Estimate compliance costs+ compliance_cost = self._estimate_compliance_cost(regulation, domain, impact_level)++ # Identify competitive advantages+ competitive_advantage = self._analyze_competitive_impact(domain, regulation, relevant_news)++ # Generate timeline+ timeline = self._estimate_implementation_timeline(stage_analysis, relevant_news)++ # Calculate confidence+ confidence = self._calculate_regulatory_confidence(relevant_news, stage_analysis)++ signal = RegulatorySignal(+ regulation_type=f"{domain}_{regulation}",+ jurisdiction=self._determine_jurisdiction(relevant_news),+ impact_level=impact_level,+ implementation_timeline=timeline,+ affected_sectors=affected_sectors,+ market_impact=market_impact,+ compliance_cost=compliance_cost,+ competitive_advantage=competitive_advantage,+ confidence=confidence+ )++ domain_signals.append(signal)++ except Exception as e:+ logging.error(f"Error analyzing regulation {regulation}: {e}")+ continue++ return domain_signals++ async def _fetch_regulatory_news(self, domain: str, regulations: List[str]) -> List[DataPoint]:+ """Fetch regulatory news for specific domain"""+ all_news = []++ # Create domain-specific search queries+ domain_queries = {+ "financial_regulation": ["banking regulation", "financial oversight", "securities rules",+ "fintech regulation"],+ "environmental_regulation": ["environmental regulation", "carbon policy", "emissions standards",+ "green legislation"],+ "technology_regulation": ["tech regulation", "data privacy", "ai governance", "platform oversight"],+ "healthcare_regulation": ["healthcare policy", "drug regulation", "medical device approval",+ "health insurance"],+ "tax_policy": ["tax reform", "corporate tax", "international taxation", "digital tax"]+ }++ queries = domain_queries.get(domain, [domain.replace("_", " ")])++ for query in queries:+ try:+ news_data = await self.data_manager.get_multi_source_data({+ "news": {+ "query": query,+ "sources": ["reuters", "bloomberg", "wsj", "ft"],+ "hours_back": 168 # 1 week+ }+ })++ if "news" in news_data:+ all_news.extend(news_data["news"])++ except Exception as e:+ logging.error(f"Error fetching regulatory news for {query}: {e}")+ continue++ return all_news++ def _is_relevant_to_regulation(self, news: DataPoint, regulation: str, domain: str) -> bool:+ """Check if news is relevant to specific regulation"""+ text = (news.value + " " + news.metadata.get("description", "")).lower()++ # Create regulation-specific keywords+ regulation_keywords = {+ "banking_rules": ["basel", "capital requirements", "stress test", "bank supervision"],+ "carbon_pricing": ["carbon tax", "cap and trade", "emissions trading", "carbon border"],+ "data_privacy": ["gdpr", "data protection", "privacy regulation", "data governance"],+ "drug_pricing": ["prescription drug", "medicare negotiation", "drug pricing", "pharmaceutical"],+ "ai_governance": ["artificial intelligence", "ai regulation", "algorithmic oversight", "ai safety"]+ }++ keywords = regulation_keywords.get(regulation, [regulation.replace("_", " ")])++ # Also check for regulatory action keywords+ regulatory_action_keywords = [+ "regulation", "policy", "rule", "legislation", "bill", "act",+ "oversight", "compliance", "enforcement", "approval", "mandate"+ ]++ has_regulation_keyword = any(keyword in text for keyword in keywords)+ has_action_keyword = any(keyword in text for keyword in regulatory_action_keywords)++ return has_regulation_keyword and has_action_keyword++ def _analyze_regulatory_stage(self, news: List[DataPoint]) -> Dict[str, float]:+ """Analyze what stage regulations are in"""+ stage_scores = {+ "proposal": 0.0,+ "advancement": 0.0,+ "implementation": 0.0,+ "enforcement": 0.0+ }++ total_articles = len(news)+ if total_articles == 0:+ return stage_scores++ for article in news:+ text = article.value.lower()++ # Count stage indicators+ for stage, keywords in self.regulatory_keywords.items():+ stage_name = stage.replace("_stage", "").replace("_action", "")+ for keyword in keywords:+ if keyword in text:+ stage_scores[stage_name] += article.confidence / total_articles++ return stage_scores++ def _calculate_regulatory_impact(self, news: List[DataPoint], regulation: str,+ domain: str, weight: float) -> int:+ """Calculate regulatory impact level (1-10)"""+ if not news:+ return 3++ # Base impact levels by regulation type+ base_impacts = {+ "banking_rules": 7,+ "carbon_pricing": 8,+ "data_privacy": 6,+ "drug_pricing": 8,+ "corporate_tax_rates": 9,+ "ai_governance": 5,+ "securities_regulation": 6+ }++ base_impact = base_impacts.get(regulation, 5)++ # Analyze news intensity and scope+ high_impact_keywords = [+ "sweeping changes", "major reform", "significant impact", "industry transformation",+ "mandatory compliance", "substantial penalties", "widespread adoption",+ "market disruption", "regulatory overhaul", "unprecedented"+ ]++ scope_indicators = [+ "global", "international", "nationwide", "industry-wide", "comprehensive",+ "all companies", "every business", "mandatory for all"+ ]++ intensity_score = 0+ scope_score = 0++ for article in news:+ text = article.value.lower()+ intensity_score += sum(1 for keyword in high_impact_keywords if keyword in text)+ scope_score += sum(1 for keyword in scope_indicators if keyword in text)++ # Adjust base impact+ if news:+ intensity_factor = min(intensity_score / len(news), 2.0)+ scope_factor = min(scope_score / len(news), 1.5)+ weight_factor = weight * 2 # Domain weight influence++ adjusted_impact = base_impact + intensity_factor + scope_factor + weight_factor+ else:+ adjusted_impact = base_impact++ return int(np.clip(adjusted_impact, 1, 10))++ def _get_affected_sectors(self, domain: str, impact_level: int) -> List[str]:+ """Get sectors affected by regulatory domain"""+ if domain not in self.sector_impact_map:+ return ["broad_market"]++ sector_impacts = self.sector_impact_map[domain]++ # Filter sectors by impact threshold+ threshold = 0.2 if impact_level > 7 else 0.3 if impact_level > 5 else 0.4++ affected_sectors = []+ for sector, impact in sector_impacts.items():+ if abs(impact) >= threshold:+ affected_sectors.append(sector)++ return affected_sectors or ["broad_market"]++ def _calculate_market_impact(self, domain: str, regulation: str, impact_level: int) -> Dict[str, float]:+ """Calculate expected market impact by asset class"""+ if domain not in self.sector_impact_map:+ return {"broad_market": 0.0}++ sector_impacts = self.sector_impact_map[domain]++ # Scale impacts by regulation impact level+ impact_multiplier = impact_level / 10.0++ market_impacts = {}+ for sector, base_impact in sector_impacts.items():+ scaled_impact = base_impact * impact_multiplier+ market_impacts[sector] = np.clip(scaled_impact, -1.0, 1.0)++ return market_impacts++ def _estimate_compliance_cost(self, regulation: str, domain: str, impact_level: int) -> float:+ """Estimate compliance cost as percentage of revenue"""+ # Base compliance costs by regulation type (% of revenue)+ base_costs = {+ "banking_rules": 0.015, # 1.5% of revenue+ "data_privacy": 0.008, # 0.8% of revenue+ "emissions_standards": 0.012, # 1.2% of revenue+ "drug_pricing": 0.005, # 0.5% of revenue+ "cybersecurity_rules": 0.010 # 1.0% of revenue+ }++ base_cost = base_costs.get(regulation, 0.005)++ # Scale by impact level+ impact_multiplier = impact_level / 5.0 # Normalize around level 5++ return base_cost * impact_multiplier++ def _analyze_competitive_impact(self, domain: str, regulation: str,+ news: List[DataPoint]) -> Dict[str, float]:+ """Analyze which companies/sectors gain competitive advantage"""+ competitive_advantages = {}++ # Analyze news for competitive implications+ advantage_keywords = {+ "large_companies": ["economies of scale", "large companies benefit", "big players advantage"],+ "incumbents": ["existing players", "incumbent advantage", "barriers to entry"],+ "tech_leaders": ["technology advantage", "innovation leaders", "digital transformation"],+ "compliance_specialists": ["compliance expertise", "regulatory experience", "specialized knowledge"]+ }++ for company_type, keywords in advantage_keywords.items():+ advantage_score = 0.0++ for article in news:+ text = article.value.lower()+ keyword_count = sum(1 for keyword in keywords if keyword in text)+ advantage_score += keyword_count * article.confidence++ if news and advantage_score > 0:+ competitive_advantages[company_type] = min(advantage_score / len(news), 1.0)++ return competitive_advantages++ def _estimate_implementation_timeline(self, stage_analysis: Dict[str, float],+ news: List[DataPoint]) -> str:+ """Estimate regulatory implementation timeline"""+ # Determine current stage+ current_stage = max(stage_analysis.items(), key=lambda x: x[1])[0]++ # Timeline estimates by stage+ timeline_estimates = {+ "proposal": "12-24 months",+ "advancement": "6-18 months",+ "implementation": "3-12 months",+ "enforcement": "Immediate"+ }++ base_timeline = timeline_estimates.get(current_stage, "12-24 months")++ # Look for specific timeline mentions in news+ timeline_patterns = [+ r"(\d+)\s*months?",+ r"(\d+)\s*years?",+ r"by\s+(\d{4})",+ r"effective\s+(\w+\s+\d{1,2},?\s+\d{4})"+ ]++ for article in news:+ text = article.value+ for pattern in timeline_patterns:+ matches = re.findall(pattern, text, re.IGNORECASE)+ if matches:+ # Found specific timeline mention+ return f"Specific timeline mentioned: {matches[0]}"++ return base_timeline++ def _determine_jurisdiction(self, news: List[DataPoint]) -> str:+ """Determine primary jurisdiction from news"""+ jurisdiction_keywords = {+ "United_States": ["usa", "united states", "sec", "fed", "congress", "senate", "house"],+ "European_Union": ["eu", "european union", "brussels", "european commission", "esma"],+ "China": ["china", "beijing", "pboc", "csrc", "chinese regulators"],+ "United_Kingdom": ["uk", "united kingdom", "fca", "pra", "bank of england"],+ "Japan": ["japan", "jfsa", "boj", "bank of japan"]+ }++ jurisdiction_scores = {j: 0 for j in jurisdiction_keywords.keys()}++ for article in news:+ text = article.value.lower()+ for jurisdiction, keywords in jurisdiction_keywords.items():+ score = sum(1 for keyword in keywords if keyword in text)+ jurisdiction_scores[jurisdiction] += score * article.confidence++ if any(jurisdiction_scores.values()):+ return max(jurisdiction_scores.items(), key=lambda x: x[1])[0]++ return "Multiple/Global"++ def _calculate_regulatory_confidence(self, news: List[DataPoint],+ stage_analysis: Dict[str, float]) -> float:+ """Calculate confidence in regulatory analysis"""+ confidence_factors = []++ # News volume and quality+ if news:+ news_confidence = min(len(news) / 10, 1.0) * 0.3 # Optimal around 10 articles+ source_quality = np.mean([article.confidence for article in news]) * 0.4+ confidence_factors.extend([news_confidence, source_quality])+ else:+ confidence_factors.extend([0.1, 0.2])++ # Stage clarity - clearer stage = higher confidence+ max_stage_score = max(stage_analysis.values()) if stage_analysis else 0+ stage_confidence = max_stage_score * 0.3+ confidence_factors.append(stage_confidence)++ return np.sum(confidence_factors)++ def _default_regulatory_signal(self) -> RegulatorySignal:+ """Return default regulatory signal"""+ return RegulatorySignal(+ regulation_type="general_regulatory_uncertainty",+ jurisdiction="Global",+ impact_level=5,+ implementation_timeline="12-24 months",+ affected_sectors=["broad_market"],+ market_impact={"broad_market": 0.0},+ compliance_cost=0.005,+ competitive_advantage={},+ confidence=0.3+ )++ async def analyze_policy_changes(self) -> List[PolicyChange]:+ """Analyze upcoming policy changes and their market implications"""+ policy_changes = []++ policy_areas = [+ "tax_reform", "healthcare_policy", "infrastructure_spending",+ "trade_policy", "energy_policy", "immigration_policy"+ ]++ for policy_area in policy_areas:+ try:+ change = await self._analyze_specific_policy(policy_area)+ if change:+ policy_changes.append(change)+ except Exception as e:+ logging.error(f"Error analyzing policy {policy_area}: {e}")+ continue++ return policy_changes++ async def _analyze_specific_policy(self, policy_area: str) -> Optional[PolicyChange]:+ """Analyze specific policy area for changes"""+ # Get policy-related news+ news_data = await self.data_manager.get_multi_source_data({+ "news": {+ "query": policy_area.replace("_", " "),+ "sources": ["reuters", "bloomberg", "wsj"],+ "hours_back": 72+ }+ })++ news = news_data.get("news", [])+ if not news:+ return None++ # Analyze policy change type and probability+ change_type = self._determine_policy_change_type(news)+ probability = self._calculate_passage_probability(news, policy_area)++ if probability < 0.2: # Skip low-probability changes+ return None++ # Calculate economic impact+ economic_impact = self._calculate_policy_economic_impact(policy_area, news)++ # Identify winners and losers+ winners, losers = self._identify_policy_winners_losers(policy_area)++ # Estimate timeline+ timeline = self._estimate_policy_timeline(news, change_type)++ return PolicyChange(+ policy_area=policy_area,+ change_type=change_type,+ probability_passage=probability,+ economic_impact=economic_impact,+ sector_winners=winners,+ sector_losers=losers,+ timeline=timeline+ )++ def _determine_policy_change_type(self, news: List[DataPoint]) -> str:+ """Determine type of policy change"""+ change_keywords = {+ "proposed": ["proposed", "draft", "plan", "considering", "exploring"],+ "enacted": ["passed", "approved", "enacted", "signed", "adopted"],+ "implemented": ["effective", "implementation", "rollout", "enforcement"]+ }++ change_scores = {change_type: 0 for change_type in change_keywords.keys()}++ for article in news:+ text = article.value.lower()+ for change_type, keywords in change_keywords.items():+ score = sum(1 for keyword in keywords if keyword in text)+ change_scores[change_type] += score++ return max(change_scores.items(), key=lambda x: x[1])[0] if any(change_scores.values()) else "proposed"++ def _calculate_passage_probability(self, news: List[DataPoint], policy_area: str) -> float:+ """Calculate probability of policy passage"""+ # Base probabilities by policy area and political difficulty+ base_probabilities = {+ "tax_reform": 0.4,+ "healthcare_policy": 0.3,+ "infrastructure_spending": 0.6,+ "trade_policy": 0.5,+ "energy_policy": 0.4,+ "immigration_policy": 0.2+ }++ base_prob = base_probabilities.get(policy_area, 0.4)++ # Analyze news sentiment for passage likelihood+ positive_indicators = ["bipartisan support", "broad agreement", "likely to pass", "strong support"]+ negative_indicators = ["opposition", "unlikely to pass", "political deadlock", "controversy"]++ positive_score = 0+ negative_score = 0++ for article in news:+ text = article.value.lower()+ positive_score += sum(1 for indicator in positive_indicators if indicator in text)+ negative_score += sum(1 for indicator in negative_indicators if indicator in text)++ # Adjust probability based on sentiment+ if news:+ sentiment_adjustment = (positive_score - negative_score) / len(news) * 0.3+ adjusted_prob = base_prob + sentiment_adjustment+ else:+ adjusted_prob = base_prob++ return np.clip(adjusted_prob, 0.0, 1.0)++ def _calculate_policy_economic_impact(self, policy_area: str, news: List[DataPoint]) -> Dict[str, float]:+ """Calculate economic impact of policy changes"""+ # Base economic impacts by policy area (% GDP impact)+ base_impacts = {+ "tax_reform": {"gdp_growth": 0.3, "business_investment": 0.5, "consumer_spending": 0.2},+ "infrastructure_spending": {"gdp_growth": 0.8, "employment": 0.6, "productivity": 0.4},+ "healthcare_policy": {"healthcare_costs": -0.3, "business_costs": 0.2, "innovation": -0.1},+ "trade_policy": {"trade_volumes": 0.4, "manufacturing": 0.3, "consumer_prices": -0.2},+ "energy_policy": {"energy_costs": -0.2, "green_investment": 0.6, "traditional_energy": -0.4}+ }++ return base_impacts.get(policy_area, {"gdp_growth": 0.1})++ def _identify_policy_winners_losers(self, policy_area: str) -> Tuple[List[str], List[str]]:+ """Identify sector winners and losers from policy changes"""+ policy_impacts = {+ "tax_reform": {+ "winners": ["domestic_companies", "small_business", "manufacturing"],+ "losers": ["multinationals", "high_tax_rate_sectors"]+ },+ "infrastructure_spending": {+ "winners": ["construction", "materials", "industrials", "transportation"],+ "losers": ["bond_investors"] # Higher deficits+ },+ "healthcare_policy": {+ "winners": ["healthcare_providers", "medical_devices"],+ "losers": ["pharmaceuticals", "health_insurance"]+ },+ "energy_policy": {+ "winners": ["renewable_energy", "electric_vehicles", "grid_infrastructure"],+ "losers": ["fossil_fuels", "traditional_utilities"]+ }+ }++ impacts = policy_impacts.get(policy_area, {"winners": [], "losers": []})+ return impacts["winners"], impacts["losers"]++ def _estimate_policy_timeline(self, news: List[DataPoint], change_type: str) -> str:+ """Estimate policy implementation timeline"""+ timeline_map = {+ "proposed": "6-18 months to passage",+ "enacted": "3-12 months to implementation",+ "implemented": "Currently rolling out"+ }++ return timeline_map.get(change_type, "12-24 months")++ async def get_regulatory_report(self) -> Dict:+ """Generate comprehensive regulatory intelligence report"""+ # Analyze regulatory landscape+ regulatory_signals = await self.analyze_regulatory_landscape()++ # Analyze policy changes+ policy_changes = await self.analyze_policy_changes()++ # Generate LLM analysis+ llm_analysis = await self._generate_regulatory_llm_analysis(regulatory_signals, policy_changes)++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "regulatory_landscape": {+ "high_impact_regulations": [{+ "regulation": signal.regulation_type,+ "jurisdiction": signal.jurisdiction,+ "impact_level": signal.impact_level,+ "timeline": signal.implementation_timeline,+ "affected_sectors": signal.affected_sectors,+ "market_impact": signal.market_impact+ } for signal in regulatory_signals[:5]],+ "compliance_cost_estimate": np.mean([s.compliance_cost for s in regulatory_signals]),+ "overall_regulatory_pressure": np.mean([s.impact_level for s in regulatory_signals])+ },+ "policy_changes": [{+ "policy_area": change.policy_area,+ "change_type": change.change_type,+ "probability": change.probability_passage,+ "economic_impact": change.economic_impact,+ "winners": change.sector_winners,+ "losers": change.sector_losers,+ "timeline": change.timeline+ } for change in policy_changes],+ "investment_implications": {+ "defensive_sectors": self._get_defensive_regulatory_sectors(regulatory_signals),+ "regulatory_beneficiaries": self._get_regulatory_beneficiaries(regulatory_signals),+ "compliance_leaders": self._get_compliance_advantage_sectors(regulatory_signals),+ "regulatory_risk_sectors": self._get_high_risk_sectors(regulatory_signals)+ },+ "llm_analysis": llm_analysis,+ "monitoring_priorities": {+ "key_regulations": [s.regulation_type for s in regulatory_signals[:3]],+ "high_probability_policies": [c.policy_area for c in policy_changes if c.probability_passage > 0.6],+ "immediate_compliance_deadlines": [s.regulation_type for s in regulatory_signals+ if "months" in s.implementation_timeline and+ int(s.implementation_timeline.split()[0]) <= 6]+ }+ }++ async def _generate_regulatory_llm_analysis(self, signals: List[RegulatorySignal],+ policy_changes: List[PolicyChange]) -> Dict:+ """Generate LLM-enhanced regulatory analysis"""+ try:+ # Prepare regulatory summary+ reg_summary = self._prepare_regulatory_summary(signals)+ policy_summary = self._prepare_policy_summary(policy_changes)++ prompt = f"""+ As a senior regulatory affairs analyst, analyze the current regulatory landscape and provide investment guidance.++ Key Regulatory Developments:+ {reg_summary}++ Policy Changes:+ {policy_summary}++ Please provide:+ 1. Most critical regulatory risks requiring immediate attention+ 2. Regulatory arbitrage opportunities (sectors benefiting from regulatory changes)+ 3. Compliance cost leaders vs laggards investment strategy+ 4. Timeline for next major regulatory wave+ 5. Sector rotation recommendations based on regulatory trends+ 6. Early warning indicators for regulatory surprises++ Format as JSON with keys: critical_risks, arbitrage_opportunities, compliance_strategy,+ regulatory_timeline, sector_rotation, early_warning_indicators+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM regulatory analysis: {e}")+ return {+ "critical_risks": ["Financial regulation tightening", "ESG compliance requirements"],+ "arbitrage_opportunities": ["Compliance technology", "Renewable energy"],+ "compliance_strategy": "Focus on established players with regulatory expertise",+ "regulatory_timeline": "Next 12-18 months",+ "sector_rotation": "Overweight compliance leaders, underweight regulatory laggards",+ "early_warning_indicators": ["Congressional hearings", "Agency enforcement actions"]+ }++ def _prepare_regulatory_summary(self, signals: List[RegulatorySignal]) -> str:+ """Prepare regulatory summary for LLM"""+ summary_lines = []++ for signal in signals[:5]: # Top 5 signals+ summary_lines.append(+ f"{signal.regulation_type} ({signal.jurisdiction}): "+ f"Impact Level {signal.impact_level}/10, "+ f"Timeline: {signal.implementation_timeline}, "+ f"Sectors: {', '.join(signal.affected_sectors[:3])}, "+ f"Compliance Cost: {signal.compliance_cost:.1%}"+ )++ return "\n".join(summary_lines)++ def _prepare_policy_summary(self, policy_changes: List[PolicyChange]) -> str:+ """Prepare policy changes summary for LLM"""+ summary_lines = []++ for policy in policy_changes:+ summary_lines.append(+ f"{policy.policy_area}: {policy.change_type} "+ f"(Probability: {policy.probability_passage:.0%}), "+ f"Winners: {', '.join(policy.sector_winners[:2])}, "+ f"Losers: {', '.join(policy.sector_losers[:2])}"+ )++ return "\n".join(summary_lines)++ def _get_defensive_regulatory_sectors(self, signals: List[RegulatorySignal]) -> List[str]:+ """Get sectors that are defensive against regulatory risk"""+ defensive_sectors = []++ # Sectors typically less affected by regulation+ inherently_defensive = ["utilities", "consumer_staples", "healthcare_providers"]++ # Sectors with positive regulatory tailwinds+ for signal in signals:+ for sector, impact in signal.market_impact.items():+ if impact > 0.3: # Positive regulatory impact+ defensive_sectors.append(sector)++ all_defensive = inherently_defensive + defensive_sectors+ return list(set(all_defensive)) # Remove duplicates++ def _get_regulatory_beneficiaries(self, signals: List[RegulatorySignal]) -> List[str]:+ """Get sectors that benefit from regulatory changes"""+ beneficiaries = []++ for signal in signals:+ for sector, impact in signal.market_impact.items():+ if impact > 0.4: # Strong positive impact+ beneficiaries.append(sector)++ # Check competitive advantages+ for advantage_type, score in signal.competitive_advantage.items():+ if score > 0.5 and advantage_type == "compliance_specialists":+ beneficiaries.extend(["legal_services", "compliance_tech", "consulting"])++ return list(set(beneficiaries))++ def _get_compliance_advantage_sectors(self, signals: List[RegulatorySignal]) -> List[str]:+ """Get sectors with compliance competitive advantages"""+ advantage_sectors = []++ for signal in signals:+ for advantage_type, score in signal.competitive_advantage.items():+ if score > 0.4:+ if advantage_type == "large_companies":+ advantage_sectors.extend(["mega_cap_stocks", "blue_chip_companies"])+ elif advantage_type == "tech_leaders":+ advantage_sectors.extend(["technology", "software"])+ elif advantage_type == "incumbents":+ advantage_sectors.extend(["established_players"])++ return list(set(advantage_sectors))++ def _get_high_risk_sectors(self, signals: List[RegulatorySignal]) -> List[str]:+ """Get sectors with high regulatory risk"""+ high_risk_sectors = []++ for signal in signals:+ if signal.impact_level >= 7: # High impact regulations+ for sector, impact in signal.market_impact.items():+ if impact < -0.3: # Negative impact+ high_risk_sectors.append(sector)++ return list(set(high_risk_sectors))\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/sentiment_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/sentiment_agent.pynew file mode 100644index 000000000..a23c98ead--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/sentiment_agent.py@@ -0,0 +1,875 @@+# -*- coding: utf-8 -*-+# agents/sentiment_agent.py - Market Sentiment Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+import json+from textblob import TextBlob+import re+from collections import defaultdict, Counter++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class SentimentSignal:+ """Market sentiment signal structure"""+ source: str+ sentiment_score: float # -1 to 1+ intensity: float # 0 to 1+ reliability: float+ trend: str # improving, deteriorating, stable+ contrarian_signal: bool+ affected_assets: List[str]+ time_horizon: str+++@dataclass+class FearGreedMetrics:+ """Fear & Greed index components"""+ vix_level: float+ put_call_ratio: float+ safe_haven_flows: float+ momentum_strength: float+ overall_score: int # 0-100+ classification: str # extreme_fear, fear, neutral, greed, extreme_greed+++class SentimentAgent:+ """Advanced market sentiment analysis and contrarian signal generation"""++ def __init__(self):+ self.name = "sentiment"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Sentiment sources and their reliability weights+ self.sentiment_sources = {+ "financial_news": {+ "reuters": 0.25,+ "bloomberg": 0.25,+ "wsj": 0.20,+ "ft": 0.15,+ "cnbc": 0.10,+ "marketwatch": 0.05+ },+ "social_media": {+ "twitter_fintwit": 0.40,+ "reddit_investing": 0.25,+ "reddit_wallstreetbets": 0.20,+ "stocktwits": 0.15+ },+ "analyst_sentiment": {+ "upgrade_downgrade": 0.35,+ "earnings_revisions": 0.30,+ "price_target_changes": 0.25,+ "recommendation_changes": 0.10+ },+ "market_indicators": {+ "vix": 0.30,+ "put_call_ratio": 0.25,+ "high_low_index": 0.20,+ "advance_decline": 0.25+ }+ }++ # Sentiment keywords with weights+ self.sentiment_keywords = {+ "extremely_bullish": {+ "keywords": ["moon", "rocket", "bull run", "unstoppable", "explosive growth",+ "parabolic", "to the stars", "massive rally", "euphoric"],+ "weight": 1.0,+ "contrarian_signal": True+ },+ "bullish": {+ "keywords": ["bullish", "optimistic", "positive", "uptrend", "rally", "growth",+ "strong", "buy", "accumulate", "opportunity"],+ "weight": 0.6,+ "contrarian_signal": False+ },+ "neutral": {+ "keywords": ["neutral", "mixed", "uncertain", "wait and see", "sideways",+ "balanced", "cautious", "hold"],+ "weight": 0.0,+ "contrarian_signal": False+ },+ "bearish": {+ "keywords": ["bearish", "pessimistic", "negative", "downtrend", "decline",+ "weakness", "sell", "avoid", "risk"],+ "weight": -0.6,+ "contrarian_signal": False+ },+ "extremely_bearish": {+ "keywords": ["crash", "collapse", "doom", "disaster", "panic", "bloodbath",+ "capitulation", "apocalypse", "end times", "dead"],+ "weight": -1.0,+ "contrarian_signal": True+ }+ }++ # Asset class sentiment mapping+ self.asset_sentiment_keywords = {+ "stocks": ["equity", "stock", "shares", "s&p", "nasdaq", "dow"],+ "bonds": ["bonds", "treasury", "yield", "fixed income", "debt"],+ "gold": ["gold", "precious metals", "safe haven"],+ "crypto": ["bitcoin", "crypto", "ethereum", "digital assets"],+ "oil": ["oil", "crude", "energy", "petroleum"],+ "dollar": ["dollar", "usd", "currency", "forex"]+ }++ # Contrarian sentiment thresholds+ self.contrarian_thresholds = {+ "extreme_bullish": 0.8, # When sentiment too positive+ "extreme_bearish": -0.8, # When sentiment too negative+ "consensus_threshold": 0.7 # When consensus too strong+ }++ async def analyze_market_sentiment(self) -> Dict[str, SentimentSignal]:+ """Comprehensive market sentiment analysis across all sources"""+ sentiment_signals = {}++ try:+ # Analyze news sentiment+ news_sentiment = await self._analyze_news_sentiment()+ if news_sentiment:+ sentiment_signals["news"] = news_sentiment++ # Analyze social media sentiment+ social_sentiment = await self._analyze_social_sentiment()+ if social_sentiment:+ sentiment_signals["social_media"] = social_sentiment++ # Analyze analyst sentiment+ analyst_sentiment = await self._analyze_analyst_sentiment()+ if analyst_sentiment:+ sentiment_signals["analyst"] = analyst_sentiment++ # Analyze market-based sentiment indicators+ market_sentiment = await self._analyze_market_indicators()+ if market_sentiment:+ sentiment_signals["market_indicators"] = market_sentiment++ return sentiment_signals++ except Exception as e:+ logging.error(f"Error in market sentiment analysis: {e}")+ return {"error": self._default_sentiment_signal()}++ async def _analyze_news_sentiment(self) -> Optional[SentimentSignal]:+ """Analyze sentiment from financial news"""+ try:+ # Fetch financial news+ news_data = await self.data_manager.get_multi_source_data({+ "news": {+ "query": "stock market economy investment",+ "sources": list(self.sentiment_sources["financial_news"].keys()),+ "hours_back": 24+ }+ })++ news_articles = news_data.get("news", [])+ if not news_articles:+ return None++ # Analyze sentiment for each article+ sentiment_scores = []+ source_weights = []+ asset_mentions = defaultdict(int)++ for article in news_articles:+ # Get sentiment score+ sentiment_score = self._calculate_text_sentiment(article.value)++ # Get source weight+ source_name = article.source.lower()+ source_weight = self.sentiment_sources["financial_news"].get(source_name, 0.05)++ sentiment_scores.append(sentiment_score * article.confidence)+ source_weights.append(source_weight)++ # Count asset mentions+ self._count_asset_mentions(article.value, asset_mentions)++ # Calculate weighted average sentiment+ if sentiment_scores and source_weights:+ weighted_sentiment = np.average(sentiment_scores, weights=source_weights)++ # Calculate intensity (standard deviation of sentiment)+ intensity = min(np.std(sentiment_scores), 1.0)++ # Determine trend+ trend = self._determine_sentiment_trend(sentiment_scores)++ # Check for contrarian signal+ contrarian_signal = abs(weighted_sentiment) > self.contrarian_thresholds["extreme_bullish"]++ # Get most mentioned assets+ top_assets = [asset for asset, count in+ Counter(asset_mentions).most_common(3)]++ return SentimentSignal(+ source="financial_news",+ sentiment_score=weighted_sentiment,+ intensity=intensity,+ reliability=np.mean(source_weights),+ trend=trend,+ contrarian_signal=contrarian_signal,+ affected_assets=top_assets,+ time_horizon="short"+ )++ except Exception as e:+ logging.error(f"Error in news sentiment analysis: {e}")++ return None++ async def _analyze_social_sentiment(self) -> Optional[SentimentSignal]:+ """Analyze sentiment from social media sources"""+ try:+ # Fetch social media sentiment data+ social_data = await self.data_manager.get_multi_source_data({+ "sentiment": {+ "subreddits": ["investing", "stocks", "SecurityAnalysis", "ValueInvesting"],+ "keywords": ["market", "stocks", "bull", "bear", "crash", "rally"]+ }+ })++ sentiment_data = social_data.get("sentiment", [])+ if not sentiment_data:+ return None++ # Process social sentiment+ sentiment_scores = []+ platform_weights = []++ for data_point in sentiment_data:+ platform = data_point.metadata.get("subreddit", "unknown")+ platform_weight = self._get_social_platform_weight(platform)++ sentiment_scores.append(data_point.value)+ platform_weights.append(platform_weight)++ if sentiment_scores:+ # Calculate weighted sentiment+ weighted_sentiment = np.average(sentiment_scores, weights=platform_weights)+ intensity = min(np.std(sentiment_scores), 1.0)++ # Social media tends to be more extreme and contrarian+ contrarian_signal = (abs(weighted_sentiment) > 0.6 or+ self._detect_social_extremes(sentiment_data))++ return SentimentSignal(+ source="social_media",+ sentiment_score=weighted_sentiment,+ intensity=intensity,+ reliability=0.6, # Lower reliability than news+ trend=self._determine_sentiment_trend(sentiment_scores),+ contrarian_signal=contrarian_signal,+ affected_assets=["stocks", "crypto"], # Social media focus+ time_horizon="very_short"+ )++ except Exception as e:+ logging.error(f"Error in social sentiment analysis: {e}")++ return None++ async def _analyze_analyst_sentiment(self) -> Optional[SentimentSignal]:+ """Analyze professional analyst sentiment"""+ try:+ # This would integrate with analyst data providers+ # For now, we'll simulate based on market data patterns++ # Simulate analyst sentiment based on recent market performance+ sentiment_score = np.random.normal(0.1, 0.3) # Slight bullish bias+ sentiment_score = np.clip(sentiment_score, -1, 1)++ # Analysts tend to be less extreme+ intensity = np.random.uniform(0.2, 0.6)++ # Professional analysts rarely give contrarian signals+ contrarian_signal = False++ return SentimentSignal(+ source="analyst_sentiment",+ sentiment_score=sentiment_score,+ intensity=intensity,+ reliability=0.8, # High reliability+ trend="stable",+ contrarian_signal=contrarian_signal,+ affected_assets=["stocks", "sectors"],+ time_horizon="medium"+ )++ except Exception as e:+ logging.error(f"Error in analyst sentiment analysis: {e}")++ return None++ async def _analyze_market_indicators(self) -> Optional[SentimentSignal]:+ """Analyze market-based sentiment indicators"""+ try:+ # Fetch market sentiment indicators+ economic_data = await self.data_manager.get_multi_source_data({+ "economic": {+ "VIXCLS": {"series_id": "VIXCLS", "limit": 30}, # VIX+ "GS10": {"series_id": "GS10", "limit": 30} # 10Y Treasury+ }+ })++ market_data = economic_data.get("economic", {})++ # Calculate fear/greed metrics+ fear_greed = self._calculate_fear_greed_index(market_data)++ # Convert fear/greed to sentiment score+ sentiment_score = (fear_greed.overall_score - 50) / 50 # Convert 0-100 to -1 to 1++ # Market indicators are highly reliable but can be contrarian+ contrarian_signal = (fear_greed.classification in ["extreme_fear", "extreme_greed"])++ return SentimentSignal(+ source="market_indicators",+ sentiment_score=sentiment_score,+ intensity=abs(sentiment_score),+ reliability=0.9, # Very reliable+ trend=self._interpret_fear_greed_trend(fear_greed),+ contrarian_signal=contrarian_signal,+ affected_assets=["stocks", "bonds", "volatility"],+ time_horizon="short"+ )++ except Exception as e:+ logging.error(f"Error in market indicator analysis: {e}")++ return None++ def _calculate_text_sentiment(self, text: str) -> float:+ """Calculate sentiment score from text using keyword analysis and TextBlob"""+ try:+ # Use TextBlob for base sentiment+ blob = TextBlob(text)+ base_sentiment = blob.sentiment.polarity++ # Enhance with custom keyword analysis+ text_lower = text.lower()+ keyword_sentiment = 0.0+ keyword_count = 0++ for sentiment_category, config in self.sentiment_keywords.items():+ for keyword in config["keywords"]:+ if keyword in text_lower:+ keyword_sentiment += config["weight"]+ keyword_count += 1++ # Combine base sentiment with keyword sentiment+ if keyword_count > 0:+ keyword_sentiment /= keyword_count+ # Weight: 60% keyword sentiment, 40% TextBlob+ combined_sentiment = 0.6 * keyword_sentiment + 0.4 * base_sentiment+ else:+ combined_sentiment = base_sentiment++ return np.clip(combined_sentiment, -1.0, 1.0)++ except Exception:+ return 0.0++ def _count_asset_mentions(self, text: str, asset_mentions: Dict[str, int]):+ """Count mentions of different asset classes in text"""+ text_lower = text.lower()++ for asset_class, keywords in self.asset_sentiment_keywords.items():+ for keyword in keywords:+ if keyword in text_lower:+ asset_mentions[asset_class] += 1++ def _determine_sentiment_trend(self, sentiment_scores: List[float]) -> str:+ """Determine if sentiment is improving, deteriorating, or stable"""+ if len(sentiment_scores) < 3:+ return "stable"++ # Compare recent vs older sentiment+ recent_avg = np.mean(sentiment_scores[-len(sentiment_scores) // 3:])+ older_avg = np.mean(sentiment_scores[:len(sentiment_scores) // 3])++ difference = recent_avg - older_avg++ if difference > 0.1:+ return "improving"+ elif difference < -0.1:+ return "deteriorating"+ else:+ return "stable"++ def _get_social_platform_weight(self, platform: str) -> float:+ """Get weight for social media platform"""+ platform_weights = {+ "investing": 0.4,+ "stocks": 0.3,+ "SecurityAnalysis": 0.5,+ "ValueInvesting": 0.4,+ "wallstreetbets": 0.2, # High volume but lower quality+ "stocktwits": 0.3+ }++ return platform_weights.get(platform, 0.2)++ def _detect_social_extremes(self, sentiment_data: List[DataPoint]) -> bool:+ """Detect extreme sentiment in social media data"""+ if not sentiment_data:+ return False++ # Check for extreme keywords+ extreme_keywords = (self.sentiment_keywords["extremely_bullish"]["keywords"] ++ self.sentiment_keywords["extremely_bearish"]["keywords"])++ extreme_count = 0+ total_posts = len(sentiment_data)++ for data_point in sentiment_data:+ text = str(data_point.value).lower()+ if any(keyword in text for keyword in extreme_keywords):+ extreme_count += 1++ # If more than 20% of posts contain extreme language+ return (extreme_count / total_posts) > 0.2 if total_posts > 0 else False++ def _calculate_fear_greed_index(self, market_data: Dict) -> FearGreedMetrics:+ """Calculate fear & greed index from market data"""+ try:+ # Get VIX level (fear indicator)+ vix_data = market_data.get("VIXCLS", [])+ current_vix = vix_data[-1].value if vix_data else 20.0++ # Normalize VIX to 0-1 scale (inverse - high VIX = fear)+ vix_score = max(0, min(1, (50 - current_vix) / 30)) # 50 = extreme fear, 10 = greed++ # Simulate other components (in production, would fetch real data)+ put_call_ratio = np.random.uniform(0.3, 1.2) # Normal range+ put_call_score = max(0, min(1, (1.2 - put_call_ratio) / 0.9))++ # Safe haven flows (inverse bond yields indicate flight to safety)+ treasury_data = market_data.get("GS10", [])+ current_yield = treasury_data[-1].value if treasury_data else 4.0+ safe_haven_score = max(0, min(1, (current_yield - 2.0) / 4.0)) # Higher yields = less fear++ # Momentum strength (simulated)+ momentum_score = np.random.uniform(0.3, 0.8)++ # Calculate overall score (0-100)+ component_scores = [vix_score, put_call_score, safe_haven_score, momentum_score]+ overall_score = int(np.mean(component_scores) * 100)++ # Classify fear/greed level+ if overall_score >= 80:+ classification = "extreme_greed"+ elif overall_score >= 60:+ classification = "greed"+ elif overall_score >= 40:+ classification = "neutral"+ elif overall_score >= 20:+ classification = "fear"+ else:+ classification = "extreme_fear"++ return FearGreedMetrics(+ vix_level=current_vix,+ put_call_ratio=put_call_ratio,+ safe_haven_flows=1 - safe_haven_score, # Invert for intuitive reading+ momentum_strength=momentum_score,+ overall_score=overall_score,+ classification=classification+ )++ except Exception as e:+ logging.error(f"Error calculating fear/greed index: {e}")+ return FearGreedMetrics(50.0, 0.8, 0.5, 0.5, 50, "neutral")++ def _interpret_fear_greed_trend(self, fear_greed: FearGreedMetrics) -> str:+ """Interpret fear/greed trend"""+ score = fear_greed.overall_score++ if score > 70:+ return "deteriorating" # Too much greed+ elif score < 30:+ return "improving" # Oversold, likely to improve+ else:+ return "stable"++ def _default_sentiment_signal(self) -> SentimentSignal:+ """Return default sentiment signal"""+ return SentimentSignal(+ source="default",+ sentiment_score=0.0,+ intensity=0.3,+ reliability=0.3,+ trend="stable",+ contrarian_signal=False,+ affected_assets=["broad_market"],+ time_horizon="short"+ )++ async def generate_contrarian_signals(self, sentiment_signals: Dict[str, SentimentSignal]) -> List[Dict]:+ """Generate contrarian trading signals from sentiment extremes"""+ contrarian_signals = []++ for source, signal in sentiment_signals.items():+ if signal.contrarian_signal:+ # Generate contrarian signal+ contrarian_direction = "short" if signal.sentiment_score > 0 else "long"+ conviction = min(signal.intensity * signal.reliability, 1.0)++ contrarian_signals.append({+ "source": source,+ "direction": contrarian_direction,+ "conviction": conviction,+ "rationale": f"Extreme {source} sentiment: {signal.sentiment_score:.2f}",+ "affected_assets": signal.affected_assets,+ "time_horizon": signal.time_horizon,+ "sentiment_score": signal.sentiment_score+ })++ return contrarian_signals++ async def analyze_sector_sentiment(self) -> Dict[str, float]:+ """Analyze sentiment by sector"""+ sector_sentiment = {}++ # Sector-specific keywords+ sector_keywords = {+ "technology": ["tech", "software", "ai", "cloud", "semiconductor"],+ "healthcare": ["pharma", "biotech", "medical", "drug", "health"],+ "financials": ["bank", "insurance", "credit", "lending", "fintech"],+ "energy": ["oil", "gas", "renewable", "energy", "solar"],+ "consumer": ["retail", "consumer", "spending", "discretionary"]+ }++ try:+ for sector, keywords in sector_keywords.items():+ # Fetch sector-specific news+ sector_news = await self.data_manager.get_multi_source_data({+ "news": {+ "query": " OR ".join(keywords),+ "sources": ["reuters", "bloomberg"],+ "hours_back": 24+ }+ })++ news_data = sector_news.get("news", [])+ if news_data:+ sentiment_scores = [self._calculate_text_sentiment(article.value)+ for article in news_data]+ sector_sentiment[sector] = np.mean(sentiment_scores)+ else:+ sector_sentiment[sector] = 0.0++ except Exception as e:+ logging.error(f"Error in sector sentiment analysis: {e}")++ return sector_sentiment++ async def get_sentiment_report(self) -> Dict:+ """Generate comprehensive sentiment analysis report"""+ # Analyze overall market sentiment+ sentiment_signals = await self.analyze_market_sentiment()++ # Generate contrarian signals+ contrarian_signals = await self.generate_contrarian_signals(sentiment_signals)++ # Analyze sector sentiment+ sector_sentiment = await self.analyze_sector_sentiment()++ # Calculate overall sentiment score+ if sentiment_signals:+ weighted_scores = []+ weights = []++ for source, signal in sentiment_signals.items():+ if source != "error":+ weighted_scores.append(signal.sentiment_score * signal.reliability)+ weights.append(signal.reliability)++ overall_sentiment = (np.average(weighted_scores, weights=weights)+ if weighted_scores else 0.0)+ else:+ overall_sentiment = 0.0++ # Generate LLM analysis+ llm_analysis = await self._generate_sentiment_llm_analysis(+ sentiment_signals, contrarian_signals, sector_sentiment+ )++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "sentiment_analysis": {+ "overall_sentiment": overall_sentiment,+ "sentiment_classification": self._classify_sentiment(overall_sentiment),+ "source_breakdown": {+ source: {+ "score": signal.sentiment_score,+ "intensity": signal.intensity,+ "reliability": signal.reliability,+ "trend": signal.trend,+ "contrarian_signal": signal.contrarian_signal+ } for source, signal in sentiment_signals.items() if source != "error"+ }+ },+ "contrarian_signals": contrarian_signals,+ "sector_sentiment": sector_sentiment,+ "fear_greed_analysis": {+ "current_level": self._estimate_fear_greed_level(overall_sentiment),+ "interpretation": self._interpret_sentiment_level(overall_sentiment),+ "contrarian_opportunity": abs(overall_sentiment) > 0.6+ },+ "trading_implications": {+ "market_timing": self._get_market_timing_signal(overall_sentiment),+ "position_sizing": self._get_position_sizing_recommendation(sentiment_signals),+ "asset_allocation": self._get_sentiment_based_allocation(overall_sentiment),+ "risk_management": self._get_sentiment_risk_recommendations(contrarian_signals)+ },+ "llm_analysis": llm_analysis,+ "monitoring_alerts": {+ "extreme_sentiment_warning": abs(overall_sentiment) > 0.7,+ "contrarian_opportunities": len(contrarian_signals) > 0,+ "sentiment_divergence": self._detect_sentiment_divergence(sentiment_signals),+ "social_media_extreme": any(s.source == "social_media" and s.contrarian_signal+ for s in sentiment_signals.values() if hasattr(s, 'source'))+ }+ }++ def _classify_sentiment(self, sentiment_score: float) -> str:+ """Classify overall sentiment level"""+ if sentiment_score >= 0.6:+ return "very_bullish"+ elif sentiment_score >= 0.2:+ return "bullish"+ elif sentiment_score >= -0.2:+ return "neutral"+ elif sentiment_score >= -0.6:+ return "bearish"+ else:+ return "very_bearish"++ def _estimate_fear_greed_level(self, sentiment_score: float) -> int:+ """Convert sentiment score to fear/greed index (0-100)"""+ # Convert -1 to 1 range to 0-100+ fear_greed_score = int((sentiment_score + 1) * 50)+ return np.clip(fear_greed_score, 0, 100)++ def _interpret_sentiment_level(self, sentiment_score: float) -> str:+ """Interpret sentiment level for trading"""+ if sentiment_score > 0.7:+ return "Extreme optimism - consider taking profits and defensive positioning"+ elif sentiment_score > 0.4:+ return "Strong bullish sentiment - continue momentum but watch for reversals"+ elif sentiment_score > -0.4:+ return "Balanced sentiment - fundamentals likely driving markets"+ elif sentiment_score > -0.7:+ return "Pessimistic sentiment - look for oversold opportunities"+ else:+ return "Extreme pessimism - strong contrarian buying opportunity"++ def _get_market_timing_signal(self, sentiment_score: float) -> str:+ """Get market timing signal based on sentiment"""+ if sentiment_score > 0.6:+ return "reduce_risk" # Extreme optimism+ elif sentiment_score < -0.6:+ return "increase_risk" # Extreme pessimism+ elif sentiment_score > 0.3:+ return "neutral_to_bullish"+ elif sentiment_score < -0.3:+ return "neutral_to_bearish"+ else:+ return "neutral"++ def _get_position_sizing_recommendation(self, sentiment_signals: Dict[str, SentimentSignal]) -> str:+ """Get position sizing recommendation based on sentiment"""+ if not sentiment_signals:+ return "normal"++ # Count contrarian signals+ contrarian_count = sum(1 for signal in sentiment_signals.values()+ if hasattr(signal, 'contrarian_signal') and signal.contrarian_signal)++ # Check sentiment intensity+ avg_intensity = np.mean([signal.intensity for signal in sentiment_signals.values()+ if hasattr(signal, 'intensity')])++ if contrarian_count >= 2:+ return "reduce_size" # Multiple contrarian signals suggest caution+ elif avg_intensity > 0.7:+ return "reduce_size" # High intensity suggests volatility+ elif contrarian_count == 1 and avg_intensity < 0.4:+ return "increase_size" # Single contrarian opportunity with low volatility+ else:+ return "normal"++ def _get_sentiment_based_allocation(self, sentiment_score: float) -> Dict[str, str]:+ """Get asset allocation recommendation based on sentiment"""+ if sentiment_score > 0.5:+ return {+ "equities": "underweight", # Reduce risk in euphoric markets+ "bonds": "overweight",+ "cash": "overweight",+ "defensive_sectors": "overweight"+ }+ elif sentiment_score < -0.5:+ return {+ "equities": "overweight", # Increase risk in pessimistic markets+ "bonds": "underweight",+ "cash": "underweight",+ "growth_sectors": "overweight"+ }+ else:+ return {+ "equities": "neutral",+ "bonds": "neutral",+ "cash": "neutral",+ "sectors": "neutral"+ }++ def _get_sentiment_risk_recommendations(self, contrarian_signals: List[Dict]) -> List[str]:+ """Get risk management recommendations based on sentiment"""+ recommendations = []++ if len(contrarian_signals) > 0:+ recommendations.append("Monitor sentiment reversal points closely")+ recommendations.append("Consider volatility hedges")++ # Check for social media extremes+ social_extremes = [signal for signal in contrarian_signals+ if signal.get("source") == "social_media"]++ if social_extremes:+ recommendations.append("High social media sentiment risk - prepare for volatility")+ recommendations.append("Consider reducing position sizes in meme stocks")++ # Check for multiple extreme signals+ if len(contrarian_signals) >= 2:+ recommendations.append("Multiple extreme sentiment signals - consider defensive positioning")++ return recommendations or ["Normal risk management procedures"]++ def _detect_sentiment_divergence(self, sentiment_signals: Dict[str, SentimentSignal]) -> bool:+ """Detect divergence between different sentiment sources"""+ if len(sentiment_signals) < 2:+ return False++ scores = [signal.sentiment_score for signal in sentiment_signals.values()+ if hasattr(signal, 'sentiment_score')]++ if len(scores) < 2:+ return False++ # Check if sentiment scores are significantly different+ score_std = np.std(scores)+ score_range = max(scores) - min(scores)++ # Divergence if high standard deviation or wide range+ return score_std > 0.4 or score_range > 0.8++ async def _generate_sentiment_llm_analysis(self, sentiment_signals: Dict[str, SentimentSignal],+ contrarian_signals: List[Dict],+ sector_sentiment: Dict[str, float]) -> Dict:+ """Generate LLM-enhanced sentiment analysis"""+ try:+ # Prepare sentiment summary+ sentiment_summary = self._prepare_sentiment_summary(sentiment_signals)+ contrarian_summary = self._prepare_contrarian_summary(contrarian_signals)+ sector_summary = self._prepare_sector_sentiment_summary(sector_sentiment)++ prompt = f"""+ As a senior market sentiment analyst, analyze the current market psychology and provide trading guidance.++ Sentiment Analysis:+ {sentiment_summary}++ Contrarian Signals:+ {contrarian_summary}++ Sector Sentiment:+ {sector_summary}++ Please provide:+ 1. Current market psychology assessment and crowd behavior analysis+ 2. Contrarian opportunities with specific entry/exit strategies+ 3. Sentiment-based sector rotation recommendations+ 4. Risk management for sentiment-driven volatility+ 5. Timeline for potential sentiment reversals+ 6. Early warning indicators for sentiment extremes++ Format as JSON with keys: market_psychology, contrarian_opportunities, sector_rotation,+ risk_management, sentiment_timeline, early_warning_indicators+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM sentiment analysis: {e}")+ return {+ "market_psychology": "Mixed sentiment with moderate optimism",+ "contrarian_opportunities": "Monitor for extreme readings in VIX and social media",+ "sector_rotation": "Balanced approach with slight tech overweight",+ "risk_management": "Standard position sizing with volatility monitoring",+ "sentiment_timeline": "Next 2-4 weeks for potential shifts",+ "early_warning_indicators": ["VIX spikes", "Social media extremes", "News flow acceleration"]+ }++ def _prepare_sentiment_summary(self, sentiment_signals: Dict[str, SentimentSignal]) -> str:+ """Prepare sentiment summary for LLM"""+ summary_lines = []++ for source, signal in sentiment_signals.items():+ if hasattr(signal, 'sentiment_score'):+ summary_lines.append(+ f"{source}: Score {signal.sentiment_score:.2f}, "+ f"Intensity {signal.intensity:.2f}, "+ f"Trend {signal.trend}, "+ f"Contrarian: {signal.contrarian_signal}"+ )++ return "\n".join(summary_lines) if summary_lines else "Limited sentiment data available"++ def _prepare_contrarian_summary(self, contrarian_signals: List[Dict]) -> str:+ """Prepare contrarian signals summary for LLM"""+ if not contrarian_signals:+ return "No significant contrarian signals detected"++ summary_lines = []+ for signal in contrarian_signals:+ summary_lines.append(+ f"{signal['source']}: {signal['direction']} signal "+ f"(Conviction: {signal['conviction']:.2f}) - {signal['rationale']}"+ )++ return "\n".join(summary_lines)++ def _prepare_sector_sentiment_summary(self, sector_sentiment: Dict[str, float]) -> str:+ """Prepare sector sentiment summary for LLM"""+ if not sector_sentiment:+ return "Sector sentiment data not available"++ summary_lines = []+ sorted_sectors = sorted(sector_sentiment.items(), key=lambda x: x[1], reverse=True)++ for sector, sentiment in sorted_sectors:+ sentiment_desc = "Bullish" if sentiment > 0.2 else "Bearish" if sentiment < -0.2 else "Neutral"+ summary_lines.append(f"{sector}: {sentiment:.2f} ({sentiment_desc})")++ return "\n".join(summary_lines)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/supply_chain_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/supply_chain_agent.pynew file mode 100644index 000000000..b78cebc18--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/supply_chain_agent.py@@ -0,0 +1,592 @@+# -*- coding: utf-8 -*-+# agents/supply_chain_agent.py - Supply Chain Analysis Agent++import asyncio+import numpy as np+import pandas as pd+from datetime import datetime, timedelta+from typing import Dict, List, Optional, Tuple+import logging+from dataclasses import dataclass+import openai+import json++from config import CONFIG+from data_feeds import DataFeedManager, DataPoint+++@dataclass+class SupplyChainRisk:+ """Supply chain risk assessment"""+ disruption_type: str+ affected_regions: List[str]+ risk_level: int # 1-10+ affected_sectors: List[str]+ price_impact: Dict[str, float]+ duration_estimate: str+ mitigation_difficulty: str+++class SupplyChainAgent:+ """Supply chain disruption monitoring and investment impact analysis"""++ def __init__(self):+ self.name = "supply_chain"+ self.data_manager = DataFeedManager()+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)++ # Critical supply chain chokepoints+ self.chokepoints = {+ "shipping": ["Suez Canal", "Panama Canal", "Strait of Hormuz", "Strait of Malacca"],+ "semiconductors": ["Taiwan", "South Korea", "Netherlands", "Japan"],+ "rare_earths": ["China", "Australia", "Myanmar"],+ "energy": ["Russia", "Saudi Arabia", "Norway", "Qatar"],+ "agriculture": ["Ukraine", "Russia", "Brazil", "Argentina"]+ }++ # Sector impact mapping+ self.sector_impacts = {+ "shipping_disruption": {+ "retail": -0.6, "automotive": -0.8, "electronics": -0.7,+ "energy": 0.3, "logistics": -0.9, "commodities": 0.4+ },+ "semiconductor_shortage": {+ "automotive": -0.9, "electronics": -0.8, "telecommunications": -0.6,+ "industrial": -0.5, "healthcare": -0.3+ },+ "energy_supply_shock": {+ "airlines": -0.8, "chemicals": -0.7, "materials": -0.6,+ "energy": 0.8, "utilities": -0.4, "transportation": -0.7+ }+ }++ async def analyze_supply_chains(self) -> List[SupplyChainRisk]:+ """Analyze global supply chain risks"""+ risks = []++ # Shipping disruptions+ shipping_risk = await self._analyze_shipping_disruptions()+ if shipping_risk:+ risks.append(shipping_risk)++ # Semiconductor supply+ chip_risk = await self._analyze_semiconductor_supply()+ if chip_risk:+ risks.append(chip_risk)++ # Energy supply+ energy_risk = await self._analyze_energy_supply()+ if energy_risk:+ risks.append(energy_risk)++ # Critical materials+ materials_risk = await self._analyze_critical_materials()+ if materials_risk:+ risks.append(materials_risk)++ return risks++ async def _analyze_shipping_disruptions(self) -> Optional[SupplyChainRisk]:+ """Analyze global shipping and logistics disruptions"""+ try:+ # Fetch shipping-related news+ shipping_news = await self.data_manager.get_multi_source_data({+ "news": {+ "query": "shipping disruption supply chain logistics",+ "sources": ["reuters", "bloomberg"],+ "hours_back": 72+ }+ })++ news_data = shipping_news.get("news", [])++ # Calculate risk level from news intensity+ disruption_keywords = [+ "port congestion", "shipping delay", "container shortage",+ "suez canal", "panama canal", "strike", "blockage"+ ]++ risk_score = 0+ for article in news_data:+ text = article.value.lower()+ keyword_count = sum(1 for keyword in disruption_keywords if keyword in text)+ risk_score += keyword_count * article.confidence++ if news_data:+ normalized_risk = min(risk_score / len(news_data) * 2, 10)+ risk_level = int(normalized_risk) if normalized_risk > 3 else 5+ else:+ risk_level = 4 # Baseline moderate risk++ # Determine affected regions and sectors+ affected_regions = ["Global", "Asia-Pacific", "Europe", "North America"]+ affected_sectors = ["retail", "automotive", "electronics", "consumer goods"]++ # Price impacts+ price_impacts = {+ "shipping_costs": 0.2 * (risk_level / 10),+ "commodity_prices": 0.15 * (risk_level / 10),+ "consumer_goods": 0.1 * (risk_level / 10)+ }++ return SupplyChainRisk(+ disruption_type="shipping_logistics",+ affected_regions=affected_regions,+ risk_level=risk_level,+ affected_sectors=affected_sectors,+ price_impact=price_impacts,+ duration_estimate="3-9 months" if risk_level > 6 else "1-6 months",+ mitigation_difficulty="moderate"+ )++ except Exception as e:+ logging.error(f"Error analyzing shipping disruptions: {e}")+ return None++ async def _analyze_semiconductor_supply(self) -> Optional[SupplyChainRisk]:+ """Analyze semiconductor supply chain risks"""+ try:+ # Fetch semiconductor news+ chip_news = await self.data_manager.get_multi_source_data({+ "news": {+ "query": "semiconductor chip shortage taiwan TSMC",+ "sources": ["reuters", "bloomberg"],+ "hours_back": 168 # 1 week+ }+ })++ news_data = chip_news.get("news", [])++ # Semiconductor risk factors+ risk_keywords = [+ "chip shortage", "semiconductor", "taiwan tensions", "TSMC",+ "fabrication", "wafer", "supply constraint"+ ]++ geopolitical_keywords = [+ "taiwan strait", "china taiwan", "semiconductor sanctions",+ "export controls", "technology war"+ ]++ supply_risk = 0+ geopolitical_risk = 0++ for article in news_data:+ text = article.value.lower()+ supply_risk += sum(1 for keyword in risk_keywords if keyword in text)+ geopolitical_risk += sum(1 for keyword in geopolitical_keywords if keyword in text)++ # Combine risks+ total_articles = len(news_data) if news_data else 1+ combined_risk = (supply_risk + geopolitical_risk * 2) / total_articles+ risk_level = min(int(combined_risk * 1.5) + 4, 10) # Base 4, scale up++ affected_regions = ["Global", "Taiwan", "South Korea", "Japan"]+ affected_sectors = ["automotive", "electronics", "telecommunications", "industrial"]++ price_impacts = {+ "semiconductor_prices": 0.3 * (risk_level / 10),+ "electronics": 0.2 * (risk_level / 10),+ "automotive": 0.25 * (risk_level / 10)+ }++ return SupplyChainRisk(+ disruption_type="semiconductor_shortage",+ affected_regions=affected_regions,+ risk_level=risk_level,+ affected_sectors=affected_sectors,+ price_impact=price_impacts,+ duration_estimate="12-24 months" if risk_level > 7 else "6-18 months",+ mitigation_difficulty="high" # Long lead times for new fabs+ )++ except Exception as e:+ logging.error(f"Error analyzing semiconductor supply: {e}")+ return None++ async def _analyze_energy_supply(self) -> Optional[SupplyChainRisk]:+ """Analyze energy supply chain risks"""+ try:+ # Fetch energy supply news+ energy_news = await self.data_manager.get_multi_source_data({+ "news": {+ "query": "energy supply oil gas pipeline russia ukraine",+ "sources": ["reuters", "bloomberg"],+ "hours_back": 96+ }+ })++ news_data = energy_news.get("news", [])++ # Energy supply risk indicators+ supply_risk_keywords = [+ "pipeline", "refinery shutdown", "oil supply", "gas supply",+ "energy crisis", "power shortage", "fuel shortage"+ ]++ geopolitical_keywords = [+ "russia sanctions", "opec", "energy weapon", "gas cutoff",+ "strategic reserve", "energy security"+ ]++ supply_disruption_score = 0+ geopolitical_score = 0++ for article in news_data:+ text = article.value.lower()+ supply_disruption_score += sum(1 for keyword in supply_risk_keywords if keyword in text)+ geopolitical_score += sum(1 for keyword in geopolitical_keywords if keyword in text)++ total_articles = len(news_data) if news_data else 1+ combined_score = (supply_disruption_score + geopolitical_score * 1.5) / total_articles+ risk_level = min(int(combined_score * 1.2) + 3, 10)++ affected_regions = ["Europe", "Asia", "Global"]+ affected_sectors = ["energy", "chemicals", "transportation", "utilities", "airlines"]++ price_impacts = {+ "oil_prices": 0.4 * (risk_level / 10),+ "gas_prices": 0.5 * (risk_level / 10),+ "electricity": 0.3 * (risk_level / 10),+ "petrochemicals": 0.25 * (risk_level / 10)+ }++ return SupplyChainRisk(+ disruption_type="energy_supply_shock",+ affected_regions=affected_regions,+ risk_level=risk_level,+ affected_sectors=affected_sectors,+ price_impact=price_impacts,+ duration_estimate="6-18 months" if risk_level > 6 else "3-12 months",+ mitigation_difficulty="moderate"+ )++ except Exception as e:+ logging.error(f"Error analyzing energy supply: {e}")+ return None++ async def _analyze_critical_materials(self) -> Optional[SupplyChainRisk]:+ """Analyze critical materials and rare earth supply"""+ try:+ # Fetch critical materials news+ materials_news = await self.data_manager.get_multi_source_data({+ "news": {+ "query": "rare earth metals lithium copper critical minerals",+ "sources": ["reuters", "bloomberg"],+ "hours_back": 120+ }+ })++ news_data = materials_news.get("news", [])++ # Critical materials risk factors+ supply_keywords = [+ "rare earth", "lithium shortage", "copper supply", "nickel",+ "cobalt", "critical minerals", "mining disruption"+ ]++ geopolitical_keywords = [+ "china rare earth", "mining sanctions", "export restrictions",+ "strategic materials", "supply security"+ ]++ supply_risk = 0+ geo_risk = 0++ for article in news_data:+ text = article.value.lower()+ supply_risk += sum(1 for keyword in supply_keywords if keyword in text)+ geo_risk += sum(1 for keyword in geopolitical_keywords if keyword in text)++ total_articles = len(news_data) if news_data else 1+ combined_risk = (supply_risk + geo_risk * 1.3) / total_articles+ risk_level = min(int(combined_risk * 1.1) + 4, 10)++ affected_regions = ["Global", "China", "Australia", "DRC"]+ affected_sectors = ["renewable_energy", "electric_vehicles", "electronics", "defense"]++ price_impacts = {+ "rare_earth_prices": 0.6 * (risk_level / 10),+ "battery_metals": 0.4 * (risk_level / 10),+ "renewable_energy_costs": 0.2 * (risk_level / 10)+ }++ return SupplyChainRisk(+ disruption_type="critical_materials_shortage",+ affected_regions=affected_regions,+ risk_level=risk_level,+ affected_sectors=affected_sectors,+ price_impact=price_impacts,+ duration_estimate="12-36 months" if risk_level > 7 else "6-24 months",+ mitigation_difficulty="high" # Limited alternative sources+ )++ except Exception as e:+ logging.error(f"Error analyzing critical materials: {e}")+ return None++ async def get_supply_chain_report(self) -> Dict:+ """Generate comprehensive supply chain risk report"""+ # Analyze supply chain risks+ supply_risks = await self.analyze_supply_chains()++ # Calculate overall supply chain stress+ overall_stress = self._calculate_supply_chain_stress(supply_risks)++ # Generate investment implications+ investment_implications = self._generate_investment_implications(supply_risks)++ # Generate LLM analysis+ llm_analysis = await self._generate_supply_chain_llm_analysis(supply_risks)++ return {+ "timestamp": datetime.now().isoformat(),+ "agent": self.name,+ "supply_chain_analysis": {+ "overall_stress_level": overall_stress,+ "stress_classification": self._classify_stress_level(overall_stress),+ "major_risks": [{+ "disruption_type": risk.disruption_type,+ "risk_level": risk.risk_level,+ "affected_regions": risk.affected_regions,+ "affected_sectors": risk.affected_sectors,+ "price_impact": risk.price_impact,+ "duration": risk.duration_estimate,+ "mitigation_difficulty": risk.mitigation_difficulty+ } for risk in supply_risks]+ },+ "investment_implications": investment_implications,+ "sector_impact_analysis": self._analyze_sector_impacts(supply_risks),+ "geographic_exposure": self._analyze_geographic_exposure(supply_risks),+ "llm_analysis": llm_analysis,+ "monitoring_priorities": {+ "high_risk_disruptions": [risk.disruption_type for risk in supply_risks if risk.risk_level >= 7],+ "critical_chokepoints": self._identify_critical_chokepoints(supply_risks),+ "early_warning_indicators": [+ "Shipping container rates", "Semiconductor lead times",+ "Energy price volatility", "Critical mineral inventories"+ ]+ }+ }++ def _calculate_supply_chain_stress(self, risks: List[SupplyChainRisk]) -> float:+ """Calculate overall supply chain stress level"""+ if not risks:+ return 3.0 # Baseline stress++ # Weight risks by severity and mitigation difficulty+ weighted_stress = 0+ total_weight = 0++ difficulty_multipliers = {"low": 0.8, "moderate": 1.0, "high": 1.3}++ for risk in risks:+ multiplier = difficulty_multipliers.get(risk.mitigation_difficulty, 1.0)+ weight = risk.risk_level * multiplier+ weighted_stress += weight+ total_weight += 1++ return weighted_stress / total_weight if total_weight > 0 else 3.0++ def _classify_stress_level(self, stress_level: float) -> str:+ """Classify supply chain stress level"""+ if stress_level >= 8:+ return "critical"+ elif stress_level >= 6:+ return "high"+ elif stress_level >= 4:+ return "moderate"+ else:+ return "low"++ def _generate_investment_implications(self, risks: List[SupplyChainRisk]) -> Dict:+ """Generate investment implications from supply chain risks"""+ implications = {+ "beneficiary_sectors": [],+ "vulnerable_sectors": [],+ "geographic_allocation": {},+ "commodity_exposure": {},+ "hedging_strategies": []+ }++ # Aggregate sector impacts+ sector_impact_totals = {}++ for risk in risks:+ # Get sector impacts for this disruption type+ if risk.disruption_type in self.sector_impacts:+ sector_impacts = self.sector_impacts[risk.disruption_type]+ for sector, impact in sector_impacts.items():+ sector_impact_totals[sector] = sector_impact_totals.get(sector, 0) + impact * (risk.risk_level / 10)++ # Classify sectors+ for sector, total_impact in sector_impact_totals.items():+ if total_impact > 0.2:+ implications["beneficiary_sectors"].append(sector)+ elif total_impact < -0.2:+ implications["vulnerable_sectors"].append(sector)++ # Geographic allocation+ high_risk_regions = set()+ for risk in risks:+ if risk.risk_level >= 6:+ high_risk_regions.update(risk.affected_regions)++ implications["geographic_allocation"] = {+ "avoid": list(high_risk_regions),+ "prefer": ["North America", "Australia"] if "Asia" in high_risk_regions else ["Domestic markets"]+ }++ # Commodity exposure+ for risk in risks:+ for commodity, impact in risk.price_impact.items():+ if impact > 0.1:+ implications["commodity_exposure"][commodity] = "positive" if impact > 0 else "negative"++ # Hedging strategies+ if any(risk.risk_level >= 7 for risk in risks):+ implications["hedging_strategies"].extend([+ "Commodity price hedging",+ "Supply chain diversification",+ "Inventory buffers"+ ])++ return implications++ def _analyze_sector_impacts(self, risks: List[SupplyChainRisk]) -> Dict[str, Dict]:+ """Analyze impact on different sectors"""+ sector_analysis = {}++ # Aggregate all affected sectors+ all_sectors = set()+ for risk in risks:+ all_sectors.update(risk.affected_sectors)++ for sector in all_sectors:+ sector_risks = [risk for risk in risks if sector in risk.affected_sectors]++ if sector_risks:+ avg_risk_level = np.mean([risk.risk_level for risk in sector_risks])+ max_risk_level = max(risk.risk_level for risk in sector_risks)++ sector_analysis[sector] = {+ "average_risk_level": avg_risk_level,+ "maximum_risk_level": max_risk_level,+ "number_of_risks": len(sector_risks),+ "primary_risks": [risk.disruption_type for risk in sector_risks[:3]],+ "investment_recommendation": self._get_sector_recommendation(avg_risk_level)+ }++ return sector_analysis++ def _get_sector_recommendation(self, risk_level: float) -> str:+ """Get investment recommendation based on sector risk level"""+ if risk_level >= 7:+ return "avoid"+ elif risk_level >= 5:+ return "underweight"+ elif risk_level >= 3:+ return "neutral"+ else:+ return "overweight"++ def _analyze_geographic_exposure(self, risks: List[SupplyChainRisk]) -> Dict[str, Dict]:+ """Analyze geographic exposure to supply chain risks"""+ geographic_analysis = {}++ # Aggregate all affected regions+ all_regions = set()+ for risk in risks:+ all_regions.update(risk.affected_regions)++ for region in all_regions:+ region_risks = [risk for risk in risks if region in risk.affected_regions]++ if region_risks:+ avg_risk = np.mean([risk.risk_level for risk in region_risks])++ geographic_analysis[region] = {+ "average_risk_level": avg_risk,+ "number_of_risks": len(region_risks),+ "primary_disruption_types": list(set(risk.disruption_type for risk in region_risks)),+ "investment_stance": "defensive" if avg_risk >= 6 else "neutral" if avg_risk >= 4 else "opportunistic"+ }++ return geographic_analysis++ def _identify_critical_chokepoints(self, risks: List[SupplyChainRisk]) -> List[str]:+ """Identify critical supply chain chokepoints"""+ critical_points = []++ for risk in risks:+ if risk.risk_level >= 6 and risk.mitigation_difficulty == "high":+ # These are critical chokepoints+ if risk.disruption_type == "semiconductor_shortage":+ critical_points.extend(["Taiwan semiconductor fabs", "ASML lithography"])+ elif risk.disruption_type == "shipping_logistics":+ critical_points.extend(["Suez Canal", "Panama Canal", "Shanghai ports"])+ elif risk.disruption_type == "energy_supply_shock":+ critical_points.extend(["Russian pipelines", "Strait of Hormuz"])+ elif risk.disruption_type == "critical_materials_shortage":+ critical_points.extend(["China rare earth production", "DRC cobalt mines"])++ return list(set(critical_points)) # Remove duplicates++ async def _generate_supply_chain_llm_analysis(self, risks: List[SupplyChainRisk]) -> Dict:+ """Generate LLM-enhanced supply chain analysis"""+ try:+ # Prepare risk summary+ risk_summary = self._prepare_risk_summary(risks)++ prompt = f"""+ As a senior supply chain risk analyst, analyze current global supply chain disruptions and provide investment guidance.++ Current Supply Chain Risks:+ {risk_summary}++ Please provide:+ 1. Most critical supply chain vulnerabilities requiring immediate attention+ 2. Investment opportunities arising from supply chain disruptions+ 3. Sector rotation strategy based on supply chain resilience+ 4. Geographic diversification recommendations+ 5. Timeline for supply chain normalization+ 6. Early warning indicators for supply chain crises++ Format as JSON with keys: critical_vulnerabilities, investment_opportunities, sector_strategy,+ geographic_diversification, normalization_timeline, early_warning_indicators+ """++ response = self.client.chat.completions.create(+ model=CONFIG.llm.deep_think_model,+ messages=[{"role": "user", "content": prompt}],+ temperature=CONFIG.llm.temperature,+ max_tokens=CONFIG.llm.max_tokens+ )++ return json.loads(response.choices[0].message.content)++ except Exception as e:+ logging.error(f"Error in LLM supply chain analysis: {e}")+ return {+ "critical_vulnerabilities": ["Semiconductor supply", "Energy security", "Shipping bottlenecks"],+ "investment_opportunities": ["Supply chain technology", "Regional suppliers", "Inventory management"],+ "sector_strategy": "Overweight supply chain resilient sectors, underweight vulnerable ones",+ "geographic_diversification": "Reduce Asia concentration, increase nearshoring exposure",+ "normalization_timeline": "18-36 months for full normalization",+ "early_warning_indicators": ["Container shipping rates", "Commodity inventories", "Trade flow data"]+ }++ def _prepare_risk_summary(self, risks: List[SupplyChainRisk]) -> str:+ """Prepare risk summary for LLM analysis"""+ summary_lines = []++ for risk in risks:+ summary_lines.append(+ f"{risk.disruption_type}: Risk Level {risk.risk_level}/10, "+ f"Regions: {', '.join(risk.affected_regions[:3])}, "+ f"Duration: {risk.duration_estimate}, "+ f"Sectors: {', '.join(risk.affected_sectors[:3])}, "+ f"Mitigation: {risk.mitigation_difficulty}"+ )++ return "\n".join(summary_lines) if summary_lines else "No major supply chain risks identified"\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/history.jsonl b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/history.jsonlnew file mode 100644index 000000000..3b289ea6c--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/history.jsonl@@ -0,0 +1,19 @@+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760621427926,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760622414199,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"[Pasted text #1 +28 lines]","pastedContents":{},"timestamp":1760624273948,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760707613869,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760707816773,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"[Pasted text #1 +162 lines]","pastedContents":{},"timestamp":1760709574303,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760729181388,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760729216541,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"[Pasted text #1 +139 lines]","pastedContents":{},"timestamp":1760731722210,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760766955381,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760766969289,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"[Pasted text #1 +14 lines]","pastedContents":{"1":{"id":1,"type":"text","content":"Of course, here is the API documentation for the Spanish government's data portal.\n\n### **Overview**\n\nThe API allows for queries to be made to the `datos.gob.es` semantic database, providing access to the data catalog and related resources. The API uses Uniform Resource Identifiers (URIs) for queries, which are constructed based on user-selected criteria.\n\n### **Key Features**\n\n* **Access to Data Catalog**: The API provides programmatic access to the data catalog.\n* **Access to URIs**: It also provides access to URIs corresponding to the primary sector taxonomy.\n* **Geographical Coverage Identification**: The API allows for the identification of geographical coverage as defined in Annexes IV and V of the Technical Interoperability Regulations on the Re-use of Information Resources (NTI).\n\n### **Additional Resources**\n\nYou can find more detailed information, including documents relating to the API methods, parameters, and model, as well as the ability to conduct test searches, on the `datos.gob.es` website."}},"timestamp":1760768424326,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760791875832,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760792158009,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"[Pasted text #1 +140 lines]","pastedContents":{},"timestamp":1760792235672,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"add english translators for spanish text","pastedContents":{},"timestamp":1760793023651,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760882925391,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760883120208,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}+{"display":"[Pasted text #1 +124 lines]","pastedContents":{},"timestamp":1760883596081,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/pershing_square_hedge_fund_agent/pershing_square_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/pershing_square_hedge_fund_agent/pershing_square_agent.pynew file mode 100644index 000000000..33eb31333--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/pershing_square_hedge_fund_agent/pershing_square_agent.py@@ -0,0 +1,985 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class PershingSquareSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ investment_thesis: dict+++def pershing_square_hedge_fund_agent(state: AgentState, agent_id: str = "pershing_square_hedge_fund_agent"):+ """+ Pershing Square: Concentrated activist investing, high-conviction bets+ Structure: Research → Activism Strategy → Public Relations → Risk Management → Bill Ackman Decision+ Philosophy: Concentrated positions, activist value creation, public campaigns+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ pershing_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Research team fundamental analysis")++ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=8, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "research_and_development"+ ],+ end_date,+ period="annual",+ limit=8,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Pershing Square's concentrated analysis structure+ progress.update_status(agent_id, ticker, "Research team analysis")+ research_team = pershing_research_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Activism strategy team")+ activism_strategy = activism_strategy_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Public relations strategy")+ public_relations = public_relations_strategy_analysis(financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk management analysis")+ risk_management = pershing_risk_management_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Bill Ackman investment decision")+ ackman_decision = bill_ackman_investment_decision(+ research_team, activism_strategy, public_relations, risk_management+ )++ # Pershing Square's high-conviction scoring+ total_score = (+ research_team["score"] * 0.35 ++ activism_strategy["score"] * 0.3 ++ risk_management["score"] * 0.2 ++ public_relations["score"] * 0.15+ )++ # Pershing Square's concentrated decision framework+ conviction_level = ackman_decision.get("conviction_level", 0)+ if total_score >= 8.5 and conviction_level > 0.8:+ signal = "bullish"+ elif total_score <= 4.0 or conviction_level < 0.3:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "research_team": research_team,+ "activism_strategy": activism_strategy,+ "public_relations": public_relations,+ "risk_management": risk_management,+ "ackman_decision": ackman_decision+ }++ pershing_output = generate_pershing_output(ticker, analysis_data, state, agent_id)++ pershing_analysis[ticker] = {+ "signal": pershing_output.signal,+ "confidence": pershing_output.confidence,+ "reasoning": pershing_output.reasoning,+ "investment_thesis": pershing_output.investment_thesis+ }++ progress.update_status(agent_id, ticker, "Done", analysis=pershing_output.reasoning)++ message = HumanMessage(content=json.dumps(pershing_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(pershing_analysis, "Pershing Square")++ state["data"]["analyst_signals"][agent_id] = pershing_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def pershing_research_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Pershing Square's research team deep fundamental analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No research data"}++ # High-quality business analysis+ business_quality = analyze_business_quality_metrics(metrics, financial_line_items)+ if business_quality > 0.8:+ score += 3+ details.append(f"Exceptional business quality: {business_quality:.2f}")+ elif business_quality > 0.6:+ score += 2+ details.append(f"High business quality: {business_quality:.2f}")++ # Competitive moat analysis+ moat_strength = analyze_competitive_moat_strength(metrics, financial_line_items)+ if moat_strength > 0.7:+ score += 3+ details.append(f"Strong competitive moat: {moat_strength:.2f}")++ # Management quality assessment+ management_quality = assess_management_quality(metrics, financial_line_items)+ if management_quality > 0.7:+ score += 2+ details.append(f"High-quality management: {management_quality:.2f}")+ elif management_quality < 0.4:+ score += 1.5 # Opportunity for improvement through activism+ details.append("Management improvement opportunity")++ # Intrinsic value vs market price+ intrinsic_value_ratio = calculate_intrinsic_value_ratio(financial_line_items, market_cap)+ if intrinsic_value_ratio > 1.5:+ score += 2.5+ details.append(f"Significant undervaluation: {intrinsic_value_ratio:.1f}x intrinsic value")+ elif intrinsic_value_ratio > 1.2:+ score += 1.5+ details.append(f"Moderate undervaluation: {intrinsic_value_ratio:.1f}x intrinsic value")++ # Long-term growth potential+ growth_potential = analyze_long_term_growth_potential(financial_line_items)+ if growth_potential > 0.6:+ score += 1.5+ details.append(f"Strong long-term growth potential: {growth_potential:.2f}")++ return {"score": score, "details": "; ".join(details)}+++def activism_strategy_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Pershing Square's activism strategy team analysis"""+ score = 0+ details = []+ activist_opportunities = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No activism data"}++ # Board and governance opportunities+ governance_opportunity = assess_governance_improvement_opportunities(metrics, financial_line_items)+ if governance_opportunity > 0.7:+ score += 3+ activist_opportunities.append("Board restructuring")+ details.append("Significant governance improvement opportunity")++ # Strategic restructuring potential+ restructuring_potential = identify_strategic_restructuring_opportunities(financial_line_items, market_cap)+ if restructuring_potential > 0.6:+ score += 2.5+ activist_opportunities.append("Strategic restructuring")+ details.append("Strategic restructuring opportunity identified")++ # Capital allocation improvements+ capital_allocation_score = analyze_capital_allocation_opportunities(financial_line_items)+ if capital_allocation_score > 0.6:+ score += 2+ activist_opportunities.append("Capital allocation")+ details.append("Capital allocation improvement opportunity")++ # Operational efficiency improvements+ operational_efficiency = identify_operational_efficiency_opportunities(financial_line_items)+ if operational_efficiency > 0.5:+ score += 1.5+ activist_opportunities.append("Operational improvements")+ details.append("Operational efficiency opportunities")++ # ESG and sustainability improvements+ esg_opportunities = assess_esg_improvement_opportunities(financial_line_items)+ if esg_opportunities > 0.5:+ score += 1+ activist_opportunities.append("ESG improvements")+ details.append("ESG improvement opportunities")++ # Public campaign viability+ public_campaign_viability = assess_public_campaign_viability(market_cap)+ if public_campaign_viability > 0.7:+ score += 1+ details.append("High public campaign viability")++ return {+ "score": score,+ "details": "; ".join(details),+ "activist_opportunities": activist_opportunities+ }+++def public_relations_strategy_analysis(financial_line_items: list, market_cap: float) -> dict:+ """Pershing Square's public relations strategy analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No PR data"}++ # Public narrative strength+ narrative_strength = assess_public_narrative_strength(financial_line_items)+ if narrative_strength > 0.7:+ score += 2+ details.append("Strong public narrative potential")++ # Media coverage potential+ media_coverage_potential = analyze_media_coverage_potential(market_cap)+ if media_coverage_potential > 0.6:+ score += 1.5+ details.append("High media coverage potential")++ # Shareholder communication effectiveness+ shareholder_communication = assess_shareholder_communication_potential(market_cap)+ score += shareholder_communication+ details.append(f"Shareholder communication score: {shareholder_communication:.1f}")++ # Public pressure effectiveness+ public_pressure_effectiveness = evaluate_public_pressure_effectiveness(financial_line_items)+ if public_pressure_effectiveness > 0.6:+ score += 1.5+ details.append("Public pressure likely to be effective")++ # Regulatory and political considerations+ regulatory_considerations = analyze_regulatory_environment(financial_line_items)+ if regulatory_considerations > 0.5:+ score += 1+ details.append("Favorable regulatory environment")++ return {"score": score, "details": "; ".join(details)}+++def pershing_risk_management_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Pershing Square's risk management for concentrated positions"""+ score = 0+ details = []+ risk_factors = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No risk data"}++ # Concentration risk assessment+ concentration_risk = assess_concentration_risk(market_cap)+ if concentration_risk < 0.3:+ score += 2+ details.append("Low concentration risk")+ elif concentration_risk > 0.7:+ risk_factors.append("High concentration risk")+ details.append("High concentration risk identified")++ # Liquidity risk for large positions+ liquidity_risk = assess_large_position_liquidity_risk(market_cap)+ if liquidity_risk < 0.2:+ score += 2+ details.append("Low liquidity risk for large positions")+ elif liquidity_risk > 0.6:+ risk_factors.append("Liquidity constraints")++ # Activist campaign risks+ campaign_risk = assess_activist_campaign_risks(financial_line_items)+ if campaign_risk < 0.4:+ score += 1.5+ details.append("Low activist campaign risk")+ elif campaign_risk > 0.7:+ risk_factors.append("High campaign execution risk")++ # Regulatory and legal risks+ regulatory_risk = assess_regulatory_and_legal_risks(market_cap)+ if regulatory_risk < 0.3:+ score += 1.5+ details.append("Low regulatory risk")+ elif regulatory_risk > 0.6:+ risk_factors.append("Regulatory concerns")++ # Reputational risk+ reputational_risk = assess_reputational_risk_exposure(financial_line_items)+ if reputational_risk < 0.4:+ score += 1+ details.append("Low reputational risk")+ elif reputational_risk > 0.7:+ risk_factors.append("Reputational risk exposure")++ # Downside protection analysis+ downside_protection = calculate_downside_protection(financial_line_items, market_cap)+ if downside_protection > 0.6:+ score += 2+ details.append("Strong downside protection")++ if risk_factors:+ details.append(f"Risk factors: {'; '.join(risk_factors)}")++ return {+ "score": score,+ "details": "; ".join(details),+ "risk_factors": risk_factors+ }+++def bill_ackman_investment_decision(research_team: dict, activism_strategy: dict,+ public_relations: dict, risk_management: dict) -> dict:+ """Bill Ackman's high-conviction investment decision"""+ details = []++ # Ackman's decision framework+ fundamental_strength = research_team["score"] / 10+ activist_potential = activism_strategy["score"] / 10+ campaign_feasibility = public_relations["score"] / 8+ risk_acceptability = risk_management["score"] / 10++ # High-conviction threshold+ overall_conviction = (+ fundamental_strength * 0.4 ++ activist_potential * 0.35 ++ campaign_feasibility * 0.15 ++ risk_acceptability * 0.1+ )++ # Position sizing decision+ if overall_conviction > 0.85:+ position_size = "Large concentrated position (15-25%)"+ conviction_level = 0.9+ details.append("Exceptional opportunity warranting large concentrated position")+ elif overall_conviction > 0.7:+ position_size = "Significant position (8-15%)"+ conviction_level = 0.75+ details.append("High-conviction opportunity with strong activist potential")+ elif overall_conviction > 0.55:+ position_size = "Moderate position (3-8%)"+ conviction_level = 0.6+ details.append("Decent opportunity but below Pershing Square's typical standards")+ else:+ position_size = "Pass - insufficient conviction"+ conviction_level = 0.3+ details.append("Does not meet Pershing Square's high-conviction threshold")++ # Timeline estimation+ activist_opportunities = activism_strategy.get("activist_opportunities", [])+ if "Board restructuring" in activist_opportunities:+ expected_timeline = "18-36 months"+ elif "Strategic restructuring" in activist_opportunities:+ expected_timeline = "24-48 months"+ elif "Capital allocation" in activist_opportunities:+ expected_timeline = "12-24 months"+ else:+ expected_timeline = "6-18 months"++ # Expected returns+ if conviction_level > 0.8:+ expected_return_range = "25-50% annualized"+ elif conviction_level > 0.6:+ expected_return_range = "15-25% annualized"+ else:+ expected_return_range = "5-15% annualized"++ return {+ "position_size": position_size,+ "conviction_level": conviction_level,+ "expected_timeline": expected_timeline,+ "expected_return_range": expected_return_range,+ "overall_conviction": overall_conviction,+ "details": "; ".join(details)+ }+++# Helper functions for Pershing Square analysis+def analyze_business_quality_metrics(metrics: list, financial_line_items: list) -> float:+ """Analyze business quality metrics"""+ if not metrics:+ return 0.5++ quality_score = 0+ components = 0++ # Return on equity consistency+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if roe_vals:+ avg_roe = sum(roe_vals) / len(roe_vals)+ high_roe_years = sum(1 for roe in roe_vals if roe > 0.15)+ roe_consistency = high_roe_years / len(roe_vals)++ quality_score += min(avg_roe / 0.2, 1.0) * 0.5 + roe_consistency * 0.5+ components += 1++ # Free cash flow generation+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ if fcf_vals:+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)+ fcf_consistency = positive_fcf_years / len(fcf_vals)+ quality_score += fcf_consistency+ components += 1++ # Revenue growth consistency+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])+ growth_consistency = growth_years / (len(revenues) - 1)+ quality_score += growth_consistency+ components += 1++ return quality_score / components if components > 0 else 0.5+++def analyze_competitive_moat_strength(metrics: list, financial_line_items: list) -> float:+ """Analyze competitive moat strength"""+ if not metrics or not financial_line_items:+ return 0.5++ moat_indicators = 0+ total_indicators = 0++ # High and stable margins+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins:+ avg_margin = sum(margins) / len(margins)+ margin_stability = 1 - ((max(margins) - min(margins)) / max(margins)) if max(margins) > 0 else 0++ if avg_margin > 0.15 and margin_stability > 0.7:+ moat_indicators += 1+ total_indicators += 1++ # Return on invested capital superiority+ if metrics:+ roic_vals = [m.return_on_invested_capital for m in metrics if m.return_on_invested_capital]+ if roic_vals:+ avg_roic = sum(roic_vals) / len(roic_vals)+ if avg_roic > 0.15: # >15% ROIC+ moat_indicators += 1+ total_indicators += 1++ # Market position strength (proxy through revenue stability)+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ revenue_volatility = calculate_coefficient_of_variation(revenues)+ if revenue_volatility < 0.2: # Low revenue volatility+ moat_indicators += 1+ total_indicators += 1++ return moat_indicators / total_indicators if total_indicators > 0 else 0.5+++def assess_management_quality(metrics: list, financial_line_items: list) -> float:+ """Assess management quality"""+ if not metrics or not financial_line_items:+ return 0.5++ management_score = 0++ # Capital allocation effectiveness+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]+ if len(shares) >= 3:+ share_reduction = (shares[-1] - shares[0]) / shares[-1]+ if share_reduction > 0.1: # 10%+ share reduction+ management_score += 0.3++ # ROE improvement over time+ if metrics and len(metrics) >= 3:+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]+ if len(roe_vals) >= 3:+ recent_roe = sum(roe_vals[:2]) / 2+ historical_roe = sum(roe_vals[2:]) / len(roe_vals[2:])+ if recent_roe > historical_roe:+ management_score += 0.4++ # Free cash flow vs earnings (capital discipline)+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ earnings = [item.net_income for item in financial_line_items if item.net_income]++ if fcf_vals and earnings and len(fcf_vals) == len(earnings):+ fcf_conversion = sum(fcf_vals) / sum(earnings) if sum(earnings) > 0 else 0+ if fcf_conversion > 0.8:+ management_score += 0.3++ return management_score+++def calculate_intrinsic_value_ratio(financial_line_items: list, market_cap: float) -> float:+ """Calculate intrinsic value to market cap ratio"""+ if not financial_line_items or not market_cap:+ return 1.0++ latest = financial_line_items[0]++ # DCF-based intrinsic value+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ # Conservative assumptions+ growth_rate = 0.06 # 6% growth+ terminal_growth = 0.03 # 3% terminal growth+ discount_rate = 0.10 # 10% discount rate++ # 10-year DCF+ dcf_value = 0+ for year in range(1, 11):+ future_fcf = latest.free_cash_flow * (1 + growth_rate) ** year+ present_value = future_fcf / ((1 + discount_rate) ** year)+ dcf_value += present_value++ # Terminal value+ terminal_fcf = latest.free_cash_flow * (1 + growth_rate) ** 10+ terminal_value = terminal_fcf * (1 + terminal_growth) / (discount_rate - terminal_growth)+ terminal_pv = terminal_value / ((1 + discount_rate) ** 10)+ dcf_value += terminal_pv++ return dcf_value / market_cap++ return 1.0+++def analyze_long_term_growth_potential(financial_line_items: list) -> float:+ """Analyze long-term growth potential"""+ growth_factors = 0++ # Revenue growth trend+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 5:+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ if revenue_cagr > 0.08: # 8%+ revenue CAGR+ growth_factors += 0.3++ # R&D investment+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ if rd_vals and revenues:+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])+ if rd_intensity > 0.05: # 5%+ R&D intensity+ growth_factors += 0.3++ # Market expansion capability+ latest = financial_line_items[0]+ if latest.current_assets and latest.current_liabilities:+ working_capital_ratio = latest.current_assets / latest.current_liabilities+ if working_capital_ratio > 1.5: # Strong balance sheet for expansion+ growth_factors += 0.4++ return growth_factors+++def assess_governance_improvement_opportunities(metrics: list, financial_line_items: list) -> float:+ """Assess governance improvement opportunities"""+ governance_score = 0++ # Management performance issues+ management_quality = assess_management_quality(metrics, financial_line_items)+ if management_quality < 0.5:+ governance_score += 0.4 # Board change opportunity++ # Capital allocation inefficiencies+ capital_allocation = analyze_capital_allocation_opportunities(financial_line_items)+ if capital_allocation > 0.6:+ governance_score += 0.3++ # Shareholder returns vs performance+ if metrics:+ latest = metrics[0]+ if latest.return_on_equity and latest.return_on_equity < 0.1: # <10% ROE+ governance_score += 0.3 # Poor performance = governance opportunity++ return governance_score+++def identify_strategic_restructuring_opportunities(financial_line_items: list, market_cap: float) -> float:+ """Identify strategic restructuring opportunities"""+ if not financial_line_items or not market_cap:+ return 0++ restructuring_score = 0+ latest = financial_line_items[0]++ # Sum-of-parts opportunity+ if latest.total_assets and latest.total_debt:+ asset_value = latest.total_assets - latest.total_debt+ if asset_value > market_cap * 1.3: # 30%+ asset value premium+ restructuring_score += 0.4++ # Spin-off potential (proxy through asset complexity)+ if latest.total_assets and latest.revenue:+ asset_intensity = latest.total_assets / latest.revenue+ if asset_intensity > 2.5: # Asset-heavy suggests complex structure+ restructuring_score += 0.3++ # Operational restructuring need+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins and len(margins) >= 3:+ margin_decline = margins[-1] - margins[0] # Historical vs current+ if margin_decline > 0.05: # 5%+ margin decline+ restructuring_score += 0.3++ return restructuring_score+++def analyze_capital_allocation_opportunities(financial_line_items: list) -> float:+ """Analyze capital allocation improvement opportunities"""+ capital_score = 0++ # Excess cash accumulation+ latest = financial_line_items[0]+ if latest.current_assets and latest.total_assets:+ cash_proxy = latest.current_assets * 0.3 # Rough cash estimate+ if cash_proxy > latest.total_assets * 0.15: # >15% cash+ capital_score += 0.3++ # Poor FCF to earnings conversion+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]+ earnings = [item.net_income for item in financial_line_items if item.net_income]++ if fcf_vals and earnings and len(fcf_vals) == len(earnings):+ conversion_ratio = sum(fcf_vals) / sum(earnings) if sum(earnings) > 0 else 0+ if conversion_ratio < 0.7: # Poor cash conversion+ capital_score += 0.4++ # No share buybacks despite profitability+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]+ if len(shares) >= 3:+ share_change = (shares[0] - shares[-1]) / shares[-1]+ if share_change < 0.05 and earnings and sum(earnings) > 0: # No buybacks despite profit+ capital_score += 0.3++ return capital_score+++def identify_operational_efficiency_opportunities(financial_line_items: list) -> float:+ """Identify operational efficiency opportunities"""+ efficiency_score = 0++ # Margin improvement potential+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins:+ current_margin = margins[0]+ best_margin = max(margins)++ if best_margin > current_margin * 1.2: # 20%+ margin improvement potential+ efficiency_score += 0.4++ # Asset utilization improvement+ if latest.total_assets and latest.revenue:+ asset_turnover = latest.revenue / latest.total_assets+ if asset_turnover < 1.0: # Low asset utilization+ efficiency_score += 0.3++ # Cost structure optimization+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ revenue_growth = (revenues[0] / revenues[-1]) - 1+ margin_change = margins[0] - margins[-1] if margins and len(margins) >= 3 else 0++ if revenue_growth > 0 and margin_change < 0: # Growing revenue, declining margins+ efficiency_score += 0.3++ return efficiency_score+++def assess_esg_improvement_opportunities(financial_line_items: list) -> float:+ """Assess ESG improvement opportunities"""+ esg_score = 0++ # Environmental improvements (proxy through R&D)+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]+ revenues = [item.revenue for item in financial_line_items if item.revenue]++ if rd_vals and revenues:+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])+ if rd_intensity < 0.03: # Low R&D = ESG improvement opportunity+ esg_score += 0.3++ # Governance improvements (covered in governance section)+ governance_opportunity = assess_governance_improvement_opportunities(metrics, financial_line_items)+ esg_score += governance_opportunity * 0.4++ # Social responsibility opportunities+ # Proxy through employee productivity (simplified)+ if latest.revenue and latest.total_assets:+ productivity_proxy = latest.revenue / latest.total_assets+ if productivity_proxy < 0.8: # Low productivity+ esg_score += 0.3++ return min(esg_score, 1.0)+++def assess_public_campaign_viability(market_cap: float) -> float:+ """Assess public campaign viability"""+ # Larger companies get more media attention+ if market_cap > 50_000_000_000: # $50B++ return 0.9+ elif market_cap > 10_000_000_000: # $10B++ return 0.8+ elif market_cap > 1_000_000_000: # $1B++ return 0.6+ else:+ return 0.3+++def assess_public_narrative_strength(financial_line_items: list) -> float:+ """Assess strength of public narrative"""+ # Strong narrative if clear value creation opportunity+ narrative_score = 0++ # Underperformance narrative+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins and len(margins) >= 3:+ margin_decline = margins[-1] - margins[0]+ if margin_decline > 0.03: # Clear declining performance+ narrative_score += 0.4++ # Value creation potential narrative+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ revenue_stability = 1 - calculate_coefficient_of_variation(revenues)+ if revenue_stability > 0.7: # Stable business with improvement potential+ narrative_score += 0.3++ # Asset value narrative+ latest = financial_line_items[0]+ if latest.total_assets and latest.total_debt:+ net_assets = latest.total_assets - latest.total_debt+ # Strong asset base provides narrative foundation+ narrative_score += 0.3++ return narrative_score+++def analyze_media_coverage_potential(market_cap: float) -> float:+ """Analyze media coverage potential"""+ # Media coverage correlates with company size and visibility+ if market_cap > 20_000_000_000: # $20B++ return 0.8+ elif market_cap > 5_000_000_000: # $5B++ return 0.7+ elif market_cap > 1_000_000_000: # $1B++ return 0.5+ else:+ return 0.3+++def assess_shareholder_communication_potential(market_cap: float) -> float:+ """Assess shareholder communication effectiveness potential"""+ # Larger companies have more institutional shareholders+ return min(market_cap / 20_000_000_000, 1.5) # Normalize by $20B, cap at 1.5+++def evaluate_public_pressure_effectiveness(financial_line_items: list) -> float:+ """Evaluate effectiveness of public pressure"""+ # Public pressure more effective when clear improvement opportunities exist+ pressure_score = 0++ # Clear performance issues+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins:+ current_margin = margins[0]+ if current_margin < 0.1: # <10% margins+ pressure_score += 0.4++ # Shareholder value destruction+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ revenue_decline = revenues[0] < revenues[-1]+ if revenue_decline:+ pressure_score += 0.3++ return pressure_score+++def analyze_regulatory_environment(financial_line_items: list) -> float:+ """Analyze regulatory environment favorability"""+ # Simplified regulatory analysis+ return 0.6 # Neutral regulatory environment+++def assess_concentration_risk(market_cap: float) -> float:+ """Assess concentration risk for large positions"""+ # Larger companies have lower concentration risk+ if market_cap > 100_000_000_000: # $100B++ return 0.1+ elif market_cap > 20_000_000_000: # $20B++ return 0.2+ elif market_cap > 5_000_000_000: # $5B++ return 0.4+ else:+ return 0.7+++def assess_large_position_liquidity_risk(market_cap: float) -> float:+ """Assess liquidity risk for large positions"""+ # Liquidity risk inversely related to market cap+ if market_cap > 50_000_000_000: # $50B++ return 0.1+ elif market_cap > 10_000_000_000: # $10B++ return 0.2+ elif market_cap > 2_000_000_000: # $2B++ return 0.4+ else:+ return 0.8+++def assess_activist_campaign_risks(financial_line_items: list) -> float:+ """Assess activist campaign execution risks"""+ campaign_risk = 0.3 # Base campaign risk++ # Financial distress increases campaign risk+ latest = financial_line_items[0]+ if latest.current_assets and latest.current_liabilities:+ current_ratio = latest.current_assets / latest.current_liabilities+ if current_ratio < 1.2:+ campaign_risk += 0.3++ # Poor performance reduces campaign risk (easier to make case)+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins and margins[0] < 0.08: # <8% margins+ campaign_risk -= 0.2++ return max(0, min(campaign_risk, 1.0))+++def assess_regulatory_and_legal_risks(market_cap: float) -> float:+ """Assess regulatory and legal risks"""+ # Larger companies face more regulatory scrutiny+ if market_cap > 100_000_000_000: # $100B++ return 0.6+ elif market_cap > 20_000_000_000: # $20B++ return 0.4+ else:+ return 0.2+++def assess_reputational_risk_exposure(financial_line_items: list) -> float:+ """Assess reputational risk exposure"""+ # Reputational risk based on business fundamentals+ risk_score = 0.3 # Base risk++ # Poor performance increases reputational risk+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins and margins[0] < 0.05: # <5% margins+ risk_score += 0.3++ return risk_score+++def calculate_downside_protection(financial_line_items: list, market_cap: float) -> float:+ """Calculate downside protection"""+ if not financial_line_items or not market_cap:+ return 0.3++ protection_score = 0+ latest = financial_line_items[0]++ # Asset backing+ if latest.total_assets and latest.total_debt:+ net_assets = latest.total_assets - latest.total_debt+ if net_assets > market_cap * 0.8:+ protection_score += 0.4++ # Cash generation+ if latest.free_cash_flow and latest.free_cash_flow > 0:+ fcf_yield = latest.free_cash_flow / market_cap+ if fcf_yield > 0.08: # 8%+ FCF yield+ protection_score += 0.3++ # Business stability+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if revenues:+ revenue_stability = 1 - calculate_coefficient_of_variation(revenues)+ protection_score += revenue_stability * 0.3++ return protection_score+++def calculate_coefficient_of_variation(data: list) -> float:+ """Calculate coefficient of variation"""+ if not data or len(data) < 2:+ return 1.0++ mean_val = sum(data) / len(data)+ if mean_val == 0:+ return 1.0++ variance = sum((x - mean_val) ** 2 for x in data) / len(data)+ std_dev = (variance ** 0.5)++ return std_dev / abs(mean_val)+++def generate_pershing_output(ticker: str, analysis_data: dict, state: AgentState,+ agent_id: str) -> PershingSquareSignal:+ """Generate Pershing Square's concentrated activist investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Pershing Square's AI system, implementing Bill Ackman's concentrated activist approach:++ ORGANIZATIONAL STRUCTURE:+ - Research Team: Deep fundamental analysis and intrinsic value calculation+ - Activism Strategy Team: Board changes, strategic restructuring, operational improvements+ - Public Relations Strategy: Media campaigns, shareholder communication, narrative building+ - Risk Management: Concentration risk, liquidity risk, campaign execution risk+ - Bill Ackman Investment Decision: High-conviction concentrated positioning++ PHILOSOPHY:+ 1. Concentrated Investing: Large positions (10-25%) in high-conviction ideas+ 2. Activist Value Creation: Board changes, strategic improvements, operational efficiency+ 3. Public Campaigns: Media engagement and public pressure for change+ 4. Long-Term Value Creation: Multi-year investment horizons+ 5. Quality Businesses: Strong competitive positions with improvement potential+ 6. Intrinsic Value Focus: Significant discount to fair value required+ 7. ESG Integration: Environmental, social, and governance improvements++ REASONING STYLE:+ - Express high conviction and concentrated position rationale+ - Discuss specific activist catalysts and value creation opportunities+ - Reference intrinsic value calculations and margin of safety+ - Consider public campaign strategy and media narrative+ - Analyze management quality and governance improvements+ - Assess timeline and expected returns from activist engagement+ - Focus on asymmetric risk/reward from concentrated positions++ Return investment signal with detailed investment thesis and activist strategy."""),++ ("human", """Apply Pershing Square's concentrated activist analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "investment_thesis": {{+ "intrinsic_value_upside": float,+ "activist_catalysts": ["string"],+ "expected_timeline": "string",+ "position_size_recommendation": "string",+ "public_campaign_strategy": "string"+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_pershing_signal():+ return PershingSquareSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ investment_thesis={+ "intrinsic_value_upside": 0.0,+ "activist_catalysts": [],+ "expected_timeline": "12-24 months",+ "position_size_recommendation": "Pass",+ "public_campaign_strategy": "None"+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=PershingSquareSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_pershing_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/renaissance_technologies_hedge_fund_agent/renaissance_technologies_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/renaissance_technologies_hedge_fund_agent/renaissance_technologies_agent.pynew file mode 100644index 000000000..a8030f1e3--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/renaissance_technologies_hedge_fund_agent/renaissance_technologies_agent.py@@ -0,0 +1,676 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+import math+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class RenaissanceSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ statistical_edge: float+ signal_strength: dict+++def renaissance_technologies_agent(state: AgentState, agent_id: str = "renaissance_technologies_agent"):+ """+ Renaissance Technologies: Pure quantitative, statistical arbitrage+ Structure: Signal Generation → Risk Models → Execution Optimization → Jim Simons Systematic Decision+ Philosophy: Mathematical models, statistical edges, high-frequency systematic trading+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ renaissance_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Signal generation algorithms analyzing patterns")++ metrics = get_financial_metrics(ticker, end_date, period="quarterly", limit=20, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_assets",+ "shareholders_equity", "operating_margin", "total_debt",+ "current_assets", "current_liabilities", "outstanding_shares"+ ],+ end_date,+ period="quarterly",+ limit=20,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Renaissance's algorithmic analysis structure+ progress.update_status(agent_id, ticker, "Signal generation team analysis")+ signal_generation = signal_generation_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk modeling team analysis")+ risk_modeling = risk_modeling_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Execution optimization analysis")+ execution_optimization = execution_optimization_analysis(financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Statistical arbitrage models")+ statistical_arbitrage = statistical_arbitrage_analysis(metrics, financial_line_items)++ progress.update_status(agent_id, ticker, "Jim Simons systematic synthesis")+ simons_systematic_decision = simons_systematic_synthesis(+ signal_generation, risk_modeling, execution_optimization, statistical_arbitrage+ )++ # Renaissance's mathematical scoring+ total_score = (+ signal_generation["score"] * 0.35 ++ statistical_arbitrage["score"] * 0.3 ++ risk_modeling["score"] * 0.2 ++ execution_optimization["score"] * 0.15+ )++ # Renaissance's systematic thresholds+ if total_score >= 8.0 and signal_generation.get("statistical_significance", 0) > 0.95:+ signal = "bullish"+ elif total_score <= 3.0 or signal_generation.get("statistical_significance", 0) < 0.6:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "signal_generation": signal_generation,+ "risk_modeling": risk_modeling,+ "execution_optimization": execution_optimization,+ "statistical_arbitrage": statistical_arbitrage,+ "simons_systematic_decision": simons_systematic_decision+ }++ renaissance_output = generate_renaissance_output(ticker, analysis_data, state, agent_id)++ renaissance_analysis[ticker] = {+ "signal": renaissance_output.signal,+ "confidence": renaissance_output.confidence,+ "reasoning": renaissance_output.reasoning,+ "statistical_edge": renaissance_output.statistical_edge,+ "signal_strength": renaissance_output.signal_strength+ }++ progress.update_status(agent_id, ticker, "Done", analysis=renaissance_output.reasoning)++ message = HumanMessage(content=json.dumps(renaissance_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(renaissance_analysis, "Renaissance Technologies")++ state["data"]["analyst_signals"][agent_id] = renaissance_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def signal_generation_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Renaissance's signal generation algorithms"""+ score = 0+ details = []+ signals = {}++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No signal data"}++ # Mean reversion signals+ mean_reversion_score = calculate_mean_reversion_signals(metrics, financial_line_items)+ signals["mean_reversion"] = mean_reversion_score+ score += mean_reversion_score * 2++ # Momentum signals+ momentum_score = calculate_momentum_signals(metrics, financial_line_items)+ signals["momentum"] = momentum_score+ score += momentum_score * 2++ # Statistical pattern recognition+ pattern_score = identify_statistical_patterns(financial_line_items)+ signals["patterns"] = pattern_score+ score += pattern_score * 1.5++ # Cross-sectional signals+ cross_sectional_score = calculate_cross_sectional_signals(metrics)+ signals["cross_sectional"] = cross_sectional_score+ score += cross_sectional_score * 1.5++ # Factor exposure analysis+ factor_exposure = analyze_factor_exposures(metrics, financial_line_items)+ signals["factor_exposure"] = factor_exposure+ score += factor_exposure * 1++ # Statistical significance calculation+ statistical_significance = calculate_statistical_significance(signals)++ details.append(f"Mean reversion signal: {mean_reversion_score:.2f}")+ details.append(f"Momentum signal: {momentum_score:.2f}")+ details.append(f"Pattern recognition: {pattern_score:.2f}")+ details.append(f"Statistical significance: {statistical_significance:.2f}")++ return {+ "score": min(score, 10), # Cap at 10+ "details": "; ".join(details),+ "signals": signals,+ "statistical_significance": statistical_significance+ }+++def risk_modeling_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Renaissance's risk modeling team analysis"""+ score = 0+ details = []+ risk_metrics = {}++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No risk modeling data"}++ # Volatility modeling+ volatility_score = model_volatility_patterns(financial_line_items)+ risk_metrics["volatility"] = volatility_score+ if volatility_score > 0.7:+ score += 2+ details.append("Low volatility risk profile")++ # Correlation analysis+ correlation_risk = analyze_correlation_risks(metrics, financial_line_items)+ risk_metrics["correlation"] = correlation_risk+ if correlation_risk < 0.6: # Low correlation is good+ score += 2+ details.append("Low correlation risk with market factors")++ # Liquidity risk modeling+ liquidity_risk = model_liquidity_risk(financial_line_items, market_cap)+ risk_metrics["liquidity"] = liquidity_risk+ if liquidity_risk > 0.8:+ score += 1+ details.append("Adequate liquidity for position sizing")++ # Factor risk decomposition+ factor_risks = decompose_factor_risks(metrics)+ risk_metrics["factor_risks"] = factor_risks+ if factor_risks.get("idiosyncratic_risk", 0) > 0.6:+ score += 2+ details.append("High idiosyncratic risk component - good for alpha generation")++ # Drawdown risk analysis+ drawdown_risk = calculate_maximum_drawdown_risk(financial_line_items)+ risk_metrics["drawdown"] = drawdown_risk+ if drawdown_risk < 0.3: # Low drawdown risk+ score += 1+ details.append("Limited drawdown risk based on historical patterns")++ return {+ "score": score,+ "details": "; ".join(details),+ "risk_metrics": risk_metrics+ }+++def execution_optimization_analysis(financial_line_items: list, market_cap: float) -> dict:+ """Renaissance's execution optimization analysis"""+ score = 0+ details = []++ if not financial_line_items or not market_cap:+ return {"score": 0, "details": "No execution data"}++ # Market impact modeling+ market_impact = estimate_market_impact(market_cap)+ if market_impact < 0.02: # Low market impact+ score += 3+ details.append(f"Low market impact: {market_impact:.3f}")+ elif market_impact < 0.05:+ score += 2+ details.append(f"Moderate market impact: {market_impact:.3f}")++ # Execution timing optimization+ timing_score = analyze_execution_timing(financial_line_items)+ score += timing_score * 2+ details.append(f"Execution timing score: {timing_score:.2f}")++ # Transaction cost analysis+ transaction_costs = estimate_transaction_costs(market_cap)+ if transaction_costs < 0.01: # Low transaction costs+ score += 2+ details.append(f"Low transaction costs: {transaction_costs:.3f}")++ # Slippage minimization+ slippage_risk = calculate_slippage_risk(market_cap)+ if slippage_risk < 0.5:+ score += 1+ details.append("Low slippage risk for systematic execution")++ return {"score": score, "details": "; ".join(details)}+++def statistical_arbitrage_analysis(metrics: list, financial_line_items: list) -> dict:+ """Renaissance's statistical arbitrage models"""+ score = 0+ details = []+ arbitrage_signals = {}++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No statistical arbitrage data"}++ # Pairs trading signals+ pairs_signal = calculate_pairs_trading_signals(metrics, financial_line_items)+ arbitrage_signals["pairs"] = pairs_signal+ score += pairs_signal * 2++ # Statistical mispricing detection+ mispricing_score = detect_statistical_mispricing(metrics, financial_line_items)+ arbitrage_signals["mispricing"] = mispricing_score+ score += mispricing_score * 2.5++ # Regime change detection+ regime_change = detect_regime_changes(financial_line_items)+ arbitrage_signals["regime_change"] = regime_change+ score += regime_change * 1.5++ # Market microstructure signals+ microstructure_score = analyze_market_microstructure(metrics)+ arbitrage_signals["microstructure"] = microstructure_score+ score += microstructure_score * 1++ details.append(f"Pairs trading signal: {pairs_signal:.2f}")+ details.append(f"Mispricing detection: {mispricing_score:.2f}")+ details.append(f"Regime change signal: {regime_change:.2f}")++ return {+ "score": min(score, 10),+ "details": "; ".join(details),+ "arbitrage_signals": arbitrage_signals+ }+++def simons_systematic_synthesis(signal_generation: dict, risk_modeling: dict,+ execution_optimization: dict, statistical_arbitrage: dict) -> dict:+ """Jim Simons' systematic synthesis and decision"""+ details = []++ # Mathematical model synthesis+ signal_strength = signal_generation.get("statistical_significance", 0)+ risk_adjustment = risk_modeling.get("risk_metrics", {}).get("volatility", 0.5)+ execution_feasibility = execution_optimization["score"] / 10+ arbitrage_opportunity = statistical_arbitrage["score"] / 10++ # Simons' systematic decision framework+ overall_edge = (signal_strength * 0.4 ++ arbitrage_opportunity * 0.3 ++ execution_feasibility * 0.2 ++ (1 - risk_adjustment) * 0.1)++ if overall_edge > 0.8:+ decision = "High conviction systematic trade"+ details.append("Strong statistical edge with low risk and good execution")+ elif overall_edge > 0.6:+ decision = "Moderate systematic position"+ details.append("Adequate statistical edge for systematic strategy")+ elif signal_strength < 0.6:+ decision = "Insufficient statistical significance"+ details.append("Statistical significance below systematic threshold")+ else:+ decision = "Pass - inadequate systematic edge"+ details.append("No clear systematic advantage identified")++ # Mathematical model confidence+ model_confidence = min(signal_strength * arbitrage_opportunity * execution_feasibility, 1.0)++ return {+ "decision": decision,+ "overall_edge": overall_edge,+ "model_confidence": model_confidence,+ "details": "; ".join(details)+ }+++# Mathematical and statistical helper functions+def calculate_mean_reversion_signals(metrics: list, financial_line_items: list) -> float:+ """Calculate mean reversion signals"""+ if not metrics:+ return 0.5++ # Price-to-earnings mean reversion+ pe_ratios = [m.price_to_earnings for m in metrics if m.price_to_earnings and m.price_to_earnings > 0]+ if len(pe_ratios) >= 4:+ current_pe = pe_ratios[0]+ historical_mean = sum(pe_ratios[1:]) / len(pe_ratios[1:])++ # Mean reversion signal strength+ deviation = abs(current_pe - historical_mean) / historical_mean+ if current_pe < historical_mean * 0.8: # 20% below mean+ return min(deviation, 1.0)+ elif current_pe > historical_mean * 1.2: # 20% above mean+ return -min(deviation, 1.0)++ return 0.0+++def calculate_momentum_signals(metrics: list, financial_line_items: list) -> float:+ """Calculate momentum signals"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ # Revenue momentum+ recent_growth = (revenues[0] / revenues[1]) - 1+ historical_growth = (revenues[1] / revenues[-1]) ** (1 / (len(revenues) - 2)) - 1++ momentum_strength = (recent_growth - historical_growth) / abs(+ historical_growth) if historical_growth != 0 else 0+ return max(min(momentum_strength, 1.0), -1.0)++ return 0.0+++def identify_statistical_patterns(financial_line_items: list) -> float:+ """Identify statistical patterns in financial data"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if len(earnings) >= 8:+ # Pattern recognition using simple autocorrelation+ autocorr = calculate_autocorrelation(earnings, lag=1)+ pattern_strength = abs(autocorr)+ return min(pattern_strength, 1.0)++ return 0.3+++def calculate_cross_sectional_signals(metrics: list) -> float:+ """Calculate cross-sectional ranking signals"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ # Simplified cross-sectional score based on multiple metrics+ score_components = []++ if latest.return_on_equity:+ score_components.append(min(latest.return_on_equity / 0.15, 1.0)) # Normalize by 15%++ if latest.price_to_earnings and latest.price_to_earnings > 0:+ score_components.append(max(1 - (latest.price_to_earnings / 20), 0)) # Lower P/E is better++ if score_components:+ return sum(score_components) / len(score_components)++ return 0.5+++def analyze_factor_exposures(metrics: list, financial_line_items: list) -> float:+ """Analyze factor exposures"""+ # Simplified factor analysis+ if not metrics:+ return 0.5++ latest = metrics[0]+ factor_score = 0++ # Value factor+ if latest.price_to_book and latest.price_to_book < 2.0:+ factor_score += 0.3++ # Quality factor+ if latest.return_on_equity and latest.return_on_equity > 0.12:+ factor_score += 0.3++ # Momentum factor+ if financial_line_items:+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 2 and revenues[0] > revenues[1]:+ factor_score += 0.2++ return min(factor_score, 1.0)+++def calculate_statistical_significance(signals: dict) -> float:+ """Calculate overall statistical significance"""+ signal_values = [v for v in signals.values() if isinstance(v, (int, float))]+ if not signal_values:+ return 0.5++ # Simplified statistical significance based on signal consistency+ signal_consistency = 1 - (max(signal_values) - min(signal_values)) / 2+ signal_strength = sum(abs(v) for v in signal_values) / len(signal_values)++ return (signal_consistency * 0.6 + signal_strength * 0.4)+++def model_volatility_patterns(financial_line_items: list) -> float:+ """Model volatility patterns"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ volatility = calculate_coefficient_of_variation(revenues)+ return max(1 - volatility, 0) # Lower volatility = higher score+ return 0.5+++def analyze_correlation_risks(metrics: list, financial_line_items: list) -> float:+ """Analyze correlation with market factors"""+ # Simplified correlation analysis+ return 0.4 # Placeholder - would calculate correlation with market indices+++def model_liquidity_risk(financial_line_items: list, market_cap: float) -> float:+ """Model liquidity risk"""+ if market_cap > 10_000_000_000: # $10B+ market cap+ return 0.9+ elif market_cap > 1_000_000_000: # $1B+ market cap+ return 0.7+ else:+ return 0.4+++def decompose_factor_risks(metrics: list) -> dict:+ """Decompose factor risks"""+ return {+ "market_risk": 0.4,+ "size_risk": 0.2,+ "value_risk": 0.1,+ "momentum_risk": 0.1,+ "idiosyncratic_risk": 0.2+ }+++def calculate_maximum_drawdown_risk(financial_line_items: list) -> float:+ """Calculate maximum drawdown risk"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ peak = max(earnings)+ trough = min(earnings)+ if peak > 0:+ return abs(trough - peak) / peak+ return 0.5+++def estimate_market_impact(market_cap: float) -> float:+ """Estimate market impact for trading"""+ if market_cap > 50_000_000_000: # $50B++ return 0.001+ elif market_cap > 10_000_000_000: # $10B++ return 0.005+ elif market_cap > 1_000_000_000: # $1B++ return 0.02+ else:+ return 0.1+++def analyze_execution_timing(financial_line_items: list) -> float:+ """Analyze optimal execution timing"""+ return 0.7 # Placeholder for execution timing analysis+++def estimate_transaction_costs(market_cap: float) -> float:+ """Estimate transaction costs"""+ if market_cap > 10_000_000_000:+ return 0.005+ elif market_cap > 1_000_000_000:+ return 0.01+ else:+ return 0.03+++def calculate_slippage_risk(market_cap: float) -> float:+ """Calculate slippage risk"""+ return 1 / (1 + math.log10(market_cap / 1_000_000_000)) # Decreases with market cap+++def calculate_pairs_trading_signals(metrics: list, financial_line_items: list) -> float:+ """Calculate pairs trading signals"""+ return 0.6 # Placeholder for pairs trading analysis+++def detect_statistical_mispricing(metrics: list, financial_line_items: list) -> float:+ """Detect statistical mispricing"""+ if not metrics:+ return 0.5++ latest = metrics[0]+ mispricing_score = 0++ # P/E vs growth mispricing+ if latest.price_to_earnings and latest.price_to_earnings > 0:+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3:+ growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ expected_pe = 15 + (growth * 100) # Simple growth-adjusted P/E+ if latest.price_to_earnings < expected_pe * 0.8:+ mispricing_score += 0.5++ return mispricing_score+++def detect_regime_changes(financial_line_items: list) -> float:+ """Detect regime changes in business fundamentals"""+ margins = []+ for item in financial_line_items:+ if item.net_income and item.revenue and item.revenue > 0:+ margins.append(item.net_income / item.revenue)++ if len(margins) >= 4:+ recent_avg = sum(margins[:2]) / 2+ historical_avg = sum(margins[2:]) / len(margins[2:])++ if abs(recent_avg - historical_avg) > 0.05: # 5% margin change+ return 0.8++ return 0.2+++def analyze_market_microstructure(metrics: list) -> float:+ """Analyze market microstructure signals"""+ return 0.5 # Placeholder for microstructure analysis+++def calculate_autocorrelation(data: list, lag: int) -> float:+ """Calculate autocorrelation with given lag"""+ if len(data) <= lag:+ return 0++ mean_val = sum(data) / len(data)+ numerator = sum((data[i] - mean_val) * (data[i + lag] - mean_val)+ for i in range(len(data) - lag))+ denominator = sum((x - mean_val) ** 2 for x in data)++ return numerator / denominator if denominator != 0 else 0+++def calculate_coefficient_of_variation(data: list) -> float:+ """Calculate coefficient of variation"""+ if not data:+ return 1.0++ mean_val = sum(data) / len(data)+ if mean_val == 0:+ return 1.0++ variance = sum((x - mean_val) ** 2 for x in data) / len(data)+ std_dev = math.sqrt(variance)++ return std_dev / abs(mean_val)+++def generate_renaissance_output(ticker: str, analysis_data: dict, state: AgentState,+ agent_id: str) -> RenaissanceSignal:+ """Generate Renaissance's systematic quantitative decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Renaissance Technologies' AI system, implementing Jim Simons' quantitative systematic approach:++ ORGANIZATIONAL STRUCTURE:+ - Signal Generation Team: Mathematical pattern recognition and statistical signals+ - Risk Modeling Team: Volatility, correlation, and factor risk analysis+ - Execution Optimization Team: Market impact and transaction cost modeling+ - Statistical Arbitrage Team: Pairs trading and mispricing detection+ - Jim Simons Systematic Synthesis: Mathematical model integration++ PHILOSOPHY:+ 1. Pure Quantitative: Mathematical models over fundamental analysis+ 2. Statistical Edge: Identify small, consistent statistical advantages+ 3. Systematic Execution: Remove human emotion and bias+ 4. High Frequency: Exploit short-term market inefficiencies+ 5. Risk Management: Sophisticated mathematical risk models+ 6. Diversification: Many small bets rather than few large ones+ 7. Continuous Learning: Models adapt and evolve systematically++ REASONING STYLE:+ - Reference mathematical models and statistical significance+ - Discuss signal generation algorithms and pattern recognition+ - Consider risk-adjusted returns and Sharpe ratios+ - Apply systematic decision thresholds and confidence intervals+ - Express reasoning in quantitative terms+ - Acknowledge model limitations and uncertainty+ - Focus on statistical edge and execution feasibility++ Return the investment signal with statistical edge and signal strength metrics."""),++ ("human", """Apply Renaissance's quantitative systematic analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "statistical_edge": float (0-1),+ "signal_strength": {{+ "mean_reversion": float,+ "momentum": float,+ "statistical_arbitrage": float,+ "risk_adjusted_return": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_renaissance_signal():+ return RenaissanceSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ statistical_edge=0.0,+ signal_strength={+ "mean_reversion": 0.0,+ "momentum": 0.0,+ "statistical_arbitrage": 0.0,+ "risk_adjusted_return": 0.0+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=RenaissanceSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_renaissance_signal,+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/sample_usage.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/sample_usage.pynew file mode 100644index 000000000..3a520a8d2--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/sample_usage.py@@ -0,0 +1,415 @@+# ===== HEDGE FUND AGENTS INTEGRATION GUIDE =====++# 1. STANDALONE USAGE (Direct Import)+from bridgewater_hedge_fund import bridgewater_associates_agent+from renaissance_hedge_fund import renaissance_technologies_agent+from citadel_hedge_fund import citadel_hedge_fund_agent+++# ... import all other agents++def analyze_stock_with_hedge_funds(ticker: str, financial_data: dict):+ """Use multiple hedge fund agents to analyze a stock"""++ # Create mock state (replace with your actual state structure)+ state = {+ "data": {+ "tickers": [ticker],+ "end_date": "2024-12-31",+ "analyst_signals": {}+ },+ "metadata": {"show_reasoning": True}+ }++ # Run multiple hedge fund analyses+ results = {}++ # Bridgewater Analysis+ bridgewater_result = bridgewater_associates_agent(state, "bridgewater")+ results["bridgewater"] = state["data"]["analyst_signals"]["bridgewater"]++ # Renaissance Analysis+ renaissance_result = renaissance_technologies_agent(state, "renaissance")+ results["renaissance"] = state["data"]["analyst_signals"]["renaissance"]++ # AQR Analysis+ aqr_result = aqr_capital_hedge_fund_agent(state, "aqr")+ results["aqr"] = state["data"]["analyst_signals"]["aqr"]++ return results+++# 2. OPENROUTER INTEGRATION+import openai+++def setup_openrouter_client():+ """Setup OpenRouter client"""+ return openai.OpenAI(+ base_url="https://openrouter.ai/api/v1",+ api_key="YOUR_OPENROUTER_API_KEY"+ )+++def call_llm_openrouter(prompt, pydantic_model, agent_name, state, default_factory,+ model="anthropic/claude-3.5-sonnet"):+ """Modified LLM call for OpenRouter"""+ client = setup_openrouter_client()++ try:+ response = client.chat.completions.create(+ model=model,+ messages=[+ {"role": "system", "content": prompt.messages[0].content},+ {"role": "user", "content": prompt.messages[1].content}+ ],+ temperature=0.1,+ max_tokens=2000+ )++ # Parse JSON response+ import json+ content = response.choices[0].message.content++ # Extract JSON from response+ start_idx = content.find('{')+ end_idx = content.rfind('}') + 1+ json_str = content[start_idx:end_idx]++ parsed_data = json.loads(json_str)+ return pydantic_model(**parsed_data)++ except Exception as e:+ print(f"OpenRouter API error: {e}")+ return default_factory()+++# 3. OLLAMA LOCAL INTEGRATION+import requests+import json+++def call_llm_ollama(prompt, pydantic_model, agent_name, state, default_factory, model="llama3.1:70b"):+ """Modified LLM call for Ollama local"""++ # Combine system and user messages+ full_prompt = f"System: {prompt.messages[0].content}\n\nHuman: {prompt.messages[1].content}\n\nAssistant:"++ try:+ response = requests.post(+ "http://localhost:11434/api/generate",+ json={+ "model": model,+ "prompt": full_prompt,+ "stream": False,+ "options": {+ "temperature": 0.1,+ "top_p": 0.9+ }+ },+ timeout=120+ )++ if response.status_code == 200:+ content = response.json()["response"]++ # Extract JSON from response+ start_idx = content.find('{')+ end_idx = content.rfind('}') + 1++ if start_idx >= 0 and end_idx > start_idx:+ json_str = content[start_idx:end_idx]+ parsed_data = json.loads(json_str)+ return pydantic_model(**parsed_data)+ else:+ raise ValueError("No valid JSON found in response")+ else:+ raise Exception(f"HTTP {response.status_code}: {response.text}")++ except Exception as e:+ print(f"Ollama API error: {e}")+ return default_factory()+++# 4. CUSTOM LLM INTEGRATION WRAPPER+class HedgeFundLLMAdapter:+ """Adapter to use different LLM providers with hedge fund agents"""++ def __init__(self, provider="openai", **kwargs):+ self.provider = provider+ self.config = kwargs++ def call_llm(self, prompt, pydantic_model, agent_name, state, default_factory):+ """Route to appropriate LLM provider"""++ if self.provider == "openrouter":+ return call_llm_openrouter(+ prompt, pydantic_model, agent_name, state, default_factory,+ model=self.config.get("model", "anthropic/claude-3.5-sonnet")+ )+ elif self.provider == "ollama":+ return call_llm_ollama(+ prompt, pydantic_model, agent_name, state, default_factory,+ model=self.config.get("model", "llama3.1:70b")+ )+ elif self.provider == "openai":+ return self.call_openai_llm(prompt, pydantic_model, agent_name, state, default_factory)+ else:+ raise ValueError(f"Unsupported provider: {self.provider}")++ def call_openai_llm(self, prompt, pydantic_model, agent_name, state, default_factory):+ """OpenAI integration"""+ import openai++ client = openai.OpenAI(api_key=self.config.get("api_key"))++ try:+ response = client.chat.completions.create(+ model=self.config.get("model", "gpt-4"),+ messages=[+ {"role": "system", "content": prompt.messages[0].content},+ {"role": "user", "content": prompt.messages[1].content}+ ],+ temperature=0.1,+ max_tokens=2000+ )++ content = response.choices[0].message.content+ start_idx = content.find('{')+ end_idx = content.rfind('}') + 1+ json_str = content[start_idx:end_idx]++ parsed_data = json.loads(json_str)+ return pydantic_model(**parsed_data)++ except Exception as e:+ print(f"OpenAI API error: {e}")+ return default_factory()+++# 5. USAGE EXAMPLES++def example_standalone_usage():+ """Example: Using hedge fund agents standalone"""++ # Mock financial data (replace with real data from your API)+ mock_state = {+ "data": {+ "tickers": ["AAPL"],+ "end_date": "2024-12-31",+ "analyst_signals": {}+ },+ "metadata": {"show_reasoning": True}+ }++ # Patch the call_llm function to use your preferred provider+ import bridgewater_hedge_fund+ llm_adapter = HedgeFundLLMAdapter(provider="openrouter", model="anthropic/claude-3.5-sonnet")+ bridgewater_hedge_fund.call_llm = llm_adapter.call_llm++ # Run analysis+ result = bridgewater_associates_agent(mock_state, "bridgewater_test")++ print("Bridgewater Analysis Results:")+ print(json.dumps(mock_state["data"]["analyst_signals"]["bridgewater_test"], indent=2))+++def example_multi_hedge_fund_consensus():+ """Example: Get consensus from multiple hedge funds"""++ hedge_funds = [+ ("bridgewater", bridgewater_associates_agent),+ ("renaissance", renaissance_technologies_agent),+ ("aqr", aqr_capital_hedge_fund_agent),+ ("elliott", elliott_management_hedge_fund_agent)+ ]++ ticker = "MSFT"+ all_signals = {}++ # Setup LLM adapter+ llm_adapter = HedgeFundLLMAdapter(provider="ollama", model="llama3.1:70b")++ for fund_name, fund_agent in hedge_funds:+ # Patch LLM function for this fund+ fund_module = fund_agent.__module__+ import importlib+ module = importlib.import_module(fund_module)+ module.call_llm = llm_adapter.call_llm++ # Create state+ state = create_mock_state([ticker])++ # Run analysis+ try:+ fund_agent(state, f"{fund_name}_analysis")+ all_signals[fund_name] = state["data"]["analyst_signals"][f"{fund_name}_analysis"][ticker]+ except Exception as e:+ print(f"Error running {fund_name}: {e}")+ continue++ # Calculate consensus+ consensus = calculate_hedge_fund_consensus(all_signals)+ return consensus+++def create_mock_state(tickers: list):+ """Create mock state for testing"""+ return {+ "data": {+ "tickers": tickers,+ "end_date": "2024-12-31",+ "analyst_signals": {}+ },+ "metadata": {"show_reasoning": True}+ }+++def calculate_hedge_fund_consensus(signals: dict):+ """Calculate consensus from multiple hedge fund signals"""++ if not signals:+ return {"consensus": "neutral", "confidence": 0}++ # Count signals+ bullish_count = sum(1 for signal in signals.values() if signal.get("signal") == "bullish")+ bearish_count = sum(1 for signal in signals.values() if signal.get("signal") == "bearish")+ neutral_count = len(signals) - bullish_count - bearish_count++ total_funds = len(signals)++ # Determine consensus+ if bullish_count > total_funds * 0.6:+ consensus = "bullish"+ confidence = bullish_count / total_funds+ elif bearish_count > total_funds * 0.6:+ consensus = "bearish"+ confidence = bearish_count / total_funds+ else:+ consensus = "neutral"+ confidence = max(bullish_count, bearish_count, neutral_count) / total_funds++ # Calculate average confidence+ avg_confidence = sum(signal.get("confidence", 0) for signal in signals.values()) / total_funds++ return {+ "consensus": consensus,+ "consensus_strength": confidence,+ "average_confidence": avg_confidence,+ "fund_breakdown": {+ "bullish": bullish_count,+ "bearish": bearish_count,+ "neutral": neutral_count+ },+ "individual_signals": signals+ }+++# 6. FLASK/FASTAPI WEB SERVICE EXAMPLE++from flask import Flask, request, jsonify++app = Flask(__name__)++[email protected]('/analyze/<ticker>')+def analyze_ticker(ticker):+ """Web endpoint to analyze a ticker with all hedge funds"""++ try:+ # Setup LLM adapter based on query parameter+ provider = request.args.get('provider', 'openrouter')+ model = request.args.get('model', 'anthropic/claude-3.5-sonnet')++ llm_adapter = HedgeFundLLMAdapter(provider=provider, model=model)++ # Run analysis with selected hedge funds+ selected_funds = request.args.get('funds', 'bridgewater,aqr,renaissance').split(',')++ results = {}+ for fund_name in selected_funds:+ if fund_name in AVAILABLE_FUNDS:+ fund_agent = AVAILABLE_FUNDS[fund_name]++ # Patch LLM+ fund_module = importlib.import_module(fund_agent.__module__)+ fund_module.call_llm = llm_adapter.call_llm++ # Run analysis+ state = create_mock_state([ticker])+ fund_agent(state, f"{fund_name}_web")+ results[fund_name] = state["data"]["analyst_signals"][f"{fund_name}_web"][ticker]++ # Calculate consensus+ consensus = calculate_hedge_fund_consensus(results)++ return jsonify({+ "ticker": ticker,+ "consensus": consensus,+ "individual_analyses": results,+ "timestamp": "2024-12-31T00:00:00Z"+ })++ except Exception as e:+ return jsonify({"error": str(e)}), 500+++# Available hedge funds mapping+AVAILABLE_FUNDS = {+ "bridgewater": bridgewater_associates_agent,+ "renaissance": renaissance_technologies_agent,+ "citadel": citadel_hedge_fund_agent,+ "two_sigma": two_sigma_hedge_fund_agent,+ "aqr": aqr_capital_hedge_fund_agent,+ "elliott": elliott_management_hedge_fund_agent,+ "millennium": millennium_management_hedge_fund_agent,+ "de_shaw": de_shaw_hedge_fund_agent,+ "pershing_square": pershing_square_hedge_fund_agent+}++if __name__ == "__main__":+ # Example usage+ print("=== Hedge Fund Agents Integration Examples ===")++ # Test standalone usage+ example_standalone_usage()++ # Test multi-fund consensus+ consensus = example_multi_hedge_fund_consensus()+ print("\nConsensus Results:")+ print(json.dumps(consensus, indent=2))++ # Start web service (uncomment to run)+ # app.run(debug=True, port=5000)++# 7. CONFIGURATION FILE EXAMPLE (config.yaml)+"""+# config.yaml+llm_providers:+ openrouter:+ api_key: "YOUR_OPENROUTER_KEY"+ base_url: "https://openrouter.ai/api/v1"+ default_model: "anthropic/claude-3.5-sonnet"++ ollama:+ base_url: "http://localhost:11434"+ default_model: "llama3.1:70b"++ openai:+ api_key: "YOUR_OPENAI_KEY"+ default_model: "gpt-4"++financial_data:+ api_key: "YOUR_FINANCIAL_API_KEY"+ provider: "alpha_vantage" # or "financial_datasets"++hedge_funds:+ enabled:+ - bridgewater+ - renaissance+ - aqr+ - elliott++ default_analysis_period: "annual"+ default_limit: 10+"""\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/state.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/state.pynew file mode 100644index 000000000..f8dc42216--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/state.py@@ -0,0 +1,51 @@+from typing_extensions import Annotated, Sequence, TypedDict++import operator+from langchain_core.messages import BaseMessage+++import json+++def merge_dicts(a: dict[str, any], b: dict[str, any]) -> dict[str, any]:+ return {**a, **b}+++# Define agent state+class AgentState(TypedDict):+ messages: Annotated[Sequence[BaseMessage], operator.add]+ data: Annotated[dict[str, any], merge_dicts]+ metadata: Annotated[dict[str, any], merge_dicts]+++def show_agent_reasoning(output, agent_name):+ print(f"\n{'=' * 10} {agent_name.center(28)} {'=' * 10}")++ def convert_to_serializable(obj):+ if hasattr(obj, "to_dict"): # Handle Pandas Series/DataFrame+ return obj.to_dict()+ elif hasattr(obj, "__dict__"): # Handle custom objects+ return obj.__dict__+ elif isinstance(obj, (int, float, bool, str)):+ return obj+ elif isinstance(obj, (list, tuple)):+ return [convert_to_serializable(item) for item in obj]+ elif isinstance(obj, dict):+ return {key: convert_to_serializable(value) for key, value in obj.items()}+ else:+ return str(obj) # Fallback to string representation++ if isinstance(output, (dict, list)):+ # Convert the output to JSON-serializable format+ serializable_output = convert_to_serializable(output)+ print(json.dumps(serializable_output, indent=2))+ else:+ try:+ # Parse the string as JSON and pretty print it+ parsed_output = json.loads(output)+ print(json.dumps(parsed_output, indent=2))+ except json.JSONDecodeError:+ # Fallback to original string if not valid JSON+ print(output)++ print("=" * 48)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/api.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/api.pynew file mode 100644index 000000000..60ccbdc9b--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/api.py@@ -0,0 +1,342 @@+import datetime+import os+import pandas as pd+import requests+import time++from src.data.cache import get_cache+from src.data.models import (+ CompanyNews,+ CompanyNewsResponse,+ FinancialMetrics,+ FinancialMetricsResponse,+ Price,+ PriceResponse,+ LineItem,+ LineItemResponse,+ InsiderTrade,+ InsiderTradeResponse,+ CompanyFactsResponse,+)++# Global cache instance+_cache = get_cache()+++def _make_api_request(url: str, headers: dict, method: str = "GET", json_data: dict = None, max_retries: int = 3) -> requests.Response:+ """+ Make an API request with rate limiting handling and moderate backoff.++ Args:+ url: The URL to request+ headers: Headers to include in the request+ method: HTTP method (GET or POST)+ json_data: JSON data for POST requests+ max_retries: Maximum number of retries (default: 3)++ Returns:+ requests.Response: The response object++ Raises:+ Exception: If the request fails with a non-429 error+ """+ for attempt in range(max_retries + 1): # +1 for initial attempt+ if method.upper() == "POST":+ response = requests.post(url, headers=headers, json=json_data)+ else:+ response = requests.get(url, headers=headers)++ if response.status_code == 429 and attempt < max_retries:+ # Linear backoff: 60s, 90s, 120s, 150s...+ delay = 60 + (30 * attempt)+ print(f"Rate limited (429). Attempt {attempt + 1}/{max_retries + 1}. Waiting {delay}s before retrying...")+ time.sleep(delay)+ continue++ # Return the response (whether success, other errors, or final 429)+ return response+++def get_prices(ticker: str, start_date: str, end_date: str, api_key: str = None) -> list[Price]:+ """Fetch price data from cache or API."""+ # Create a cache key that includes all parameters to ensure exact matches+ cache_key = f"{ticker}_{start_date}_{end_date}"++ # Check cache first - simple exact match+ if cached_data := _cache.get_prices(cache_key):+ return [Price(**price) for price in cached_data]++ # If not in cache, fetch from API+ headers = {}+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")+ if financial_api_key:+ headers["X-API-KEY"] = financial_api_key++ url = f"https://api.financialdatasets.ai/prices/?ticker={ticker}&interval=day&interval_multiplier=1&start_date={start_date}&end_date={end_date}"+ response = _make_api_request(url, headers)+ if response.status_code != 200:+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")++ # Parse response with Pydantic model+ price_response = PriceResponse(**response.json())+ prices = price_response.prices++ if not prices:+ return []++ # Cache the results using the comprehensive cache key+ _cache.set_prices(cache_key, [p.model_dump() for p in prices])+ return prices+++def get_financial_metrics(+ ticker: str,+ end_date: str,+ period: str = "ttm",+ limit: int = 10,+ api_key: str = None,+) -> list[FinancialMetrics]:+ """Fetch financial metrics from cache or API."""+ # Create a cache key that includes all parameters to ensure exact matches+ cache_key = f"{ticker}_{period}_{end_date}_{limit}"++ # Check cache first - simple exact match+ if cached_data := _cache.get_financial_metrics(cache_key):+ return [FinancialMetrics(**metric) for metric in cached_data]++ # If not in cache, fetch from API+ headers = {}+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")+ if financial_api_key:+ headers["X-API-KEY"] = financial_api_key++ url = f"https://api.financialdatasets.ai/financial-metrics/?ticker={ticker}&report_period_lte={end_date}&limit={limit}&period={period}"+ response = _make_api_request(url, headers)+ if response.status_code != 200:+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")++ # Parse response with Pydantic model+ metrics_response = FinancialMetricsResponse(**response.json())+ financial_metrics = metrics_response.financial_metrics++ if not financial_metrics:+ return []++ # Cache the results as dicts using the comprehensive cache key+ _cache.set_financial_metrics(cache_key, [m.model_dump() for m in financial_metrics])+ return financial_metrics+++def search_line_items(+ ticker: str,+ line_items: list[str],+ end_date: str,+ period: str = "ttm",+ limit: int = 10,+ api_key: str = None,+) -> list[LineItem]:+ """Fetch line items from API."""+ # If not in cache or insufficient data, fetch from API+ headers = {}+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")+ if financial_api_key:+ headers["X-API-KEY"] = financial_api_key++ url = "https://api.financialdatasets.ai/financials/search/line-items"++ body = {+ "tickers": [ticker],+ "line_items": line_items,+ "end_date": end_date,+ "period": period,+ "limit": limit,+ }+ response = _make_api_request(url, headers, method="POST", json_data=body)+ if response.status_code != 200:+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")+ data = response.json()+ response_model = LineItemResponse(**data)+ search_results = response_model.search_results+ if not search_results:+ return []++ # Cache the results+ return search_results[:limit]+++def get_insider_trades(+ ticker: str,+ end_date: str,+ start_date: str | None = None,+ limit: int = 1000,+ api_key: str = None,+) -> list[InsiderTrade]:+ """Fetch insider trades from cache or API."""+ # Create a cache key that includes all parameters to ensure exact matches+ cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"++ # Check cache first - simple exact match+ if cached_data := _cache.get_insider_trades(cache_key):+ return [InsiderTrade(**trade) for trade in cached_data]++ # If not in cache, fetch from API+ headers = {}+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")+ if financial_api_key:+ headers["X-API-KEY"] = financial_api_key++ all_trades = []+ current_end_date = end_date++ while True:+ url = f"https://api.financialdatasets.ai/insider-trades/?ticker={ticker}&filing_date_lte={current_end_date}"+ if start_date:+ url += f"&filing_date_gte={start_date}"+ url += f"&limit={limit}"++ response = _make_api_request(url, headers)+ if response.status_code != 200:+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")++ data = response.json()+ response_model = InsiderTradeResponse(**data)+ insider_trades = response_model.insider_trades++ if not insider_trades:+ break++ all_trades.extend(insider_trades)++ # Only continue pagination if we have a start_date and got a full page+ if not start_date or len(insider_trades) < limit:+ break++ # Update end_date to the oldest filing date from current batch for next iteration+ current_end_date = min(trade.filing_date for trade in insider_trades).split("T")[0]++ # If we've reached or passed the start_date, we can stop+ if current_end_date <= start_date:+ break++ if not all_trades:+ return []++ # Cache the results using the comprehensive cache key+ _cache.set_insider_trades(cache_key, [trade.model_dump() for trade in all_trades])+ return all_trades+++def get_company_news(+ ticker: str,+ end_date: str,+ start_date: str | None = None,+ limit: int = 1000,+ api_key: str = None,+) -> list[CompanyNews]:+ """Fetch company news from cache or API."""+ # Create a cache key that includes all parameters to ensure exact matches+ cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"++ # Check cache first - simple exact match+ if cached_data := _cache.get_company_news(cache_key):+ return [CompanyNews(**news) for news in cached_data]++ # If not in cache, fetch from API+ headers = {}+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")+ if financial_api_key:+ headers["X-API-KEY"] = financial_api_key++ all_news = []+ current_end_date = end_date++ while True:+ url = f"https://api.financialdatasets.ai/news/?ticker={ticker}&end_date={current_end_date}"+ if start_date:+ url += f"&start_date={start_date}"+ url += f"&limit={limit}"++ response = _make_api_request(url, headers)+ if response.status_code != 200:+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")++ data = response.json()+ response_model = CompanyNewsResponse(**data)+ company_news = response_model.news++ if not company_news:+ break++ all_news.extend(company_news)++ # Only continue pagination if we have a start_date and got a full page+ if not start_date or len(company_news) < limit:+ break++ # Update end_date to the oldest date from current batch for next iteration+ current_end_date = min(news.date for news in company_news).split("T")[0]++ # If we've reached or passed the start_date, we can stop+ if current_end_date <= start_date:+ break++ if not all_news:+ return []++ # Cache the results using the comprehensive cache key+ _cache.set_company_news(cache_key, [news.model_dump() for news in all_news])+ return all_news+++def get_market_cap(+ ticker: str,+ end_date: str,+ api_key: str = None,+) -> float | None:+ """Fetch market cap from the API."""+ # Check if end_date is today+ if end_date == datetime.datetime.now().strftime("%Y-%m-%d"):+ # Get the market cap from company facts API+ headers = {}+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")+ if financial_api_key:+ headers["X-API-KEY"] = financial_api_key++ url = f"https://api.financialdatasets.ai/company/facts/?ticker={ticker}"+ response = _make_api_request(url, headers)+ if response.status_code != 200:+ print(f"Error fetching company facts: {ticker} - {response.status_code}")+ return None++ data = response.json()+ response_model = CompanyFactsResponse(**data)+ return response_model.company_facts.market_cap++ financial_metrics = get_financial_metrics(ticker, end_date, api_key=api_key)+ if not financial_metrics:+ return None++ market_cap = financial_metrics[0].market_cap++ if not market_cap:+ return None++ return market_cap+++def prices_to_df(prices: list[Price]) -> pd.DataFrame:+ """Convert prices to a DataFrame."""+ df = pd.DataFrame([p.model_dump() for p in prices])+ df["Date"] = pd.to_datetime(df["time"])+ df.set_index("Date", inplace=True)+ numeric_cols = ["open", "close", "high", "low", "volume"]+ for col in numeric_cols:+ df[col] = pd.to_numeric(df[col], errors="coerce")+ df.sort_index(inplace=True)+ return df+++# Update the get_price_data function to use the new functions+def get_price_data(ticker: str, start_date: str, end_date: str, api_key: str = None) -> pd.DataFrame:+ prices = get_prices(ticker, start_date, end_date, api_key=api_key)+ return prices_to_df(prices)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/__init__.pynew file mode 100644index 000000000..de043de03--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/__init__.py@@ -0,0 +1,3 @@+# This file can be empty++"""Utility modules for the application."""diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/analysts.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/analysts.pynew file mode 100644index 000000000..26f9d21fd--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/analysts.py@@ -0,0 +1,173 @@+"""Constants and utilities related to analysts configuration."""++from src.agents import portfolio_manager+from src.agents.aswath_damodaran import aswath_damodaran_agent+from src.agents.ben_graham import ben_graham_agent+from src.agents.bill_ackman import bill_ackman_agent+from src.agents.cathie_wood import cathie_wood_agent+from src.agents.charlie_munger import charlie_munger_agent+from src.agents.fundamentals import fundamentals_analyst_agent+from src.agents.michael_burry import michael_burry_agent+from src.agents.phil_fisher import phil_fisher_agent+from src.agents.peter_lynch import peter_lynch_agent+from src.agents.sentiment import sentiment_analyst_agent+from src.agents.stanley_druckenmiller import stanley_druckenmiller_agent+from src.agents.technicals import technical_analyst_agent+from src.agents.valuation import valuation_analyst_agent+from src.agents.warren_buffett import warren_buffett_agent+from src.agents.rakesh_jhunjhunwala import rakesh_jhunjhunwala_agent+from src.agents.mohnish_pabrai import mohnish_pabrai_agent++# Define analyst configuration - single source of truth+ANALYST_CONFIG = {+ "aswath_damodaran": {+ "display_name": "Aswath Damodaran",+ "description": "The Dean of Valuation",+ "investing_style": "Focuses on intrinsic value and financial metrics to assess investment opportunities through rigorous valuation analysis.",+ "agent_func": aswath_damodaran_agent,+ "type": "analyst",+ "order": 0,+ },+ "ben_graham": {+ "display_name": "Ben Graham",+ "description": "The Father of Value Investing",+ "investing_style": "Emphasizes a margin of safety and invests in undervalued companies with strong fundamentals through systematic value analysis.",+ "agent_func": ben_graham_agent,+ "type": "analyst",+ "order": 1,+ },+ "bill_ackman": {+ "display_name": "Bill Ackman",+ "description": "The Activist Investor",+ "investing_style": "Seeks to influence management and unlock value through strategic activism and contrarian investment positions.",+ "agent_func": bill_ackman_agent,+ "type": "analyst",+ "order": 2,+ },+ "cathie_wood": {+ "display_name": "Cathie Wood",+ "description": "The Queen of Growth Investing",+ "investing_style": "Focuses on disruptive innovation and growth, investing in companies that are leading technological advancements and market disruption.",+ "agent_func": cathie_wood_agent,+ "type": "analyst",+ "order": 3,+ },+ "charlie_munger": {+ "display_name": "Charlie Munger",+ "description": "The Rational Thinker",+ "investing_style": "Advocates for value investing with a focus on quality businesses and long-term growth through rational decision-making.",+ "agent_func": charlie_munger_agent,+ "type": "analyst",+ "order": 4,+ },+ "michael_burry": {+ "display_name": "Michael Burry",+ "description": "The Big Short Contrarian",+ "investing_style": "Makes contrarian bets, often shorting overvalued markets and investing in undervalued assets through deep fundamental analysis.",+ "agent_func": michael_burry_agent,+ "type": "analyst",+ "order": 5,+ },+ "mohnish_pabrai": {+ "display_name": "Mohnish Pabrai",+ "description": "The Dhandho Investor",+ "investing_style": "Focuses on value investing and long-term growth through fundamental analysis and a margin of safety.",+ "agent_func": mohnish_pabrai_agent,+ "type": "analyst",+ "order": 6,+ },+ "peter_lynch": {+ "display_name": "Peter Lynch",+ "description": "The 10-Bagger Investor",+ "investing_style": "Invests in companies with understandable business models and strong growth potential using the 'buy what you know' strategy.",+ "agent_func": peter_lynch_agent,+ "type": "analyst",+ "order": 6,+ },+ "phil_fisher": {+ "display_name": "Phil Fisher",+ "description": "The Scuttlebutt Investor",+ "investing_style": "Emphasizes investing in companies with strong management and innovative products, focusing on long-term growth through scuttlebutt research.",+ "agent_func": phil_fisher_agent,+ "type": "analyst",+ "order": 7,+ },+ "rakesh_jhunjhunwala": {+ "display_name": "Rakesh Jhunjhunwala",+ "description": "The Big Bull Of India",+ "investing_style": "Leverages macroeconomic insights to invest in high-growth sectors, particularly within emerging markets and domestic opportunities.",+ "agent_func": rakesh_jhunjhunwala_agent,+ "type": "analyst",+ "order": 8,+ },+ "stanley_druckenmiller": {+ "display_name": "Stanley Druckenmiller",+ "description": "The Macro Investor",+ "investing_style": "Focuses on macroeconomic trends, making large bets on currencies, commodities, and interest rates through top-down analysis.",+ "agent_func": stanley_druckenmiller_agent,+ "type": "analyst",+ "order": 9,+ },+ "warren_buffett": {+ "display_name": "Warren Buffett",+ "description": "The Oracle of Omaha",+ "investing_style": "Seeks companies with strong fundamentals and competitive advantages through value investing and long-term ownership.",+ "agent_func": warren_buffett_agent,+ "type": "analyst",+ "order": 10,+ },+ "technical_analyst": {+ "display_name": "Technical Analyst",+ "description": "Chart Pattern Specialist",+ "investing_style": "Focuses on chart patterns and market trends to make investment decisions, often using technical indicators and price action analysis.",+ "agent_func": technical_analyst_agent,+ "type": "analyst",+ "order": 11,+ },+ "fundamentals_analyst": {+ "display_name": "Fundamentals Analyst",+ "description": "Financial Statement Specialist",+ "investing_style": "Delves into financial statements and economic indicators to assess the intrinsic value of companies through fundamental analysis.",+ "agent_func": fundamentals_analyst_agent,+ "type": "analyst",+ "order": 12,+ },+ "sentiment_analyst": {+ "display_name": "Sentiment Analyst",+ "description": "Market Sentiment Specialist",+ "investing_style": "Gauges market sentiment and investor behavior to predict market movements and identify opportunities through behavioral analysis.",+ "agent_func": sentiment_analyst_agent,+ "type": "analyst",+ "order": 13,+ },+ "valuation_analyst": {+ "display_name": "Valuation Analyst",+ "description": "Company Valuation Specialist",+ "investing_style": "Specializes in determining the fair value of companies, using various valuation models and financial metrics for investment decisions.",+ "agent_func": valuation_analyst_agent,+ "type": "analyst",+ "order": 14,+ },+}++# Derive ANALYST_ORDER from ANALYST_CONFIG for backwards compatibility+ANALYST_ORDER = [(config["display_name"], key) for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])]+++def get_analyst_nodes():+ """Get the mapping of analyst keys to their (node_name, agent_func) tuples."""+ return {key: (f"{key}_agent", config["agent_func"]) for key, config in ANALYST_CONFIG.items()}+++def get_agents_list():+ """Get the list of agents for API responses."""+ return [+ {+ "key": key,+ "display_name": config["display_name"],+ "description": config["description"],+ "investing_style": config["investing_style"],+ "order": config["order"]+ }+ for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])+ ]diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/api_key.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/api_key.pynew file mode 100644index 000000000..048813f75--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/api_key.py@@ -0,0 +1,9 @@+++def get_api_key_from_state(state: dict, api_key_name: str) -> str:+ """Get an API key from the state object."""+ if state and state.get("metadata", {}).get("request"):+ request = state["metadata"]["request"]+ if hasattr(request, 'api_keys') and request.api_keys:+ return request.api_keys.get(api_key_name)+ return None\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/display.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/display.pynew file mode 100644index 000000000..21a7f6852--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/display.py@@ -0,0 +1,371 @@+from colorama import Fore, Style+from tabulate import tabulate+from .analysts import ANALYST_ORDER+import os+import json+++def sort_agent_signals(signals):+ """Sort agent signals in a consistent order."""+ # Create order mapping from ANALYST_ORDER+ analyst_order = {display: idx for idx, (display, _) in enumerate(ANALYST_ORDER)}+ analyst_order["Risk Management"] = len(ANALYST_ORDER) # Add Risk Management at the end++ return sorted(signals, key=lambda x: analyst_order.get(x[0], 999))+++def print_trading_output(result: dict) -> None:+ """+ Print formatted trading results with colored tables for multiple tickers.++ Args:+ result (dict): Dictionary containing decisions and analyst signals for multiple tickers+ """+ decisions = result.get("decisions")+ if not decisions:+ print(f"{Fore.RED}No trading decisions available{Style.RESET_ALL}")+ return++ # Print decisions for each ticker+ for ticker, decision in decisions.items():+ print(f"\n{Fore.WHITE}{Style.BRIGHT}Analysis for {Fore.CYAN}{ticker}{Style.RESET_ALL}")+ print(f"{Fore.WHITE}{Style.BRIGHT}{'=' * 50}{Style.RESET_ALL}")++ # Prepare analyst signals table for this ticker+ table_data = []+ for agent, signals in result.get("analyst_signals", {}).items():+ if ticker not in signals:+ continue++ # Skip Risk Management agent in the signals section+ if agent == "risk_management_agent":+ continue++ signal = signals[ticker]+ agent_name = agent.replace("_agent", "").replace("_", " ").title()+ signal_type = signal.get("signal", "").upper()+ confidence = signal.get("confidence", 0)++ signal_color = {+ "BULLISH": Fore.GREEN,+ "BEARISH": Fore.RED,+ "NEUTRAL": Fore.YELLOW,+ }.get(signal_type, Fore.WHITE)++ # Get reasoning if available+ reasoning_str = ""+ if "reasoning" in signal and signal["reasoning"]:+ reasoning = signal["reasoning"]++ # Handle different types of reasoning (string, dict, etc.)+ if isinstance(reasoning, str):+ reasoning_str = reasoning+ elif isinstance(reasoning, dict):+ # Convert dict to string representation+ reasoning_str = json.dumps(reasoning, indent=2)+ else:+ # Convert any other type to string+ reasoning_str = str(reasoning)++ # Wrap long reasoning text to make it more readable+ wrapped_reasoning = ""+ current_line = ""+ # Use a fixed width of 60 characters to match the table column width+ max_line_length = 60+ for word in reasoning_str.split():+ if len(current_line) + len(word) + 1 > max_line_length:+ wrapped_reasoning += current_line + "\n"+ current_line = word+ else:+ if current_line:+ current_line += " " + word+ else:+ current_line = word+ if current_line:+ wrapped_reasoning += current_line++ reasoning_str = wrapped_reasoning++ table_data.append(+ [+ f"{Fore.CYAN}{agent_name}{Style.RESET_ALL}",+ f"{signal_color}{signal_type}{Style.RESET_ALL}",+ f"{Fore.WHITE}{confidence}%{Style.RESET_ALL}",+ f"{Fore.WHITE}{reasoning_str}{Style.RESET_ALL}",+ ]+ )++ # Sort the signals according to the predefined order+ table_data = sort_agent_signals(table_data)++ print(f"\n{Fore.WHITE}{Style.BRIGHT}AGENT ANALYSIS:{Style.RESET_ALL} [{Fore.CYAN}{ticker}{Style.RESET_ALL}]")+ print(+ tabulate(+ table_data,+ headers=[f"{Fore.WHITE}Agent", "Signal", "Confidence", "Reasoning"],+ tablefmt="grid",+ colalign=("left", "center", "right", "left"),+ )+ )++ # Print Trading Decision Table+ action = decision.get("action", "").upper()+ action_color = {+ "BUY": Fore.GREEN,+ "SELL": Fore.RED,+ "HOLD": Fore.YELLOW,+ "COVER": Fore.GREEN,+ "SHORT": Fore.RED,+ }.get(action, Fore.WHITE)++ # Get reasoning and format it+ reasoning = decision.get("reasoning", "")+ # Wrap long reasoning text to make it more readable+ wrapped_reasoning = ""+ if reasoning:+ current_line = ""+ # Use a fixed width of 60 characters to match the table column width+ max_line_length = 60+ for word in reasoning.split():+ if len(current_line) + len(word) + 1 > max_line_length:+ wrapped_reasoning += current_line + "\n"+ current_line = word+ else:+ if current_line:+ current_line += " " + word+ else:+ current_line = word+ if current_line:+ wrapped_reasoning += current_line++ decision_data = [+ ["Action", f"{action_color}{action}{Style.RESET_ALL}"],+ ["Quantity", f"{action_color}{decision.get('quantity')}{Style.RESET_ALL}"],+ [+ "Confidence",+ f"{Fore.WHITE}{decision.get('confidence'):.1f}%{Style.RESET_ALL}",+ ],+ ["Reasoning", f"{Fore.WHITE}{wrapped_reasoning}{Style.RESET_ALL}"],+ ]++ print(f"\n{Fore.WHITE}{Style.BRIGHT}TRADING DECISION:{Style.RESET_ALL} [{Fore.CYAN}{ticker}{Style.RESET_ALL}]")+ print(tabulate(decision_data, tablefmt="grid", colalign=("left", "left")))++ # Print Portfolio Summary+ print(f"\n{Fore.WHITE}{Style.BRIGHT}PORTFOLIO SUMMARY:{Style.RESET_ALL}")+ portfolio_data = []++ # Extract portfolio manager reasoning (common for all tickers)+ portfolio_manager_reasoning = None+ for ticker, decision in decisions.items():+ if decision.get("reasoning"):+ portfolio_manager_reasoning = decision.get("reasoning")+ break++ for ticker, decision in decisions.items():+ action = decision.get("action", "").upper()+ action_color = {+ "BUY": Fore.GREEN,+ "SELL": Fore.RED,+ "HOLD": Fore.YELLOW,+ "COVER": Fore.GREEN,+ "SHORT": Fore.RED,+ }.get(action, Fore.WHITE)+ portfolio_data.append(+ [+ f"{Fore.CYAN}{ticker}{Style.RESET_ALL}",+ f"{action_color}{action}{Style.RESET_ALL}",+ f"{action_color}{decision.get('quantity')}{Style.RESET_ALL}",+ f"{Fore.WHITE}{decision.get('confidence'):.1f}%{Style.RESET_ALL}",+ ]+ )++ headers = [f"{Fore.WHITE}Ticker", "Action", "Quantity", "Confidence"]++ # Print the portfolio summary table+ print(+ tabulate(+ portfolio_data,+ headers=headers,+ tablefmt="grid",+ colalign=("left", "center", "right", "right"),+ )+ )++ # Print Portfolio Manager's reasoning if available+ if portfolio_manager_reasoning:+ # Handle different types of reasoning (string, dict, etc.)+ reasoning_str = ""+ if isinstance(portfolio_manager_reasoning, str):+ reasoning_str = portfolio_manager_reasoning+ elif isinstance(portfolio_manager_reasoning, dict):+ # Convert dict to string representation+ reasoning_str = json.dumps(portfolio_manager_reasoning, indent=2)+ else:+ # Convert any other type to string+ reasoning_str = str(portfolio_manager_reasoning)++ # Wrap long reasoning text to make it more readable+ wrapped_reasoning = ""+ current_line = ""+ # Use a fixed width of 60 characters to match the table column width+ max_line_length = 60+ for word in reasoning_str.split():+ if len(current_line) + len(word) + 1 > max_line_length:+ wrapped_reasoning += current_line + "\n"+ current_line = word+ else:+ if current_line:+ current_line += " " + word+ else:+ current_line = word+ if current_line:+ wrapped_reasoning += current_line++ print(f"\n{Fore.WHITE}{Style.BRIGHT}Portfolio Strategy:{Style.RESET_ALL}")+ print(f"{Fore.CYAN}{wrapped_reasoning}{Style.RESET_ALL}")+++def print_backtest_results(table_rows: list) -> None:+ """Print the backtest results in a nicely formatted table"""+ # Clear the screen+ os.system("cls" if os.name == "nt" else "clear")++ # Split rows into ticker rows and summary rows+ ticker_rows = []+ summary_rows = []++ for row in table_rows:+ if isinstance(row[1], str) and "PORTFOLIO SUMMARY" in row[1]:+ summary_rows.append(row)+ else:+ ticker_rows.append(row)++ # Display latest portfolio summary+ if summary_rows:+ # Pick the most recent summary by date (YYYY-MM-DD)+ latest_summary = max(summary_rows, key=lambda r: r[0])+ print(f"\n{Fore.WHITE}{Style.BRIGHT}PORTFOLIO SUMMARY:{Style.RESET_ALL}")++ # Adjusted indexes after adding Long/Short Shares+ position_str = latest_summary[7].split("$")[1].split(Style.RESET_ALL)[0].replace(",", "")+ cash_str = latest_summary[8].split("$")[1].split(Style.RESET_ALL)[0].replace(",", "")+ total_str = latest_summary[9].split("$")[1].split(Style.RESET_ALL)[0].replace(",", "")++ print(f"Cash Balance: {Fore.CYAN}${float(cash_str):,.2f}{Style.RESET_ALL}")+ print(f"Total Position Value: {Fore.YELLOW}${float(position_str):,.2f}{Style.RESET_ALL}")+ print(f"Total Value: {Fore.WHITE}${float(total_str):,.2f}{Style.RESET_ALL}")+ print(f"Return: {latest_summary[10]}")++ # Display performance metrics if available+ if latest_summary[11]: # Sharpe ratio+ print(f"Sharpe Ratio: {latest_summary[11]}")+ if latest_summary[12]: # Sortino ratio+ print(f"Sortino Ratio: {latest_summary[12]}")+ if latest_summary[13]: # Max drawdown+ print(f"Max Drawdown: {latest_summary[13]}")++ # Add vertical spacing+ print("\n" * 2)++ # Print the table with just ticker rows+ print(+ tabulate(+ ticker_rows,+ headers=[+ "Date",+ "Ticker",+ "Action",+ "Quantity",+ "Price",+ "Long Shares",+ "Short Shares",+ "Position Value",+ "Bullish",+ "Bearish",+ "Neutral",+ ],+ tablefmt="grid",+ colalign=(+ "left", # Date+ "left", # Ticker+ "center", # Action+ "right", # Quantity+ "right", # Price+ "right", # Long Shares+ "right", # Short Shares+ "right", # Position Value+ "right", # Bullish+ "right", # Bearish+ "right", # Neutral+ ),+ )+ )++ # Add vertical spacing+ print("\n" * 4)+++def format_backtest_row(+ date: str,+ ticker: str,+ action: str,+ quantity: float,+ price: float,+ long_shares: float = 0,+ short_shares: float = 0,+ position_value: float = 0,+ bullish_count: int = 0,+ bearish_count: int = 0,+ neutral_count: int = 0,+ is_summary: bool = False,+ total_value: float = None,+ return_pct: float = None,+ cash_balance: float = None,+ total_position_value: float = None,+ sharpe_ratio: float = None,+ sortino_ratio: float = None,+ max_drawdown: float = None,+) -> list[any]:+ """Format a row for the backtest results table"""+ # Color the action+ action_color = {+ "BUY": Fore.GREEN,+ "COVER": Fore.GREEN,+ "SELL": Fore.RED,+ "SHORT": Fore.RED,+ "HOLD": Fore.WHITE,+ }.get(action.upper(), Fore.WHITE)++ if is_summary:+ return_color = Fore.GREEN if return_pct >= 0 else Fore.RED+ return [+ date,+ f"{Fore.WHITE}{Style.BRIGHT}PORTFOLIO SUMMARY{Style.RESET_ALL}",+ "", # Action+ "", # Quantity+ "", # Price+ "", # Long Shares+ "", # Short Shares+ f"{Fore.YELLOW}${total_position_value:,.2f}{Style.RESET_ALL}", # Total Position Value+ f"{Fore.CYAN}${cash_balance:,.2f}{Style.RESET_ALL}", # Cash Balance+ f"{Fore.WHITE}${total_value:,.2f}{Style.RESET_ALL}", # Total Value+ f"{return_color}{return_pct:+.2f}%{Style.RESET_ALL}", # Return+ f"{Fore.YELLOW}{sharpe_ratio:.2f}{Style.RESET_ALL}" if sharpe_ratio is not None else "", # Sharpe Ratio+ f"{Fore.YELLOW}{sortino_ratio:.2f}{Style.RESET_ALL}" if sortino_ratio is not None else "", # Sortino Ratio+ f"{Fore.RED}{abs(max_drawdown):.2f}%{Style.RESET_ALL}" if max_drawdown is not None else "", # Max Drawdown+ ]+ else:+ return [+ date,+ f"{Fore.CYAN}{ticker}{Style.RESET_ALL}",+ f"{action_color}{action.upper()}{Style.RESET_ALL}",+ f"{action_color}{quantity:,.0f}{Style.RESET_ALL}",+ f"{Fore.WHITE}{price:,.2f}{Style.RESET_ALL}",+ f"{Fore.GREEN}{long_shares:,.0f}{Style.RESET_ALL}", # Long Shares+ f"{Fore.RED}{short_shares:,.0f}{Style.RESET_ALL}", # Short Shares+ f"{Fore.YELLOW}{position_value:,.2f}{Style.RESET_ALL}",+ f"{Fore.GREEN}{bullish_count}{Style.RESET_ALL}",+ f"{Fore.RED}{bearish_count}{Style.RESET_ALL}",+ f"{Fore.BLUE}{neutral_count}{Style.RESET_ALL}",+ ]diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/docker.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/docker.pynew file mode 100644index 000000000..d638f5499--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/docker.py@@ -0,0 +1,124 @@+"""Utilities for working with Ollama models in Docker environments"""++import requests+import time+from colorama import Fore, Style+import questionary++def ensure_ollama_and_model(model_name: str, ollama_url: str) -> bool:+ """Ensure the Ollama model is available in a Docker environment."""+ print(f"{Fore.CYAN}Docker environment detected.{Style.RESET_ALL}")++ # Step 1: Check if Ollama service is available+ if not is_ollama_available(ollama_url):+ return False++ # Step 2: Check if model is already available+ available_models = get_available_models(ollama_url)+ if model_name in available_models:+ print(f"{Fore.GREEN}Model {model_name} is available in the Docker Ollama container.{Style.RESET_ALL}")+ return True++ # Step 3: Model not available - ask if user wants to download+ print(f"{Fore.YELLOW}Model {model_name} is not available in the Docker Ollama container.{Style.RESET_ALL}")++ if not questionary.confirm(f"Do you want to download {model_name}?").ask():+ print(f"{Fore.RED}Cannot proceed without the model.{Style.RESET_ALL}")+ return False++ # Step 4: Download the model+ return download_model(model_name, ollama_url)+++def is_ollama_available(ollama_url: str) -> bool:+ """Check if Ollama service is available in Docker environment."""+ try:+ response = requests.get(f"{ollama_url}/api/version", timeout=5)+ if response.status_code == 200:+ return True++ print(f"{Fore.RED}Cannot connect to Ollama service at {ollama_url}.{Style.RESET_ALL}")+ print(f"{Fore.YELLOW}Make sure the Ollama service is running in your Docker environment.{Style.RESET_ALL}")+ return False+ except requests.RequestException as e:+ print(f"{Fore.RED}Error connecting to Ollama service: {e}{Style.RESET_ALL}")+ return False+++def get_available_models(ollama_url: str) -> list:+ """Get list of available models in Docker environment."""+ try:+ response = requests.get(f"{ollama_url}/api/tags", timeout=5)+ if response.status_code == 200:+ models = response.json().get("models", [])+ return [m["name"] for m in models]++ print(f"{Fore.RED}Failed to get available models from Ollama service. Status code: {response.status_code}{Style.RESET_ALL}")+ return []+ except requests.RequestException as e:+ print(f"{Fore.RED}Error getting available models: {e}{Style.RESET_ALL}")+ return []+++def download_model(model_name: str, ollama_url: str) -> bool:+ """Download a model in Docker environment."""+ print(f"{Fore.YELLOW}Downloading model {model_name} to the Docker Ollama container...{Style.RESET_ALL}")+ print(f"{Fore.CYAN}This may take some time. Please be patient.{Style.RESET_ALL}")++ # Step 1: Initiate the download+ try:+ response = requests.post(f"{ollama_url}/api/pull", json={"name": model_name}, timeout=10)+ if response.status_code != 200:+ print(f"{Fore.RED}Failed to initiate model download. Status code: {response.status_code}{Style.RESET_ALL}")+ if response.text:+ print(f"{Fore.RED}Error: {response.text}{Style.RESET_ALL}")+ return False+ except requests.RequestException as e:+ print(f"{Fore.RED}Error initiating download request: {e}{Style.RESET_ALL}")+ return False++ # Step 2: Monitor the download progress+ print(f"{Fore.CYAN}Download initiated. Checking periodically for completion...{Style.RESET_ALL}")++ total_wait_time = 0+ max_wait_time = 1800 # 30 minutes max wait+ check_interval = 10 # Check every 10 seconds++ while total_wait_time < max_wait_time:+ # Check if the model has been downloaded+ available_models = get_available_models(ollama_url)+ if model_name in available_models:+ print(f"{Fore.GREEN}Model {model_name} downloaded successfully.{Style.RESET_ALL}")+ return True++ # Wait before checking again+ time.sleep(check_interval)+ total_wait_time += check_interval++ # Print a status message every minute+ if total_wait_time % 60 == 0:+ minutes = total_wait_time // 60+ print(f"{Fore.CYAN}Download in progress... ({minutes} minute{'s' if minutes != 1 else ''} elapsed){Style.RESET_ALL}")++ # If we get here, we've timed out+ print(f"{Fore.RED}Timed out waiting for model download to complete after {max_wait_time // 60} minutes.{Style.RESET_ALL}")+ return False+++def delete_model(model_name: str, ollama_url: str) -> bool:+ """Delete a model in Docker environment."""+ print(f"{Fore.YELLOW}Deleting model {model_name} from Docker container...{Style.RESET_ALL}")++ try:+ response = requests.delete(f"{ollama_url}/api/delete", json={"name": model_name}, timeout=10)+ if response.status_code == 200:+ print(f"{Fore.GREEN}Model {model_name} deleted successfully.{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Failed to delete model. Status code: {response.status_code}{Style.RESET_ALL}")+ if response.text:+ print(f"{Fore.RED}Error: {response.text}{Style.RESET_ALL}")+ return False+ except requests.RequestException as e:+ print(f"{Fore.RED}Error deleting model: {e}{Style.RESET_ALL}")+ return False\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/llm.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/llm.pynew file mode 100644index 000000000..c7535d5d2--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/llm.py@@ -0,0 +1,147 @@+"""Helper functions for LLM"""++import json+from pydantic import BaseModel+from src.llm.models import get_model, get_model_info+from src.utils.progress import progress+from src.graph.state import AgentState+++def call_llm(+ prompt: any,+ pydantic_model: type[BaseModel],+ agent_name: str | None = None,+ state: AgentState | None = None,+ max_retries: int = 3,+ default_factory=None,+) -> BaseModel:+ """+ Makes an LLM call with retry logic, handling both JSON supported and non-JSON supported models.++ Args:+ prompt: The prompt to send to the LLM+ pydantic_model: The Pydantic model class to structure the output+ agent_name: Optional name of the agent for progress updates and model config extraction+ state: Optional state object to extract agent-specific model configuration+ max_retries: Maximum number of retries (default: 3)+ default_factory: Optional factory function to create default response on failure++ Returns:+ An instance of the specified Pydantic model+ """++ # Extract model configuration if state is provided and agent_name is available+ if state and agent_name:+ model_name, model_provider = get_agent_model_config(state, agent_name)+ else:+ # Use system defaults when no state or agent_name is provided+ model_name = "gpt-4.1"+ model_provider = "OPENAI"++ # Extract API keys from state if available+ api_keys = None+ if state:+ request = state.get("metadata", {}).get("request")+ if request and hasattr(request, 'api_keys'):+ api_keys = request.api_keys++ model_info = get_model_info(model_name, model_provider)+ llm = get_model(model_name, model_provider, api_keys)++ # For non-JSON support models, we can use structured output+ if not (model_info and not model_info.has_json_mode()):+ llm = llm.with_structured_output(+ pydantic_model,+ method="json_mode",+ )++ # Call the LLM with retries+ for attempt in range(max_retries):+ try:+ # Call the LLM+ result = llm.invoke(prompt)++ # For non-JSON support models, we need to extract and parse the JSON manually+ if model_info and not model_info.has_json_mode():+ parsed_result = extract_json_from_response(result.content)+ if parsed_result:+ return pydantic_model(**parsed_result)+ else:+ return result++ except Exception as e:+ if agent_name:+ progress.update_status(agent_name, None, f"Error - retry {attempt + 1}/{max_retries}")++ if attempt == max_retries - 1:+ print(f"Error in LLM call after {max_retries} attempts: {e}")+ # Use default_factory if provided, otherwise create a basic default+ if default_factory:+ return default_factory()+ return create_default_response(pydantic_model)++ # This should never be reached due to the retry logic above+ return create_default_response(pydantic_model)+++def create_default_response(model_class: type[BaseModel]) -> BaseModel:+ """Creates a safe default response based on the model's fields."""+ default_values = {}+ for field_name, field in model_class.model_fields.items():+ if field.annotation == str:+ default_values[field_name] = "Error in analysis, using default"+ elif field.annotation == float:+ default_values[field_name] = 0.0+ elif field.annotation == int:+ default_values[field_name] = 0+ elif hasattr(field.annotation, "__origin__") and field.annotation.__origin__ == dict:+ default_values[field_name] = {}+ else:+ # For other types (like Literal), try to use the first allowed value+ if hasattr(field.annotation, "__args__"):+ default_values[field_name] = field.annotation.__args__[0]+ else:+ default_values[field_name] = None++ return model_class(**default_values)+++def extract_json_from_response(content: str) -> dict | None:+ """Extracts JSON from markdown-formatted response."""+ try:+ json_start = content.find("```json")+ if json_start != -1:+ json_text = content[json_start + 7 :] # Skip past ```json+ json_end = json_text.find("```")+ if json_end != -1:+ json_text = json_text[:json_end].strip()+ return json.loads(json_text)+ except Exception as e:+ print(f"Error extracting JSON from response: {e}")+ return None+++def get_agent_model_config(state, agent_name):+ """+ Get model configuration for a specific agent from the state.+ Falls back to global model configuration if agent-specific config is not available.+ Always returns valid model_name and model_provider values.+ """+ request = state.get("metadata", {}).get("request")++ if request and hasattr(request, 'get_agent_model_config'):+ # Get agent-specific model configuration+ model_name, model_provider = request.get_agent_model_config(agent_name)+ # Ensure we have valid values+ if model_name and model_provider:+ return model_name, model_provider.value if hasattr(model_provider, 'value') else str(model_provider)++ # Fall back to global configuration (system defaults)+ model_name = state.get("metadata", {}).get("model_name") or "gpt-4.1"+ model_provider = state.get("metadata", {}).get("model_provider") or "OPENAI"++ # Convert enum to string if necessary+ if hasattr(model_provider, 'value'):+ model_provider = model_provider.value++ return model_name, model_providerdiff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/ollama.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/ollama.pynew file mode 100644index 000000000..5af70ee44--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/ollama.py@@ -0,0 +1,389 @@+"""Utilities for working with Ollama models"""++import platform+import subprocess+import requests+import time+from typing import List+import questionary+from colorama import Fore, Style+import os+from . import docker++# Constants+OLLAMA_SERVER_URL = "http://localhost:11434"+OLLAMA_API_MODELS_ENDPOINT = f"{OLLAMA_SERVER_URL}/api/tags"+OLLAMA_DOWNLOAD_URL = {"darwin": "https://ollama.com/download/darwin", "windows": "https://ollama.com/download/windows", "linux": "https://ollama.com/download/linux"} # macOS # Windows # Linux+INSTALLATION_INSTRUCTIONS = {"darwin": "curl -fsSL https://ollama.com/install.sh | sh", "windows": "# Download from https://ollama.com/download/windows and run the installer", "linux": "curl -fsSL https://ollama.com/install.sh | sh"}+++def is_ollama_installed() -> bool:+ """Check if Ollama is installed on the system."""+ system = platform.system().lower()++ if system == "darwin" or system == "linux": # macOS or Linux+ try:+ result = subprocess.run(["which", "ollama"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)+ return result.returncode == 0+ except Exception:+ return False+ elif system == "windows": # Windows+ try:+ result = subprocess.run(["where", "ollama"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)+ return result.returncode == 0+ except Exception:+ return False+ else:+ return False # Unsupported OS+++def is_ollama_server_running() -> bool:+ """Check if the Ollama server is running."""+ try:+ response = requests.get(OLLAMA_API_MODELS_ENDPOINT, timeout=2)+ return response.status_code == 200+ except requests.RequestException:+ return False+++def get_locally_available_models() -> List[str]:+ """Get a list of models that are already downloaded locally."""+ if not is_ollama_server_running():+ return []++ try:+ response = requests.get(OLLAMA_API_MODELS_ENDPOINT, timeout=5)+ if response.status_code == 200:+ data = response.json()+ return [model["name"] for model in data["models"]] if "models" in data else []+ return []+ except requests.RequestException:+ return []+++def start_ollama_server() -> bool:+ """Start the Ollama server if it's not already running."""+ if is_ollama_server_running():+ print(f"{Fore.GREEN}Ollama server is already running.{Style.RESET_ALL}")+ return True++ system = platform.system().lower()++ try:+ if system == "darwin" or system == "linux": # macOS or Linux+ subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)+ elif system == "windows": # Windows+ subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)+ else:+ print(f"{Fore.RED}Unsupported operating system: {system}{Style.RESET_ALL}")+ return False++ # Wait for server to start+ for _ in range(10): # Try for 10 seconds+ if is_ollama_server_running():+ print(f"{Fore.GREEN}Ollama server started successfully.{Style.RESET_ALL}")+ return True+ time.sleep(1)++ print(f"{Fore.RED}Failed to start Ollama server. Timed out waiting for server to become available.{Style.RESET_ALL}")+ return False+ except Exception as e:+ print(f"{Fore.RED}Error starting Ollama server: {e}{Style.RESET_ALL}")+ return False+++def install_ollama() -> bool:+ """Install Ollama on the system."""+ system = platform.system().lower()+ if system not in OLLAMA_DOWNLOAD_URL:+ print(f"{Fore.RED}Unsupported operating system for automatic installation: {system}{Style.RESET_ALL}")+ print(f"Please visit https://ollama.com/download to install Ollama manually.")+ return False++ if system == "darwin": # macOS+ print(f"{Fore.YELLOW}Ollama for Mac is available as an application download.{Style.RESET_ALL}")++ # Default to offering the app download first for macOS users+ if questionary.confirm("Would you like to download the Ollama application?", default=True).ask():+ try:+ import webbrowser++ webbrowser.open(OLLAMA_DOWNLOAD_URL["darwin"])+ print(f"{Fore.YELLOW}Please download and install the application, then restart this program.{Style.RESET_ALL}")+ print(f"{Fore.CYAN}After installation, you may need to open the Ollama app once before continuing.{Style.RESET_ALL}")++ # Ask if they want to try continuing after installation+ if questionary.confirm("Have you installed the Ollama app and opened it at least once?", default=False).ask():+ # Check if it's now installed+ if is_ollama_installed() and start_ollama_server():+ print(f"{Fore.GREEN}Ollama is now properly installed and running!{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Ollama installation not detected. Please restart this application after installing Ollama.{Style.RESET_ALL}")+ return False+ return False+ except Exception as e:+ print(f"{Fore.RED}Failed to open browser: {e}{Style.RESET_ALL}")+ return False+ else:+ # Only offer command-line installation as a fallback for advanced users+ if questionary.confirm("Would you like to try the command-line installation instead? (For advanced users)", default=False).ask():+ print(f"{Fore.YELLOW}Attempting command-line installation...{Style.RESET_ALL}")+ try:+ install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)++ if install_process.returncode == 0:+ print(f"{Fore.GREEN}Ollama installed successfully via command line.{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Command-line installation failed. Please use the app download method instead.{Style.RESET_ALL}")+ return False+ except Exception as e:+ print(f"{Fore.RED}Error during command-line installation: {e}{Style.RESET_ALL}")+ return False+ return False+ elif system == "linux": # Linux+ print(f"{Fore.YELLOW}Installing Ollama...{Style.RESET_ALL}")+ try:+ # Run the installation command as a single command+ install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)++ if install_process.returncode == 0:+ print(f"{Fore.GREEN}Ollama installed successfully.{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Failed to install Ollama. Error: {install_process.stderr}{Style.RESET_ALL}")+ return False+ except Exception as e:+ print(f"{Fore.RED}Error during Ollama installation: {e}{Style.RESET_ALL}")+ return False+ elif system == "windows": # Windows+ print(f"{Fore.YELLOW}Automatic installation on Windows is not supported.{Style.RESET_ALL}")+ print(f"Please download and install Ollama from: {OLLAMA_DOWNLOAD_URL['windows']}")++ # Ask if they want to open the download page+ if questionary.confirm("Do you want to open the Ollama download page in your browser?").ask():+ try:+ import webbrowser++ webbrowser.open(OLLAMA_DOWNLOAD_URL["windows"])+ print(f"{Fore.YELLOW}After installation, please restart this application.{Style.RESET_ALL}")++ # Ask if they want to try continuing after installation+ if questionary.confirm("Have you installed Ollama?", default=False).ask():+ # Check if it's now installed+ if is_ollama_installed() and start_ollama_server():+ print(f"{Fore.GREEN}Ollama is now properly installed and running!{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Ollama installation not detected. Please restart this application after installing Ollama.{Style.RESET_ALL}")+ return False+ except Exception as e:+ print(f"{Fore.RED}Failed to open browser: {e}{Style.RESET_ALL}")+ return False++ return False+++def download_model(model_name: str) -> bool:+ """Download an Ollama model."""+ if not is_ollama_server_running():+ if not start_ollama_server():+ return False++ print(f"{Fore.YELLOW}Downloading model {model_name}...{Style.RESET_ALL}")+ print(f"{Fore.CYAN}This may take a while depending on your internet speed and the model size.{Style.RESET_ALL}")+ print(f"{Fore.CYAN}The download is happening in the background. Please be patient...{Style.RESET_ALL}")++ try:+ # Use the Ollama CLI to download the model+ process = subprocess.Popen(+ ["ollama", "pull", model_name],+ stdout=subprocess.PIPE,+ stderr=subprocess.STDOUT, # Redirect stderr to stdout to capture all output+ text=True,+ bufsize=1, # Line buffered+ encoding='utf-8', # Explicitly use UTF-8 encoding+ errors='replace' # Replace any characters that cannot be decoded+ )++ # Show some progress to the user+ print(f"{Fore.CYAN}Download progress:{Style.RESET_ALL}")++ # For tracking progress+ last_percentage = 0+ last_phase = ""+ bar_length = 40++ while True:+ output = process.stdout.readline()+ if output == "" and process.poll() is not None:+ break+ if output:+ output = output.strip()+ # Try to extract percentage information using a more lenient approach+ percentage = None+ current_phase = None++ # Example patterns in Ollama output:+ # "downloading: 23.45 MB / 42.19 MB [================>-------------] 55.59%"+ # "downloading model: 76%"+ # "pulling manifest: 100%"++ # Check for percentage in the output+ import re++ percentage_match = re.search(r"(\d+(\.\d+)?)%", output)+ if percentage_match:+ try:+ percentage = float(percentage_match.group(1))+ except ValueError:+ percentage = None++ # Try to determine the current phase (downloading, extracting, etc.)+ phase_match = re.search(r"^([a-zA-Z\s]+):", output)+ if phase_match:+ current_phase = phase_match.group(1).strip()++ # If we found a percentage, display a progress bar+ if percentage is not None:+ # Only update if there's a significant change (avoid flickering)+ if abs(percentage - last_percentage) >= 1 or (current_phase and current_phase != last_phase):+ last_percentage = percentage+ if current_phase:+ last_phase = current_phase++ # Create a progress bar+ filled_length = int(bar_length * percentage / 100)+ bar = "█" * filled_length + "░" * (bar_length - filled_length)++ # Build the status line with the phase if available+ phase_display = f"{Fore.CYAN}{last_phase.capitalize()}{Style.RESET_ALL}: " if last_phase else ""+ status_line = f"\r{phase_display}{Fore.GREEN}{bar}{Style.RESET_ALL} {Fore.YELLOW}{percentage:.1f}%{Style.RESET_ALL}"++ # Print the status line without a newline to update in place+ print(status_line, end="", flush=True)+ else:+ # If we couldn't extract a percentage but have identifiable output+ if "download" in output.lower() or "extract" in output.lower() or "pulling" in output.lower():+ # Don't print a newline for percentage updates+ if "%" in output:+ print(f"\r{Fore.GREEN}{output}{Style.RESET_ALL}", end="", flush=True)+ else:+ print(f"{Fore.GREEN}{output}{Style.RESET_ALL}")++ # Wait for the process to finish+ return_code = process.wait()++ # Ensure we print a newline after the progress bar+ print()++ if return_code == 0:+ print(f"{Fore.GREEN}Model {model_name} downloaded successfully!{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Failed to download model {model_name}. Check your internet connection and try again.{Style.RESET_ALL}")+ return False+ except Exception as e:+ print(f"\n{Fore.RED}Error downloading model {model_name}: {e}{Style.RESET_ALL}")+ return False+++def ensure_ollama_and_model(model_name: str) -> bool:+ """Ensure Ollama is installed, running, and the requested model is available."""+ # Check if we're running in Docker+ in_docker = os.environ.get("OLLAMA_BASE_URL", "").startswith("http://ollama:") or os.environ.get("OLLAMA_BASE_URL", "").startswith("http://host.docker.internal:")++ # In Docker environment, we need a different approach+ if in_docker:+ ollama_url = os.environ.get("OLLAMA_BASE_URL", "http://ollama:11434")+ return docker.ensure_ollama_and_model(model_name, ollama_url)++ # Regular flow for non-Docker environments+ # Check if Ollama is installed+ if not is_ollama_installed():+ print(f"{Fore.YELLOW}Ollama is not installed on your system.{Style.RESET_ALL}")++ # Ask if they want to install it+ if questionary.confirm("Do you want to install Ollama?").ask():+ if not install_ollama():+ return False+ else:+ print(f"{Fore.RED}Ollama is required to use local models.{Style.RESET_ALL}")+ return False++ # Make sure the server is running+ if not is_ollama_server_running():+ print(f"{Fore.YELLOW}Starting Ollama server...{Style.RESET_ALL}")+ if not start_ollama_server():+ return False++ # Check if the model is already downloaded+ available_models = get_locally_available_models()+ if model_name not in available_models:+ print(f"{Fore.YELLOW}Model {model_name} is not available locally.{Style.RESET_ALL}")++ # Ask if they want to download it+ model_size_info = ""+ if "70b" in model_name:+ model_size_info = " This is a large model (up to several GB) and may take a while to download."+ elif "34b" in model_name or "8x7b" in model_name:+ model_size_info = " This is a medium-sized model (1-2 GB) and may take a few minutes to download."++ if questionary.confirm(f"Do you want to download the {model_name} model?{model_size_info} The download will happen in the background.").ask():+ return download_model(model_name)+ else:+ print(f"{Fore.RED}The model is required to proceed.{Style.RESET_ALL}")+ return False++ return True+++def delete_model(model_name: str) -> bool:+ """Delete a locally downloaded Ollama model."""+ # Check if we're running in Docker+ in_docker = os.environ.get("OLLAMA_BASE_URL", "").startswith("http://ollama:") or os.environ.get("OLLAMA_BASE_URL", "").startswith("http://host.docker.internal:")++ # In Docker environment, delegate to docker module+ if in_docker:+ ollama_url = os.environ.get("OLLAMA_BASE_URL", "http://ollama:11434")+ return docker.delete_model(model_name, ollama_url)++ # Non-Docker environment+ if not is_ollama_server_running():+ if not start_ollama_server():+ return False++ print(f"{Fore.YELLOW}Deleting model {model_name}...{Style.RESET_ALL}")++ try:+ # Use the Ollama CLI to delete the model+ process = subprocess.run(["ollama", "rm", model_name], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)++ if process.returncode == 0:+ print(f"{Fore.GREEN}Model {model_name} deleted successfully.{Style.RESET_ALL}")+ return True+ else:+ print(f"{Fore.RED}Failed to delete model {model_name}. Error: {process.stderr}{Style.RESET_ALL}")+ return False+ except Exception as e:+ print(f"{Fore.RED}Error deleting model {model_name}: {e}{Style.RESET_ALL}")+ return False+++# Add this at the end of the file for command-line usage+if __name__ == "__main__":+ import sys+ import argparse++ parser = argparse.ArgumentParser(description="Ollama model manager")+ parser.add_argument("--check-model", help="Check if model exists and download if needed")+ args = parser.parse_args()++ if args.check_model:+ print(f"Ensuring Ollama is installed and model {args.check_model} is available...")+ result = ensure_ollama_and_model(args.check_model)+ sys.exit(0 if result else 1)+ else:+ print("No action specified. Use --check-model to check if a model exists.")+ sys.exit(1)diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/progress.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/progress.pynew file mode 100644index 000000000..0c709d16f--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/progress.py@@ -0,0 +1,116 @@+from datetime import datetime, timezone+from rich.console import Console+from rich.live import Live+from rich.table import Table+from rich.style import Style+from rich.text import Text+from typing import Dict, Optional, Callable, List++console = Console()+++class AgentProgress:+ """Manages progress tracking for multiple agents."""++ def __init__(self):+ self.agent_status: Dict[str, Dict[str, str]] = {}+ self.table = Table(show_header=False, box=None, padding=(0, 1))+ self.live = Live(self.table, console=console, refresh_per_second=4)+ self.started = False+ self.update_handlers: List[Callable[[str, Optional[str], str], None]] = []++ def register_handler(self, handler: Callable[[str, Optional[str], str], None]):+ """Register a handler to be called when agent status updates."""+ self.update_handlers.append(handler)+ return handler # Return handler to support use as decorator++ def unregister_handler(self, handler: Callable[[str, Optional[str], str], None]):+ """Unregister a previously registered handler."""+ if handler in self.update_handlers:+ self.update_handlers.remove(handler)++ def start(self):+ """Start the progress display."""+ if not self.started:+ self.live.start()+ self.started = True++ def stop(self):+ """Stop the progress display."""+ if self.started:+ self.live.stop()+ self.started = False++ def update_status(self, agent_name: str, ticker: Optional[str] = None, status: str = "", analysis: Optional[str] = None):+ """Update the status of an agent."""+ if agent_name not in self.agent_status:+ self.agent_status[agent_name] = {"status": "", "ticker": None}++ if ticker:+ self.agent_status[agent_name]["ticker"] = ticker+ if status:+ self.agent_status[agent_name]["status"] = status+ if analysis:+ self.agent_status[agent_name]["analysis"] = analysis++ # Set the timestamp as UTC datetime+ timestamp = datetime.now(timezone.utc).isoformat()+ self.agent_status[agent_name]["timestamp"] = timestamp++ # Notify all registered handlers+ for handler in self.update_handlers:+ handler(agent_name, ticker, status, analysis, timestamp)++ self._refresh_display()++ def get_all_status(self):+ """Get the current status of all agents as a dictionary."""+ return {agent_name: {"ticker": info["ticker"], "status": info["status"], "display_name": self._get_display_name(agent_name)} for agent_name, info in self.agent_status.items()}++ def _get_display_name(self, agent_name: str) -> str:+ """Convert agent_name to a display-friendly format."""+ return agent_name.replace("_agent", "").replace("_", " ").title()++ def _refresh_display(self):+ """Refresh the progress display."""+ self.table.columns.clear()+ self.table.add_column(width=100)++ # Sort agents with Risk Management and Portfolio Management at the bottom+ def sort_key(item):+ agent_name = item[0]+ if "risk_management" in agent_name:+ return (2, agent_name)+ elif "portfolio_management" in agent_name:+ return (3, agent_name)+ else:+ return (1, agent_name)++ for agent_name, info in sorted(self.agent_status.items(), key=sort_key):+ status = info["status"]+ ticker = info["ticker"]+ # Create the status text with appropriate styling+ if status.lower() == "done":+ style = Style(color="green", bold=True)+ symbol = "✓"+ elif status.lower() == "error":+ style = Style(color="red", bold=True)+ symbol = "✗"+ else:+ style = Style(color="yellow")+ symbol = "⋯"++ agent_display = self._get_display_name(agent_name)+ status_text = Text()+ status_text.append(f"{symbol} ", style=style)+ status_text.append(f"{agent_display:<20}", style=Style(bold=True))++ if ticker:+ status_text.append(f"[{ticker}] ", style=Style(color="cyan"))+ status_text.append(status, style=style)++ self.table.add_row(status_text)+++# Create a global instance+progress = AgentProgress()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/visualize.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/visualize.pynew file mode 100644index 000000000..3e498a31a--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/visualize.py@@ -0,0 +1,9 @@+from langgraph.graph.state import CompiledGraph+from langchain_core.runnables.graph import MermaidDrawMethod+++def save_graph_as_png(app: CompiledGraph, output_file_path) -> None:+ png_image = app.get_graph().draw_mermaid_png(draw_method=MermaidDrawMethod.API)+ file_path = output_file_path if len(output_file_path) > 0 else "graph.png"+ with open(file_path, "wb") as f:+ f.write(png_image)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/two_sigma_hedge_fund_agent/two_sigma_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/two_sigma_hedge_fund_agent/two_sigma_agent.pynew file mode 100644index 000000000..4123b3fba--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/two_sigma_hedge_fund_agent/two_sigma_agent.py@@ -0,0 +1,811 @@+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items+from langchain_core.prompts import ChatPromptTemplate+from langchain_core.messages import HumanMessage+from pydantic import BaseModel+import json+import math+from typing_extensions import Literal+from fincept_terminal.Agents.src.utils.progress import progress+from fincept_terminal.Agents.src.utils.llm import call_llm+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state+++class TwoSigmaSignal(BaseModel):+ signal: Literal["bullish", "bearish", "neutral"]+ confidence: float+ reasoning: str+ ml_model_predictions: dict+++def two_sigma_hedge_fund_agent(state: AgentState, agent_id: str = "two_sigma_hedge_fund_agent"):+ """+ Two Sigma: Machine learning, data science+ Structure: Data Science → ML Engineering → Risk Models → Portfolio Optimization → Scientific Decision+ Philosophy: Data-driven, machine learning, scientific approach, technology focus+ """+ data = state["data"]+ end_date = data["end_date"]+ tickers = data["tickers"]+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")+ analysis_data = {}+ two_sigma_analysis = {}++ for ticker in tickers:+ progress.update_status(agent_id, ticker, "Data science team feature engineering")++ metrics = get_financial_metrics(ticker, end_date, period="quarterly", limit=16, api_key=api_key)+ financial_line_items = search_line_items(+ ticker,+ [+ "revenue", "net_income", "free_cash_flow", "total_debt",+ "shareholders_equity", "operating_margin", "total_assets",+ "current_assets", "current_liabilities", "research_and_development"+ ],+ end_date,+ period="quarterly",+ limit=16,+ api_key=api_key,+ )+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)++ # Two Sigma's ML-driven analysis structure+ progress.update_status(agent_id, ticker, "Data science team analysis")+ data_science_team = data_science_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "ML engineering team models")+ ml_engineering_team = ml_engineering_team_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Risk modeling team analysis")+ risk_modeling_team = risk_modeling_team_analysis(metrics, financial_line_items)++ progress.update_status(agent_id, ticker, "Portfolio optimization analysis")+ portfolio_optimization = portfolio_optimization_analysis(metrics, financial_line_items, market_cap)++ progress.update_status(agent_id, ticker, "Scientific method synthesis")+ scientific_synthesis = scientific_method_synthesis(+ data_science_team, ml_engineering_team, risk_modeling_team, portfolio_optimization+ )++ # Two Sigma's ML-weighted scoring+ total_score = (+ ml_engineering_team["score"] * 0.35 ++ data_science_team["score"] * 0.25 ++ portfolio_optimization["score"] * 0.2 ++ risk_modeling_team["score"] * 0.2+ )++ # Two Sigma's scientific decision framework+ ml_confidence = ml_engineering_team.get("model_confidence", 0)+ if total_score >= 8.0 and ml_confidence > 0.75:+ signal = "bullish"+ elif total_score <= 3.5 or ml_confidence < 0.4:+ signal = "bearish"+ else:+ signal = "neutral"++ analysis_data[ticker] = {+ "signal": signal,+ "score": total_score,+ "data_science_team": data_science_team,+ "ml_engineering_team": ml_engineering_team,+ "risk_modeling_team": risk_modeling_team,+ "portfolio_optimization": portfolio_optimization,+ "scientific_synthesis": scientific_synthesis+ }++ two_sigma_output = generate_two_sigma_output(ticker, analysis_data, state, agent_id)++ two_sigma_analysis[ticker] = {+ "signal": two_sigma_output.signal,+ "confidence": two_sigma_output.confidence,+ "reasoning": two_sigma_output.reasoning,+ "ml_model_predictions": two_sigma_output.ml_model_predictions+ }++ progress.update_status(agent_id, ticker, "Done", analysis=two_sigma_output.reasoning)++ message = HumanMessage(content=json.dumps(two_sigma_analysis), name=agent_id)++ if state["metadata"]["show_reasoning"]:+ show_agent_reasoning(two_sigma_analysis, "Two Sigma")++ state["data"]["analyst_signals"][agent_id] = two_sigma_analysis+ progress.update_status(agent_id, None, "Done")++ return {"messages": [message], "data": state["data"]}+++def data_science_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Two Sigma's data science team feature engineering and analysis"""+ score = 0+ details = []+ features = {}++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No data for feature engineering"}++ # Feature engineering from financial data+ engineered_features = engineer_financial_features(metrics, financial_line_items)+ features.update(engineered_features)++ # Time series features+ time_series_features = extract_time_series_features(financial_line_items)+ features.update(time_series_features)++ # Cross-sectional features+ cross_sectional_features = create_cross_sectional_features(metrics, market_cap)+ features.update(cross_sectional_features)++ # Feature importance scoring+ if features.get("revenue_momentum", 0) > 0.6:+ score += 2+ details.append(f"Strong revenue momentum feature: {features['revenue_momentum']:.2f}")++ if features.get("margin_stability", 0) > 0.7:+ score += 2+ details.append(f"High margin stability: {features['margin_stability']:.2f}")++ if features.get("growth_quality", 0) > 0.6:+ score += 1.5+ details.append(f"Quality growth signals: {features['growth_quality']:.2f}")++ # Alternative data integration (simulated)+ alt_data_score = integrate_alternative_data_signals(features)+ score += alt_data_score+ if alt_data_score > 1:+ details.append(f"Positive alternative data signals: {alt_data_score:.1f}")++ # Feature interaction analysis+ interaction_score = analyze_feature_interactions(features)+ score += interaction_score+ details.append(f"Feature interaction score: {interaction_score:.2f}")++ return {+ "score": min(score, 10),+ "details": "; ".join(details),+ "features": features+ }+++def ml_engineering_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Two Sigma's ML engineering team model predictions"""+ score = 0+ details = []+ model_predictions = {}++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No ML data"}++ # Ensemble model predictions+ random_forest_pred = simulate_random_forest_prediction(metrics, financial_line_items)+ model_predictions["random_forest"] = random_forest_pred++ gradient_boosting_pred = simulate_gradient_boosting_prediction(metrics, financial_line_items)+ model_predictions["gradient_boosting"] = gradient_boosting_pred++ neural_network_pred = simulate_neural_network_prediction(metrics, financial_line_items)+ model_predictions["neural_network"] = neural_network_pred++ # Time series models+ lstm_pred = simulate_lstm_prediction(financial_line_items)+ model_predictions["lstm"] = lstm_pred++ # Ensemble prediction+ ensemble_prediction = calculate_ensemble_prediction(model_predictions)+ model_predictions["ensemble"] = ensemble_prediction++ # Model confidence calculation+ model_confidence = calculate_model_confidence(model_predictions)++ # Scoring based on ensemble prediction and confidence+ if ensemble_prediction > 0.6 and model_confidence > 0.7:+ score += 4+ details.append(f"Strong ensemble prediction: {ensemble_prediction:.2f} with high confidence")+ elif ensemble_prediction > 0.4:+ score += 2+ details.append(f"Positive ensemble prediction: {ensemble_prediction:.2f}")++ # Model agreement analysis+ model_agreement = calculate_model_agreement(model_predictions)+ if model_agreement > 0.8:+ score += 2+ details.append(f"High model agreement: {model_agreement:.2f}")+ elif model_agreement < 0.4:+ score -= 1+ details.append(f"Low model agreement: {model_agreement:.2f}")++ # Feature importance from models+ feature_importance = extract_feature_importance(model_predictions)+ if feature_importance.get("fundamental_strength", 0) > 0.7:+ score += 1+ details.append("Models emphasize fundamental strength")++ return {+ "score": min(score, 10),+ "details": "; ".join(details),+ "model_predictions": model_predictions,+ "model_confidence": model_confidence,+ "ensemble_prediction": ensemble_prediction+ }+++def risk_modeling_team_analysis(metrics: list, financial_line_items: list) -> dict:+ """Two Sigma's risk modeling team analysis"""+ score = 0+ details = []+ risk_metrics = {}++ if not metrics or not financial_line_items:+ return {"score": 0, "details": "No risk modeling data"}++ # Value-at-Risk modeling+ var_analysis = calculate_value_at_risk(financial_line_items)+ risk_metrics["var_95"] = var_analysis+ if var_analysis < 0.15: # 15% VaR+ score += 2+ details.append(f"Low VaR: {var_analysis:.1%}")++ # Expected shortfall+ expected_shortfall = calculate_expected_shortfall(financial_line_items)+ risk_metrics["expected_shortfall"] = expected_shortfall+ if expected_shortfall < 0.2:+ score += 1+ details.append(f"Limited tail risk: {expected_shortfall:.1%}")++ # Factor risk decomposition+ factor_risks = decompose_factor_risks_ml(metrics, financial_line_items)+ risk_metrics["factor_risks"] = factor_risks++ # Maximum diversification ratio+ diversification_ratio = calculate_diversification_benefits(financial_line_items)+ risk_metrics["diversification"] = diversification_ratio+ if diversification_ratio > 0.6:+ score += 1+ details.append(f"Good diversification benefits: {diversification_ratio:.2f}")++ # Regime-dependent risk modeling+ regime_risks = model_regime_dependent_risks(financial_line_items)+ risk_metrics["regime_risks"] = regime_risks++ # Stress testing results+ stress_test_results = conduct_ml_stress_tests(financial_line_items)+ risk_metrics["stress_tests"] = stress_test_results+ if stress_test_results.get("worst_case_scenario", 1) > 0.7:+ score += 2+ details.append("Passes ML stress test scenarios")++ return {+ "score": score,+ "details": "; ".join(details),+ "risk_metrics": risk_metrics+ }+++def portfolio_optimization_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:+ """Two Sigma's portfolio optimization analysis"""+ score = 0+ details = []++ if not metrics or not financial_line_items or not market_cap:+ return {"score": 0, "details": "No portfolio optimization data"}++ # Mean-variance optimization+ sharpe_ratio_estimate = estimate_sharpe_ratio(metrics, financial_line_items)+ if sharpe_ratio_estimate > 1.5:+ score += 3+ details.append(f"High estimated Sharpe ratio: {sharpe_ratio_estimate:.2f}")+ elif sharpe_ratio_estimate > 1.0:+ score += 2+ details.append(f"Good estimated Sharpe ratio: {sharpe_ratio_estimate:.2f}")++ # Risk budgeting analysis+ risk_contribution = calculate_risk_contribution(financial_line_items, market_cap)+ if risk_contribution < 0.1: # Low risk contribution+ score += 2+ details.append(f"Low portfolio risk contribution: {risk_contribution:.1%}")++ # Transaction cost optimization+ transaction_costs = optimize_transaction_costs(market_cap)+ if transaction_costs < 0.02:+ score += 1+ details.append(f"Low transaction costs: {transaction_costs:.2%}")++ # Alpha decay analysis+ alpha_persistence = analyze_alpha_persistence(financial_line_items)+ if alpha_persistence > 0.6:+ score += 2+ details.append(f"Persistent alpha signals: {alpha_persistence:.2f}")++ # Capacity constraints+ strategy_capacity = assess_strategy_capacity(market_cap)+ if strategy_capacity > 0.8:+ score += 1+ details.append("High strategy capacity for scaling")++ return {"score": score, "details": "; ".join(details)}+++def scientific_method_synthesis(data_science: dict, ml_engineering: dict,+ risk_modeling: dict, portfolio_optimization: dict) -> dict:+ """Two Sigma's scientific method synthesis"""+ details = []++ # Scientific hypothesis testing+ ml_confidence = ml_engineering.get("model_confidence", 0)+ ensemble_pred = ml_engineering.get("ensemble_prediction", 0.5)+ risk_score = risk_modeling["score"] / 10++ # Bayesian model averaging+ prior_belief = 0.5 # Neutral prior+ likelihood = ensemble_pred+ posterior = (likelihood * prior_belief) / ((likelihood * prior_belief) + ((1 - likelihood) * (1 - prior_belief)))++ # Scientific confidence intervals+ confidence_interval = calculate_prediction_confidence_interval(ml_engineering.get("model_predictions", {}))++ # Hypothesis strength+ if ml_confidence > 0.8 and abs(ensemble_pred - 0.5) > 0.2:+ hypothesis_strength = "Strong"+ details.append("Strong statistical evidence for directional prediction")+ elif ml_confidence > 0.6:+ hypothesis_strength = "Moderate"+ details.append("Moderate statistical evidence")+ else:+ hypothesis_strength = "Weak"+ details.append("Insufficient statistical evidence")++ # Scientific decision framework+ if hypothesis_strength == "Strong" and risk_score > 0.6:+ scientific_decision = "High conviction systematic position"+ elif hypothesis_strength == "Moderate":+ scientific_decision = "Moderate systematic position"+ else:+ scientific_decision = "Insufficient evidence for position"++ return {+ "scientific_decision": scientific_decision,+ "hypothesis_strength": hypothesis_strength,+ "posterior_probability": posterior,+ "confidence_interval": confidence_interval,+ "details": "; ".join(details)+ }+++# ML and Data Science Helper Functions+def engineer_financial_features(metrics: list, financial_line_items: list) -> dict:+ """Engineer features from financial data"""+ features = {}++ # Revenue momentum features+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ recent_momentum = (revenues[0] / revenues[1]) - 1+ historical_momentum = (revenues[1] / revenues[-1]) ** (1 / (len(revenues) - 2)) - 1+ features["revenue_momentum"] = recent_momentum - historical_momentum++ # Margin stability+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]+ if margins:+ margin_cv = calculate_coefficient_of_variation(margins)+ features["margin_stability"] = max(0, 1 - margin_cv)++ # Growth quality+ if metrics and len(revenues) >= 3:+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1+ roe = metrics[0].return_on_equity if metrics[0].return_on_equity else 0+ features["growth_quality"] = min(revenue_growth * roe * 10, 1.0)++ return features+++def extract_time_series_features(financial_line_items: list) -> dict:+ """Extract time series features"""+ features = {}++ # Trend analysis+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 6:+ trend_strength = calculate_trend_strength(revenues)+ features["trend_strength"] = trend_strength++ # Seasonality detection+ if len(revenues) >= 8:+ seasonality = detect_seasonality(revenues)+ features["seasonality"] = seasonality++ # Volatility clustering+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ volatility_clustering = analyze_volatility_clustering(earnings)+ features["volatility_clustering"] = volatility_clustering++ return features+++def create_cross_sectional_features(metrics: list, market_cap: float) -> dict:+ """Create cross-sectional ranking features"""+ features = {}++ if not metrics:+ return features++ latest = metrics[0]++ # Relative valuation features+ if latest.price_to_earnings and latest.price_to_earnings > 0:+ features["pe_percentile"] = min(max(1 - (latest.price_to_earnings / 25), 0), 1)++ # Size factor+ features["size_factor"] = min(math.log10(market_cap / 1_000_000_000), 2) / 2 # Normalize by $100B++ # Quality factor+ if latest.return_on_equity:+ features["quality_factor"] = min(latest.return_on_equity / 0.25, 1)++ return features+++def integrate_alternative_data_signals(features: dict) -> float:+ """Integrate alternative data signals (simulated)"""+ # Simulated alternative data integration+ base_score = features.get("revenue_momentum", 0) * features.get("margin_stability", 0.5)+ return min(base_score * 2, 2.0)+++def analyze_feature_interactions(features: dict) -> float:+ """Analyze feature interactions"""+ if not features:+ return 0++ # Simplified interaction analysis+ interaction_score = 0+ feature_values = [v for v in features.values() if isinstance(v, (int, float))]++ if feature_values:+ mean_feature = sum(feature_values) / len(feature_values)+ interaction_score = min(mean_feature * len(feature_values) / 5, 2.0)++ return interaction_score+++def simulate_random_forest_prediction(metrics: list, financial_line_items: list) -> float:+ """Simulate random forest model prediction"""+ if not metrics or not financial_line_items:+ return 0.5++ # Simplified RF prediction based on multiple factors+ latest = metrics[0]+ score = 0.5++ if latest.return_on_equity and latest.return_on_equity > 0.12:+ score += 0.2++ if latest.price_to_earnings and latest.price_to_earnings < 15:+ score += 0.15++ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 3 and revenues[0] > revenues[-1]:+ score += 0.1++ return min(max(score, 0), 1)+++def simulate_gradient_boosting_prediction(metrics: list, financial_line_items: list) -> float:+ """Simulate gradient boosting model prediction"""+ # Similar to RF but with different weighting+ rf_pred = simulate_random_forest_prediction(metrics, financial_line_items)+ # Add some variation to simulate different model+ return min(max(rf_pred + 0.05 - 0.1 * (rf_pred - 0.5), 0), 1)+++def simulate_neural_network_prediction(metrics: list, financial_line_items: list) -> float:+ """Simulate neural network model prediction"""+ # Non-linear combination+ rf_pred = simulate_random_forest_prediction(metrics, financial_line_items)+ # Sigmoid-like transformation+ return 1 / (1 + math.exp(-5 * (rf_pred - 0.5)))+++def simulate_lstm_prediction(financial_line_items: list) -> float:+ """Simulate LSTM time series prediction"""+ revenues = [item.revenue for item in financial_line_items if item.revenue]+ if len(revenues) >= 4:+ # Simple trend-based prediction+ recent_trend = (revenues[0] / revenues[2]) - 1+ return min(max(0.5 + recent_trend, 0), 1)+ return 0.5+++def calculate_ensemble_prediction(model_predictions: dict) -> float:+ """Calculate ensemble prediction from multiple models"""+ predictions = [v for k, v in model_predictions.items() if k != "ensemble" and isinstance(v, (int, float))]+ if predictions:+ return sum(predictions) / len(predictions)+ return 0.5+++def calculate_model_confidence(model_predictions: dict) -> float:+ """Calculate confidence based on model agreement"""+ predictions = [v for k, v in model_predictions.items() if k != "ensemble" and isinstance(v, (int, float))]+ if len(predictions) >= 2:+ mean_pred = sum(predictions) / len(predictions)+ variance = sum((p - mean_pred) ** 2 for p in predictions) / len(predictions)+ # Lower variance = higher confidence+ return max(0, 1 - variance * 4)+ return 0.5+++def calculate_model_agreement(model_predictions: dict) -> float:+ """Calculate agreement between models"""+ return calculate_model_confidence(model_predictions) # Same calculation+++def extract_feature_importance(model_predictions: dict) -> dict:+ """Extract feature importance from models"""+ return {+ "fundamental_strength": 0.7,+ "momentum": 0.5,+ "valuation": 0.6+ }+++def calculate_value_at_risk(financial_line_items: list) -> float:+ """Calculate Value-at-Risk"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ sorted_earnings = sorted(earnings)+ var_index = int(len(sorted_earnings) * 0.05) # 5th percentile+ if var_index < len(sorted_earnings):+ worst_case = sorted_earnings[var_index]+ max_earnings = max(earnings)+ if max_earnings > 0:+ return abs(worst_case - max_earnings) / max_earnings+ return 0.3+++def calculate_expected_shortfall(financial_line_items: list) -> float:+ """Calculate Expected Shortfall (Conditional VaR)"""+ var = calculate_value_at_risk(financial_line_items)+ return var * 1.3 # ES is typically higher than VaR+++def decompose_factor_risks_ml(metrics: list, financial_line_items: list) -> dict:+ """ML-based factor risk decomposition"""+ return {+ "market_beta": 0.8,+ "size_factor": 0.3,+ "value_factor": 0.4,+ "momentum_factor": 0.2,+ "quality_factor": 0.6,+ "idiosyncratic": 0.4+ }+++def calculate_diversification_benefits(financial_line_items: list) -> float:+ """Calculate diversification benefits"""+ return 0.6 # Placeholder+++def model_regime_dependent_risks(financial_line_items: list) -> dict:+ """Model risks under different regimes"""+ return {+ "bull_market_risk": 0.2,+ "bear_market_risk": 0.4,+ "recession_risk": 0.6,+ "inflation_risk": 0.3+ }+++def conduct_ml_stress_tests(financial_line_items: list) -> dict:+ """Conduct ML-based stress tests"""+ return {+ "worst_case_scenario": 0.8,+ "market_crash_scenario": 0.6,+ "liquidity_crisis": 0.7+ }+++def estimate_sharpe_ratio(metrics: list, financial_line_items: list) -> float:+ """Estimate expected Sharpe ratio"""+ if not metrics:+ return 1.0++ latest = metrics[0]+ if latest.return_on_equity:+ # Simple proxy for Sharpe ratio+ return min(latest.return_on_equity * 5, 3.0)++ return 1.0+++def calculate_risk_contribution(financial_line_items: list, market_cap: float) -> float:+ """Calculate risk contribution to portfolio"""+ # Based on market cap and volatility+ volatility = estimate_volatility(financial_line_items)+ size_factor = min(market_cap / 100_000_000_000, 1.0) # Normalize by $100B+ return volatility * (1 - size_factor)+++def optimize_transaction_costs(market_cap: float) -> float:+ """Optimize transaction costs"""+ if market_cap > 50_000_000_000:+ return 0.005+ elif market_cap > 10_000_000_000:+ return 0.01+ else:+ return 0.03+++def analyze_alpha_persistence(financial_line_items: list) -> float:+ """Analyze alpha persistence"""+ return 0.6 # Placeholder+++def assess_strategy_capacity(market_cap: float) -> float:+ """Assess strategy capacity"""+ return min(market_cap / 1_000_000_000, 1.0) # Based on liquidity+++def calculate_prediction_confidence_interval(model_predictions: dict) -> dict:+ """Calculate confidence intervals for predictions"""+ ensemble = model_predictions.get("ensemble", 0.5)+ std_dev = 0.1 # Estimated standard deviation++ return {+ "lower_bound": max(ensemble - 1.96 * std_dev, 0),+ "upper_bound": min(ensemble + 1.96 * std_dev, 1)+ }+++def calculate_coefficient_of_variation(data: list) -> float:+ """Calculate coefficient of variation"""+ if not data:+ return 1.0++ mean_val = sum(data) / len(data)+ if mean_val == 0:+ return 1.0++ variance = sum((x - mean_val) ** 2 for x in data) / len(data)+ std_dev = math.sqrt(variance)++ return std_dev / abs(mean_val)+++def calculate_trend_strength(data: list) -> float:+ """Calculate trend strength"""+ if len(data) < 3:+ return 0++ # Simple linear trend+ n = len(data)+ x_mean = (n - 1) / 2+ y_mean = sum(data) / n++ numerator = sum((i - x_mean) * (data[i] - y_mean) for i in range(n))+ denominator = sum((i - x_mean) ** 2 for i in range(n))++ if denominator == 0:+ return 0++ slope = numerator / denominator+ return min(abs(slope) / (y_mean if y_mean != 0 else 1), 1.0)+++def detect_seasonality(data: list) -> float:+ """Detect seasonality in data"""+ if len(data) < 8:+ return 0++ # Simple quarterly seasonality check+ q1_avg = sum(data[i] for i in range(0, len(data), 4)) / ((len(data) + 3) // 4)+ q2_avg = sum(data[i] for i in range(1, len(data), 4)) / ((len(data) + 2) // 4)++ if q1_avg > 0:+ return min(abs(q2_avg - q1_avg) / q1_avg, 1.0)++ return 0+++def analyze_volatility_clustering(data: list) -> float:+ """Analyze volatility clustering"""+ if len(data) < 4:+ return 0++ # Calculate rolling volatility+ volatilities = []+ for i in range(2, len(data)):+ recent_vol = abs(data[i] - data[i - 1])+ volatilities.append(recent_vol)++ if volatilities:+ return min(calculate_coefficient_of_variation(volatilities), 1.0)++ return 0+++def estimate_volatility(financial_line_items: list) -> float:+ """Estimate volatility from financial data"""+ earnings = [item.net_income for item in financial_line_items if item.net_income]+ if earnings:+ return calculate_coefficient_of_variation(earnings)+ return 0.3+++def generate_two_sigma_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> TwoSigmaSignal:+ """Generate Two Sigma's machine learning investment decision"""+ template = ChatPromptTemplate.from_messages([+ ("system", """You are Two Sigma's AI system, implementing scientific machine learning approach to investing:++ ORGANIZATIONAL STRUCTURE:+ - Data Science Team: Feature engineering and alternative data integration+ - ML Engineering Team: Ensemble models and prediction algorithms+ - Risk Modeling Team: Value-at-Risk and factor risk analysis+ - Portfolio Optimization Team: Mean-variance and transaction cost optimization+ - Scientific Method Synthesis: Hypothesis testing and Bayesian inference++ PHILOSOPHY:+ 1. Data-Driven Decisions: All investment decisions based on data and models+ 2. Machine Learning: Advanced ML algorithms for pattern recognition+ 3. Scientific Method: Hypothesis testing and statistical significance+ 4. Alternative Data: Integration of non-traditional data sources+ 5. Risk Management: Sophisticated quantitative risk models+ 6. Technology Focus: Cutting-edge technology and research+ 7. Academic Rigor: PhD-level research and peer review process++ REASONING STYLE:+ - Reference machine learning model predictions and confidence levels+ - Discuss feature engineering and alternative data signals+ - Apply statistical significance testing and confidence intervals+ - Consider ensemble model predictions and cross-validation+ - Express reasoning in probabilistic terms+ - Acknowledge model limitations and overfitting risks+ - Focus on scientific hypothesis testing framework++ Return investment signal with ML model predictions and confidence metrics."""),++ ("human", """Apply Two Sigma's machine learning analysis to {ticker}:++ {analysis_data}++ Provide investment signal in JSON format:+ {{+ "signal": "bullish" | "bearish" | "neutral",+ "confidence": float (0-100),+ "reasoning": "string",+ "ml_model_predictions": {{+ "ensemble_prediction": float,+ "model_confidence": float,+ "random_forest": float,+ "gradient_boosting": float,+ "neural_network": float,+ "lstm": float+ }}+ }}""")+ ])++ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})++ def create_default_two_sigma_signal():+ return TwoSigmaSignal(+ signal="neutral",+ confidence=0.0,+ reasoning="Analysis error, defaulting to neutral",+ ml_model_predictions={+ "ensemble_prediction": 0.5,+ "model_confidence": 0.0,+ "random_forest": 0.5,+ "gradient_boosting": 0.5,+ "neural_network": 0.5,+ "lstm": 0.5+ }+ )++ return call_llm(+ prompt=prompt,+ pydantic_model=TwoSigmaSignal,+ agent_name=agent_id,+ state=state,+ default_factory=create_default_two_sigma_signal,+ )\ No newline at end of file